Erste Schritte
Verbinden & Basisbefehle
Memcached nutzt ein einfaches Textprotokoll auf Port 11211. Der set-Befehl nimmt flags (32-Bit-Ganzzahl, für den Server opak), exptime (Ablauf in Sekunden, 0 = ohne Ablauf) und die Byte-Größe. Werte werden als rohe Bytes gespeichert — der Server prüft oder verändert sie nie. memcached-tool wird mit dem Server mitgeliefert und ist praktisch für schnelle Statistiken.
# connect to a memcached server
telnet localhost 11211
# or use the memcached-tool (ships with the server)
memcached-tool localhost:11211 stats
# set a key (flags, exptime, bytes)
set mykey 0 3600 5
hello
# get a key
get mykey
# delete a key
delete mykeyProtokollübersicht
Memcached unterstützt sowohl ein ASCII-Textprotokoll (einfach mit telnet/netcat nutzbar) als auch ein Binärprotokoll (effizienter, unterstützt SASL-Authentifizierung und atomare Operationen). Das Binärprotokoll verwendet einen festen 24-Byte-Header und wird von den meisten Produktions-Clients bevorzugt. Beide Protokolle arbeiten auf demselben zugrunde liegenden Key-Value-Store.
# Two protocols available:
# 1) ASCII text protocol (human-readable, telnet-friendly)
# 2) Binary protocol (lower overhead, SASL auth, request pipelining)
# text protocol example
set foo 0 0 3
bar
# -> STORED
# binary protocol needs a client (e.g. python binary protocol):
# 0x80 (request) | opcode | keylen | extras | datatype | reserved
# bodylen | opaque | cas | extras | key | value
# both share the same in-memory data store
# check server version (text)
version
# -> VERSION 1.6.24Schlüsselregeln & Grenzen
Schlüssel sind auf 250 Bytes begrenzt und dürfen im Textprotokoll keine Leerzeichen oder Steuerzeichen enthalten. Die Standard-Maximalgröße für Werte ist 1 MB (erhöhen mit dem Flag -I, z. B. -I 4m). Schlüssel werden nicht kopiert — Memcached speichert sie inline, längere Schlüssel verbrauchen also mehr Speicher. Nutze kurze, strukturierte Schlüssel wie user:1001 statt ausschweifender Beschreibungen.
# Keys: max 250 bytes, no spaces or newlines (text protocol)
# Controls: max 1MB default value (configurable via -I)
# valid keys
set user:1001 0 0 5
alice
set product:sku-42 0 0 3
xyz
# INVALID keys (text protocol)
# set "with spaces" ... -> spaces not allowed
# set mykey\n ... -> newlines not allowed
# large value exceeds 1MB default
set bigkey 0 0 1048577
# -> SERVER_ERROR object too large for cache
# increase max item size at startup (-I in MB)
# memcached -m 256 -I 4mTypische Anwendungsfälle
Memcached eignet sich am besten zum Cachen flüchtiger, abgeleiteter Daten: Datenbank-Abfrageergebnisse, Sessions, gerenderte Seitenfragmente, Rate-Limit-Zähler und teure Berechnungen. Es ist bewusst simpel — keine Persistenz, keine Replikation, keine komplexen Datentypen. Behandle es als flüchtigen LRU-Cache: Speichere niemals Daten, die du nicht aus einem System of Record wiederherstellen kannst.
# 1) Database query cache
set user:1001:profile 0 600 48
{"id":1001,"name":"Alice","email":"[email protected]"}
# 2) Session storage (with TTL)
set sess:abc123 0 1800 64
{"userId":1001,"loginAt":1700000000,"role":"admin"}
# 3) Rendered HTML fragment cache
set page:home:en 0 300 128
<html><body>Hello</body></html>
# 4) Rate-limit counters
incr ratelimit:ip:1.2.3.4 1
# 5) Computed result cache (expensive aggregation)
set report:daily:20240101 0 3600 256
{"visits":1234,"signups":56}Architekturübersicht
Memcached ist ein verteilter Cache aus unabhängigen, nicht koordinierten Servern. Im Server selbst gibt es kein Clustering, keine Replikation und kein Failover — die gesamte Verteilungslogik liegt im Client (consistent hashing). Jeder Knoten besitzt einen disjunkten Ausschnitt des Keyspaces; stirbt ein Knoten, sind seine Daten verloren und Clients leiten um. Das hält den Server radikal einfach und schnell, auf Kosten der Dauerhaftigkeit.
# Memcached is a pool of independent servers (no clustering built-in)
#
# +---------+ +---------+ +---------+
# | mc:11211| | mc:11211| | mc:11211|
# +---------+ +---------+ +---------+
# ^ ^ ^
# | | |
# +----+------------+-------------+----+
# | CLIENT (consistent hashing) |
# +------------------------------------+
#
# - Each server owns a disjoint slice of the keyspace
# - Sharding is done by the CLIENT (consistent hashing)
# - Servers do NOT talk to each other (no replication, no failover)
# - A server down = its keys are lost; clients reroute to the ring
# horizontal scale = add more servers to the ring
# vertical scale = bigger -m memory per serverBasisbefehle (set / get / delete)
set — Wert speichern
set speichert bedingungslos einen Wert und überschreibt einen vorhandenen Schlüssel. flags ist eine 32-Bit-Ganzzahl, die der Server speichert, aber nie interpretiert — Clients nutzen sie, um das Serialisierungsformat zu codieren (z. B. 1 = JSON, 2 = komprimiert). exptime 0 bedeutet kein Ablauf; ein Unix-Zeitstempel > 30 Tage gilt als absolute Zeit. noreply überspringt die Antwort für Fire-and-Forget-Schreibvorgänge (schneller, aber keine Fehlerberichterstattung).
# syntax: set <key> <flags> <exptime> <bytes> [noreply]\r\n<data>\r\n
# response: STORED | NOT_STORED
set greeting 0 0 5
hello
# -> STORED
# with flags (app-defined 32-bit int, e.g. mark as JSON=1)
set config 1 0 14
{"a":1,"b":2}
# -> STORED
# with expiration (3600 seconds) and noreply
set token 0 3600 8 noreply
s3cr3t00
# -> (no response)
# overwrite an existing key
set greeting 0 0 7
goodbye
# -> STOREDget — Werte abrufen
get ruft einen oder mehrere Schlüssel in einem einzigen Round-Trip ab — Batching (multi-get) ist entscheidend für die Performance. Jede zurückgegebene VALUE-Zeile echo-t die flags, damit der Client weiß, wie er deserialisiert. Fehlende Schlüssel werden stillschweigend ausgelassen (kein Fehler). Die Antwort endet mit END. Große Multi-Gets sollten in Häppchen aufgeteilt werden, damit kein einzelner Server-Thread blockiert.
# single key
get greeting
# VALUE greeting 0 7
# goodbye
# END
# multiple keys in one request (batched)
get user:1 user:2 user:3
# VALUE user:1 0 5
# alice
# VALUE user:3 0 3
# bob
# END (user:2 missing -> simply omitted)
# response format: VALUE <key> <flags> <bytes>\r\n<data>\r\n ... END
# flags lets the client decode (e.g. decompress / parse JSON)
# non-existent key
get nope
# END (no VALUE line at all)gets — Abrufen mit CAS-Token
gets (get-extended) ist identisch zu get, hängt aber an jede VALUE-Zeile ein cas_unique-Token an. Diese 64-Bit-Ganzzahl ändert sich bei jedem Schreibvorgang und ist die Grundlage der optimistischen Nebenläufigkeit von Memcached (CAS). Verwende gets + cas gemeinsam, um verlorene Updates zu vermeiden, wenn mehrere Clients denselben Schlüssel ändern. Das Token ist opak — nimm nie einen Wert oder eine Monotonie über Schlüssel hinweg an.
# gets returns a CAS unique identifier for optimistic concurrency
gets greeting
# VALUE greeting 0 7 12
# goodbye
# END
# ^ cas_unique = 12
# the cas_unique changes every time the key is written
set greeting 0 0 5
hello
gets greeting
# VALUE greeting 0 5 13
# hello
# END (cas_unique is now 13)
# use cas_unique with the cas command for safe updates
cas greeting 0 0 5 13
world
# -> STOREDdelete — Schlüssel entfernen
delete entfernt einen einzelnen Schlüssel und liefert DELETED oder NOT_FOUND. Es gibt kein Wildcard- oder Musterlöschen — Memcached hat überhaupt keinen Befehl zur Schlüsselaufzählung, daher muss Massenlöschung von der Anwendung getrackt werden (ein Set von Schlüsseln woanders pflegen oder Namensraum-Flush-Muster nutzen). noreply ergänzen, um die Antwort zu überspringen. Gelöschter Speicher geht an seinen Slab zurück und wird wiederverwendet.
# delete a single key
delete greeting
# -> DELETED
# delete a non-existent key
delete nope
# -> NOT_FOUND
# with noreply (fire-and-forget)
delete stalekey 0 noreply
# -> (no response)
# delete does NOT support patterns or wildcards
# delete user:* <- INVALID, only deletes a key literally named "user:*"
# to bulk-delete, list keys yourself then delete each
# (memcached has no KEYS/SCAN command — track keys in your app)touch & gat — Ablauf aktualisieren
touch (1.4.8+) aktualisiert den Ablauf eines Schlüssels, ohne den Wert zu übertragen — billiger als get+set für Session-Refresh. gat holt den Wert und aktualisiert den TTL atomar in einem Round-Trip, ideal für Session-Lesevorgänge, deren Lebensdauer verlängert werden soll. gats liefert zusätzlich das CAS-Token. Nutze diese statt get+set, um eine Race zu vermeiden, bei der sich der Wert zwischen den Operationen ändert.
# touch: change a key's expiration without fetching the value
touch session 3600
# -> TOUCHED
touch session 0 # make it never expire
# -> TOUCHED
# gat: get-and-touch — fetch value AND update expiration in one op
gat 3600 session
# VALUE session 0 64
# {...}
# END
# gats: get-and-touch with CAS token
gats 3600 session
# VALUE session 0 64 42
# {...}
# END
# touch a missing key
touch nope 60
# -> NOT_FOUNDSpeicherbefehle (add / replace / append / prepend)
add — Nur speichern, wenn nicht vorhanden
add speichert einen Wert nur, wenn der Schlüssel NOCH NICHT existiert, sonst NOT_STORED. Es ist der kanonische Weg, Schlüssel (Zähler, Locks) lazy ohne Race zu initialisieren. Kombiniert mit incr/decr ergibt sich ein sicheres Zählermuster: add zum Anlegen mit 0, dann incr. Anders als Redis SETNX hat add keinen TTL-Kurzbefehl — setze exptime im Befehl.
# add fails if the key already exists
add newkey 0 0 5
hello
# -> STORED
add newkey 0 0 5
world
# -> NOT_STORED (key already exists)
# common pattern: initialize a counter only once
add counter:daily 0 0 1
0
# -> STORED on first run, NOT_STORED after
# then use incr to bump it
incr counter:daily 1
# -> 1replace — Nur speichern, wenn vorhanden
replace speichert einen Wert nur, wenn der Schlüssel BEREITS existiert — das Spiegelbild von add. Es verhindert, dass ein veralteter Update-Pfad versehentlich einen Cache-Eintrag erzeugt. Bei fehlendem Schlüssel folgt NOT_STORED. Verwende es, wenn ein Schreibvorgang den bestehenden Cache auffrischen, aber nie einen neuen Eintrag füllen soll (z. B. ein Hintergrund-Refresh, der einen verdrängten Schlüssel nicht wiederbeleben soll).
# replace fails if the key does NOT exist
replace missing 0 0 5
hello
# -> NOT_STORED (key doesn't exist)
set existing 0 0 3
foo
# -> STORED
replace existing 0 0 3
bar
# -> STORED (key existed, value updated)
# useful for updating cached data only if it was already cached
# (don't accidentally create a cache entry from a stale write)
replace cached:user:1 0 600 64
{"name":"Alice"}append — An bestehenden Wert anhängen
append hängt Daten an das Ende eines bestehenden Werts an und liefert NOT_STORED, wenn der Schlüssel fehlt. Die Argumente flags und exptime werden akzeptiert, aber ignoriert — der Wert behält seine ursprünglichen Metadaten. Damit baust du Logzeilen oder Puffer in place, ohne Read-Modify-Write. Achtung: Der entstehende Wert muss weiterhin unter der 1-MB-Item-Grenze bleiben.
# append adds data to the END of an existing value
set logline 0 0 5
hello
# -> STORED
append logline 0 0 6
world
# -> STORED
get logline
# VALUE logline 0 11
# hello world
# END
# append to a non-existent key
append nolog 0 0 3
abc
# -> NOT_STORED (key must exist)
# flags and exptime are IGNORED on append/prepend (value keeps old metadata)prepend — Vor bestehenden Wert stellen
prepend ist das Spiegelbild von append — es hängt Daten an den ANFANG eines bestehenden Werts. Wie append verlangt es einen existierenden Schlüssel und ignoriert flags/exptime. Nützlich, um Header/Präfixe auf einen gepufferten Wert zu stapeln. append und prepend sind KEIN atomares clientübergreifendes Read-Modify-Write, da sie das Ergebnis nicht zurückgeben — aber sie sind serverseitig atomare Operationen.
# prepend adds data to the START of an existing value
set greeting 0 0 5
world
# -> STORED
prepend greeting 0 0 6
hello
# -> STORED
get greeting
# VALUE greeting 0 11
# hello world
# END
# prepend to non-existent key
prepend nope 0 0 3
abc
# -> NOT_STORED
# flags/exptime ignored — only the value bytes changeVergleich der Speicherbefehle
Memcacheds sechs Speicherbefehle (set, add, replace, append, prepend, cas) unterscheiden sich nur in ihrer Vorbedingung zum Speichern. set ist bedingungslos; add/replace sind existenzgebunden; append/prepend ändern in place und ignorieren Metadaten; cas ist an das CAS-Token aus gets gebunden. Die richtige Wahl macht aus einer Read-Modify-Write-Race eine einzelne atomare Serveroperation.
# When does each command succeed?
#
# set -> ALWAYS (create or overwrite)
# add -> only if key does NOT exist
# replace -> only if key ALREADY exists
# append -> only if key exists (adds to end, ignores flags/exptime)
# prepend -> only if key exists (adds to start, ignores flags/exptime)
#
# All return STORED / NOT_STORED / EXISTS / NOT_FOUND as appropriate.
# set: overwrite unconditionally
# add: lazy init (counters, locks)
# replace: refresh only if already cached
# append: grow a buffer / log
# prepend: stack headers
# all accept [noreply] to skip the responseCAS (Compare-And-Swap)
gets — CAS-Token holen
gets (get-extended) ist die Leseseite von CAS. Es liefert den Wert plus ein cas_unique-64-Bit-Token, das der Server garantiert bei jeder Änderung dieses Schlüssels ändert. Du fängst dieses Token ein und gibst es an cas zurück; stimmt das Token noch, gelingt dein Schreibvorgang. Ohne gets ist kein sicheres CAS möglich — ein einfaches get lässt das Token weg.
# gets is get + a 64-bit cas_unique token
gets counter
# VALUE counter 0 1 7
# 5
# END
# ^ cas_unique = 7
# the token is opaque and changes on EVERY write to the key
set counter 0 0 1
5
gets counter
# VALUE counter 0 1 8 <- token changed to 8
# fetch multiple keys with tokens in one call
gets a b c
# VALUE a 0 3 11
# ...
# VALUE c 0 3 19
# ...cas — Bedingtes Schreiben
cas schreibt einen Wert nur, wenn das cas_unique-Token noch dem von gets zurückgegebenen entspricht. STORED heißt, der Schreibvorgang wurde angewendet; EXISTS heißt, ein anderer Client hat den Schlüssel zuerst geändert (Token-Mismatch); NOT_FOUND heißt, der Schlüssel wurde gelöscht. Das ist optimistisches Locking — bei EXISTS die ganze gets→modify→cas-Schleife wiederholen. So vermeidest du verlorene Updates ohne serverseitiges Locking.
# syntax: cas <key> <flags> <exptime> <bytes> <cas_unique> [noreply]
gets counter
# VALUE counter 0 1 8 <- token is 8
# 5
cas counter 0 0 1 8
6
# -> STORED (token matched, write applied)
# a concurrent write changed the token in the meantime
cas counter 0 0 1 8 # stale token 8, but key is now on token 9
6
# -> EXISTS (token mismatch, someone else wrote first)CAS-Anwendungsfall: Sichere Zähler
CAS löst das Lost-Update-Problem, wenn du Read-Modify-Write-Semantik brauchst (z. B. ein JSON-Blob in einem Cache-Eintrag aktualisieren). Bei EXISTS musst du mit gets neu lesen, deine Transformation erneut anwenden und cas wiederholen — typischerweise mit begrenzter Retry-Anzahl, um Live-Lock zu vermeiden. Für reine Ganzzahl-Zähler sind incr/decr einfacher und atomar; CAS erst greifen, wenn der Wert strukturiert ist.
# read-modify-write with get+set is RACY:
# get counter -> 5 (client A)
# get counter -> 5 (client B)
# set counter 6 (A writes 6)
# set counter 6 (B writes 6, LOST A's increment!)
# safe pattern with gets/cas:
gets counter # token = 8, value = 5
newval = 5 + 1
cas counter 0 0 1 8 # 8 -> STORED, value = 6
# on EXISTS, retry the whole loop:
gets counter # token = 9, value = 6
cas counter 0 0 1 9 # -> STORED, value = 7
# for plain counters prefer incr/decr (atomic, no CAS needed)CAS-Fehler & Wiederholung
Eine robuste CAS-Schleife muss drei Ausgänge behandeln: fehlender Schlüssel (add verwenden, bei NOT_STORED auf Retry fallen), Token-Treffer (STORED, fertig) und Token-Mismatch (EXISTS, wiederholen). Retries begrenzen, um Live-Lock unter Contention zu vermeiden. Fehlt der Schlüssel wirklich, lieber add statt set, damit sich zwei Client-Rennen beim Anlegen nicht gegenseitig überschreiben.
# pseudocode for a CAS retry loop
max_retries = 5
for i in range(max_retries):
res = client.gets(key) # value + cas token
if res is None:
# key missing -> use add to create it race-free
if client.add(key, new_value, ttl):
break
else:
continue # someone else created it; retry
old_val, cas_token = res
new_val = transform(old_val) # your read-modify logic
if client.cas(key, new_value, ttl, cas_token):
break # STORED
# else EXISTS -> loop and retry
else:
raise Exception("CAS failed after retries")CAS-Grenzen
CAS funktioniert nur pro Schlüssel — Memcached hat keine Mehrschlüssel-Transaktionen wie Redis MULTI/EXEC. Es ist optimistisch, nicht pessimistisch: Bei starker Contention treffen viele Schreibvorgänge auf EXISTS und wiederholen — Hot Keys daher sharden. cas_unique ist schlüsselbezogen und opak; vergleiche es nie über Schlüssel hinweg und nimm keine Ordnung an. Wird ein Schlüssel verdrängt und neu erzeugt, setzt das Token zurück — behandle NOT_FOUND also als Neustart, nicht als Fehler.
# 1) CAS only protects a SINGLE key — no multi-key transactions
# (memcached has no MULTI/EXEC like Redis)
#
# 2) CAS tokens are per-key and opaque — never compare across keys
#
# 3) CAS does NOT lock the key; it's optimistic — high contention
# means many retries (consider sharding the hot key)
#
# 4) The binary protocol exposes cas more cleanly; some ASCII quirks
# exist in older servers
#
# 5) cas_unique may RESET if a key is evicted and re-created —
# treat absence (NOT_FOUND) as a fresh start, not a token failure
# for multi-key atomicity, use app-level locks (e.g. add-based lock)Zähler (incr / decr)
incr — Atomares Hochzählen
incr addiert atomar eine positive Ganzzahl zu einem Schlüssel, dessen Wert ein Dezimalstring ist, und liefert den neuen Wert. Die Operation ist vollständig atomar über gleichzeitige Clients — keine verlorenen Updates. Der Wert muss ein vorzeichenloser 64-Bit-Numerik-ASCII-String sein (keine Vorzeichen, keine Dezimalstellen). incr auf fehlendem Schlüssel liefert NOT_FOUND; bei nicht-numerischen Daten bricht es ab. Kein Auto-Anlegen — vorher add verwenden.
# syntax: incr <key> <value> [noreply]
# the key's value MUST be a numeric string (ASCII digits)
set views 0 0 1
5
# -> STORED
incr views 1
# -> 6
incr views 10
# -> 16
# returns the NEW value as a decimal string
# incrementing a non-numeric value
set name 0 0 5
alice
incr name 1
# -> CLIENT_ERROR cannot increment or decrement non-numeric value
# incr on a missing key
incr missing 1
# -> NOT_FOUNDdecr — Atomares Herunterzählen
decr subtrahiert atomar von einem numerischen Wert und liefert das Ergebnis. Es ist bei 0 nach unten geklemmt — nie negativ, praktisch für Bestandszähler, aber decr kann keine negativen Netto-Salden tracken. Wie incr verlangt es ASCII-Ziffern als Wert und einen existierenden Schlüssel (sonst NOT_FOUND).
# syntax: decr <key> <value> [noreply]
set views 0 0 2
16
# -> STORED
decr views 1
# -> 15
decr views 10
# -> 5
# decr NEVER goes negative — stops at 0
decr views 100
# -> 0
# decr a missing key
decr missing 1
# -> NOT_FOUND
# decr a non-numeric value -> CLIENT_ERRORZähler initialisieren
Weil incr/decr bei fehlendem Schlüssel NOT_FOUND liefern, müssen Zähler mit add initialisiert werden (race-frei: der erste Aufrufer legt mit 0 an, andere erhalten NOT_STORED und springen direkt zu incr). Initialisiere einen Zähler, den du auch incr-st, niemals mit set — set überschreibt bedingungslos und racet mit gleichzeitigen Increments. Zähler nach Datum namespacen und mit TTL versehen, damit sie automatisch ablaufen.
# incr/decr do NOT create keys — initialize with add first
# race-free counter init: add creates at "0" only if absent
add counter:daily 0 86400 1
0
# -> STORED (first caller wins) or NOT_STORED (already exists)
# now safe to increment from any client
incr counter:daily 1
# -> 1
# alternative: set then incr (but set+incr is racy for resets)
# For a daily counter, key by date so it auto-expires:
# counter:2024-01-01
# counter:2024-01-02Zähler-Anwendungsfälle
Zähler glänzen beim Rate-Limiting (Schlüssel nach IP+Minute mit 60-s-TTL), bei View/Download-Statistiken, Daily-Active-Zählungen, Beständen und Rollout-Metriken. Sie sind atomar und billig und skalieren auf sehr hohe Schreibraten. Wähle fürs Rate-Limiting eine Schlüsselgranularität (pro Nutzer, pro IP) und TTL passend zum Fenster — und bedenke, dass decr bei 0 klemmt, Bestände also nie negativ werden.
# rate limiting (per IP per minute)
add ratelimit:1.2.3.4:2024010112 0 60 1
0
incr ratelimit:1.2.3.4:2024010112 1
# if result > 100 -> reject request
# view/download counters
incr article:42:views 1
# daily active users (with a SET of user ids tracked elsewhere)
incr dau:20240101 1
# inventory / stock (decrement on purchase)
decr product:42:stock 1
# if result == 0 -> out of stock
# feature-flag rollout counters
incr flag:newui:shown 1Zähler-Grenzen
Zähler sind nur vorzeichenlose 64-Bit-Ganzzahlen — keine Floats, keine Negativen, keine Vorzeichen. incr/decr legen niemals automatisch einen Schlüssel an. decr klemmt bei 0. Da der Wert nur ein String ist, überschreibt ein abirrendes set/replace ihn und vernichtet gleichzeitige Increments — mit add initialisieren und sonst ausschließlich incr/decr verwenden. Für Floats oder Mehrfeld-Zähler lieber CAS auf einem strukturierten Wert.
# 1) values must be unsigned 64-bit integers (no decimals, no signs)
# incr/decr on "3.14" or "-5" -> CLIENT_ERROR
#
# 2) no auto-create — must add/set first; incr on missing = NOT_FOUND
#
# 3) decr floors at 0 — cannot represent negative balances
#
# 4) the counter is just a string; set/add/replace/cas OVERWRITE it,
# which can clobber concurrent incr/decr (use add only to init)
#
# 5) for float counters or complex updates, use CAS on a JSON blob
# to RESET a counter, use set (not decr-to-zero) — but watch for racesAblauf & TTL
set mit Ablauf
exptime ist in Sekunden: 0 heißt nie ablaufen, Werte bis 2592000 (30 Tage) sind relative TTLs, größere werden als absolute Unix-Zeitstempel interpretiert. Abgelaufene Items werden nicht exakt zur Sekunde aktiv entfernt — Memcached nutzt lazy Expiration (geprüft beim Zugriff) plus einen LRU-Crawler im Hintergrund, daher kann ein veralteter Schlüssel liegen bleiben, bis er berührt oder verdrängt wird.
# exptime is the 4th arg to all storage commands (seconds)
# 0 = no expiration (live until evicted)
set session 0 0 5 # never expire
alice
set session 0 1800 5 # expire in 1800 seconds (30 min)
alice
# exptime > 30 days (2592000 s) is treated as a UNIX timestamp
set archive 0 1735689600 5 # expires at 2025-01-01 00:00 UTC
alice
# common TTLs
# 60 -> 1 minute (rate limit windows)
# 3600 -> 1 hour (short cache)
# 86400 -> 1 day (daily cache)
# 0 -> forever (until LRU evicts)touch — TTL aktualisieren
touch (1.4.8+) aktualisiert die TTL eines Schlüssels in place, ohne den Wert zu übertragen — deutlich billiger als get+set für Sliding-Window-Sessions. exptime auf 1 setzen ergibt ein Soft-Delete (sofort abgelaufen). Dieselbe 30-Tage-Regel (relativ vs. absolut) gilt. touch liefert bei fehlenden Schlüsseln NOT_FOUND, Aufrufer sollten das als 'nicht gecacht' behandeln.
# touch: change a key's TTL without fetching the value
# syntax: touch <key> <exptime> [noreply]
set session 0 3600 5
alice
# extend the session by another hour
touch session 3600
# -> TOUCHED
# make it never expire
touch session 0
# -> TOUCHED
# expire it immediately (poor man's delete via TTL)
touch session 1
# -> TOUCHED (effectively deleted on next access)
touch missing 60
# -> NOT_FOUNDgat & gats — Get und Touch
gat (1.6+) kombiniert get und touch atomar in einem Round-Trip — perfekt für Session-Lesevorgänge, die den Ablauf nach hinten schieben sollen. gats liefert zusätzlich das CAS-Token. get+touch getrennt erzeugt ein Fenster, in dem die TTL nicht erneuert wird, und verdoppelt die Round-Trips; gat behebt beides. Für Mehrschlüssel-Sliding-Reads nimmt gat mehrere Schlüssel.
# gat: fetch value AND update TTL in one round-trip
# syntax: gat <exptime> <key>
gat 3600 session
# VALUE session 0 5
# alice
# END
# gats: get-and-touch with CAS token
gats 3600 session
# VALUE session 0 5 42
# alice
# END
# ideal for session reads that should refresh the TTL:
# - one network round-trip instead of get + touch
# - atomic: no window where TTL isn't refreshed
# multiple keys: gat <exptime> <key1> <key2> ...
gat 3600 a b cAblaufverhalten
Expiration ist bei Memcached standardmäßig lazy — ein Schlüssel wird erst beim Zugriff entfernt, d. h. veraltete Daten können Speicher belegen, bis sie verdrängt werden. Der LRU-Crawler (1.4.24+) ergänzt einen Hintergrund-Sweep, der abgelaufene Items pro Slab proaktiv freigibt und Speicherverschwendung verhindert. In Produktion aktivieren: lru_crawler enable. Trotzdem: Verlass dich für Korrektheit nie auf exaktes Expiry-Timing.
# Memcached does NOT actively scan for expired keys every second.
# Expiration is LAZY: a key is checked when accessed (get/gets/touch).
#
# A background "LRU crawler" (1.4.24+) periodically sweeps slabs to
# free expired items so memory is reclaimed even if never accessed.
#
# stats lru_crawler # is the crawler enabled?
# lru_crawler enable # turn it on
# lru_crawler sleep 100 # microseconds between slab visits
# lru_crawler tocrawl 1000 # max items to inspect per slab per pass
# an expired-but-not-yet-reaped key:
get expiredkey
# -> END (treated as missing, memory freed for its slab)TTL-Best-Practices
Immer eine TTL setzen — unbegrenzte Cache-Einträge führen zu unbegrenztem Speicherwachstum und Stale-Data-Bugs. TTLs zufälliges Jitter (±5–10%) geben, damit korrelierte Ablaufzeiten den Origin nicht unter Beschuss nehmen. Flüchtige Daten nach Datum namespacen, damit alte Einträge automatisch ablaufen. Bei Miss im selben Codepfad neu berechnen und speichern, um den Cache warm zu halten. Für explizites Invalidieren delete verwenden, nicht TTL=1.
# 1) ALWAYS set a TTL on cache entries — never store forever (0)
# unless you have an explicit invalidation path.
#
# 2) add jitter to avoid thundering herds:
ttl = base_ttl + random(0, 300) # +/- 5 minutes
#
# 3) namespace by time so old keys auto-expire:
set report:2024-01-01 0 86400 N # yesterday's report, 1-day TTL
#
# 4) use longer TTLs for stable data, shorter for volatile data
#
# 5) on a cache miss, recompute AND set with TTL in ONE path
#
# 6) don't use exptime=1 as a "delete" in production — use deleteStats-Befehle
stats — Übersicht
stats wirft die zentralen Servermetriken aus: cmd_get/cmd_set (Operationen insgesamt), get_hits/get_misses (Hit Rate = hits/cmd_get), evictions (Items, die unter Speicherdruck fallen gelassen wurden), curr_items, bytes vs. limit_maxbytes und Verbindungsanzahlen. Hit Rate und Evictions sind die beiden Zahlen, die man zuerst beobachtet. Das Fundament jedes Memcached-Monitorings.
# general server statistics
stats
# STAT pid 1234
# STAT uptime 3600
# STAT curr_connections 10
# STAT total_connections 1024
# STAT cmd_get 50000
# STAT cmd_set 12000
# STAT get_hits 45000
# STAT get_misses 5000
# STAT evictions 12
# STAT bytes 8388608
# STAT limit_maxbytes 67108864
# STAT curr_items 4321
# ...
# END
# hit rate = get_hits / cmd_get (here 90%)
# watch evictions — rising = memory pressurestats items — Item-Anzahlen pro Slab
stats items meldet für jede Slab-Klasse, wie viele Items sie hält (number) und wie alt ihr am längsten nicht erneuertes Item ist (age). Eine Slab mit hoher Zahl, aber niedrigem Alter wird durchgerührt; eine Slab mit hohem Alter hält langlebige Daten. Erster Anlaufpunkt beim Tuning der Chunk-Größen oder wenn geklärt werden soll, warum ein bestimmter Größenbereich verdrängt wird.
# item counts and age per slab class
stats items
# STAT items:1:number 100
# STAT items:1:age 1200
# STAT items:2:number 250
# STAT items:2:age 3600
# STAT items:5:number 3
# STAT items:5:age 60
# ...
# END
# items:<slabid>:number -> how many items live in that slab class
# items:<slabid>:age -> age of the LRU item (seconds since stored)
# use this to see which size classes are full / hotstats slabs — Slab-Allocator-Status
stats slabs offenbart das Layout des Slab-Allocators: Jede Klasse hat eine chunk_size (Item-Slots werden darauf aufgerundet), chunks_per_page, total_pages und used/free chunks. Einer Slab-Klasse zugewiesener Speicher bleibt dort — er kann anderen Klassen nicht zurückgegeben werden. Ist eine Klasse voll und verdrängt, während eine andere leer bleibt, liegt Slab-Verkalkung vor, behandelbar durch Tuning von -f (growth factor).
# memory layout of each slab class
stats slabs
# STAT 1:chunk_size 96
# STAT 1:chunks_per_page 10922
# STAT 1:total_pages 1
# STAT 1:total_chunks 10922
# STAT 1:used_chunks 100
# STAT 1:free_chunks 10822
# STAT 2:chunk_size 120
# ...
# STAT active_slabs 5
# STAT total_malloced 16777216
# END
# chunk_size -> bytes per item slot in this class
# total_chunks -> total slots
# used_chunks -> slots holding data
# free_chunks -> empty slotsstats sizes — Item-Größen-Histogramm
stats sizes baut ein Histogramm der echten Item-Größen (Schlüssel+Wert+Overhead), sodass du siehst, wie viel Speicher durch Chunk-Größen-Aufrundung verloren geht. Es führt einen vollständigen Scan durch und sperrte historisch den Server — moderne Versionen schalten es hinter einen Safe-Mode-Check frei; mit --disable-safe-mode erzwingen. Nur bei niedrigem Traffic ausführen. Die Ausgabe hilft, den passenden -f-Growth-Factor zu wählen.
# histogram of actual item sizes (key + value + overhead)
# WARNING: this command locks the cache while scanning — do NOT run
# in production at peak. Use stats sizes --disable-safe-mode only
# if you accept the risk.
stats sizes
# STAT 96 100 # 100 items rounded up to 96 bytes
# STAT 120 250
# STAT 192 50
# ...
# END
# compare to stats slabs to see how much memory is wasted to
# chunk-size rounding (internal fragmentation)stats cachedump — Slab inspizieren
stats cachedump listet die Schlüssel einer bestimmten Slab-Klasse auf (begrenzt auf N Einträge), nützlich für Ad-hoc-Debugging. Es durchläuft den LRU der Slab und kann langsam sein oder in manchen Builds ganz deaktiviert — nutze es niemals zur Produktions-Schlüsselaufzählung. Memcached bietet bewusst keinen effizienten Weg, alle Schlüssel aufzulisten; behandle es als Black Box, die von deiner Anwendung verschlüsselt wird.
# peek at keys in a specific slab class
# syntax: stats cachedump <slab_id> <limit> [noreply]
stats cachedump 1 10
# ITEM user:1 [5 b; 1700000000 s]
# ITEM user:2 [5 b; 1700000000 s]
# ...
# END
# WARNING: for debugging only — it walks the LRU and can be slow.
# Not all builds ship cachedump; it is disabled in some distros.
# Each ITEM shows: key, [value size in bytes; storage time s]
# do NOT use this for key enumeration in production code —
# memcached has no efficient SCAN commandstats reset & weitere Subbefehle
stats reset nullt die kumulativen Zähler (ops, hits, misses), ohne Daten zu löschen — praktisch, um nach einem Deploy ein frisches Intervall zu messen. Weitere nützliche Subbefehle: stats settings (effektive Konfiguration), stats conns (Verbindungsdetails in neueren Builds), stats lru_crawler (Crawler-Status). Zähler sind sonst kumulativ seit Prozessstart, also vor Benchmarks reset.
# zero the cumulative counters (cmd_get, hits, misses, etc.)
stats reset
# -> RESET
# useful stats subcommands:
stats settings # current effective configuration
stats items # per-slab item counts/age
stats slabs # slab allocator layout
stats sizes # item size histogram (slow!)
stats conns # per-connection info (newer builds)
stats lru_crawler # crawler state
# reset counters after a deploy to measure only current run
# (counters are since process start otherwise)Einstellungen & Konfiguration
stats settings — Effektive Konfiguration
stats settings zeigt die laufende Konfiguration: maxbytes (-m), maxconns (-c), growth_factor (-f), item_size_max (-I), ob Evictions und CAS aktiviert sind, und den LRU-Crawler-Status. Die meisten davon sind beim Start fixiert; nur eine Handvoll lässt sich zur Laufzeit ändern. Erster Anlaufpunkt, um zu bestätigen, ob der Server die Flags übernommen hat, die du denkst.
# view the server's current effective settings
stats settings
# STAT maxbytes 67108864
# STAT maxconns 1024
# STAT tcpport 11211
# STAT udpport 0
# STAT inter NULL
# STAT evictions on
# STAT cas_enabled on
# STAT chunk_size 48
# STAT growth_factor 1.25
# STAT item_size_max 1048576
# STAT lru_crawler on
# ...
# END
# this reflects flags passed at startup (-m, -c, -f, -I, ...)Startup-Flags
Die meiste Konfiguration läuft über Startup-Flags. Die kritischen: -m (Speicher), -l (immer an 127.0.0.1 oder ein privates Netz binden — Memcached nie öffentlich exponieren), -c (Verbindungslimit), -I (max. Item-Größe) und -f (Slab-Growth-Factor). -M dreht das Eviction-Verhalten auf Fehler-bei-voll statt LRU-Eviction (für einen Cache selten gewollt). -t an die CPU-Anzahl anpassen für Durchsatz.
# common memcached startup flags
memcached -d -m 256 -p 11211 -u memcache -c 2048 -f 1.25 -I 1m
# -d run as a daemon
# -m <MB> max memory to use for items (default 64)
# -M return error instead of evicting when memory full
# -c <conn> max simultaneous connections (default 1024)
# -p <port> TCP port (default 11211)
# -U <port> UDP port (0 disables; default 11211)
# -l <addr> listen address (default all — bind to 127.0.0.1!)
# -u <user> run as this user (when started as root)
# -f <factor> slab growth factor (default 1.25)
# -n <bytes> min item allocation (default 48)
# -I <size> max item size (default 1m, can be 1m-1g)
# -t <threads> worker threads (default 4)
# -v / -vv / -vvv verbosityLaufzeitkonfiguration
Memcached legt nur wenige Laufzeit-Stellschrauben offen: cache_memlimit (Speichergrenze live ändern), die lru_crawler-Familie (den Hintergrund-Reaper aktivieren/deaktivieren/tunen), verbosity (Log-Level) und flush_all (alle Items invalidieren, optional verzögert). Die meisten Einstellungen bleiben beim Start fixiert — für Änderungen an -m, -c oder -I den Prozess neu starten. flush_all ist eine Control-Plane-Operation, keine Einstellung.
# a small number of settings can change at runtime:
# change the memory limit (bytes) live
cache_memlimit 536870912 # 512 MB
# -> OK
# LRU crawler controls
lru_crawler enable # turn the crawler on
lru_crawler disable # turn it off
lru_crawler sleep 100 # us between slab visits
lru_crawler tocrawl 1000 # max items per slab per pass
lru_crawler metadump all # dump key metadata (not values)
# log verbosity at runtime
verbosity 2
# flush_all (invalidate everything, not a config change)
flush_all
flush_all 900 # invalidate in 900 secondsWichtige Einstellungen erklärt
-m ist die Haupt-Einstellung: auf Working Set plus Luft bemessen, denn Unterdimensionierung verursacht Evictions und Cache-Churn. -f tauscht Slab-Klassen-Granularität gegen interne Fragmentierung — niedriger stellen (Richtung 1.1), wenn viele eng beieinander liegende Item-Größen vorkommen. -I begrenzt die Item-Größe; nur erhöhen, wenn große Blobs gecacht werden müssen. -M wird bei Caches selten genutzt — es macht aus OOM Fehler statt Evictions.
# -m memory budget
# the single most important knob. Size to fit your working set
# with headroom; undersizing = evictions = cache churn.
#
# -f slab growth factor (default 1.25)
# smaller (1.1) = more slab classes, less internal fragmentation
# but more per-class memory stuck. Larger (1.5) = fewer classes,
# more waste per chunk.
#
# -I max item size (default 1m)
# raise to cache bigger blobs (e.g. -I 4m) at the cost of larger
# worst-case allocations.
#
# -M disable LRU eviction (error instead) — only for strict caches
#
# -t worker threads (default 4) — scale to CPU count for throughputVerbindungslimits & Threads
-c begrenzt gleichzeitige Verbindungen — deutlich über (pool_size × app_instances) ansetzen, sonst werden Clients abgewiesen (listen_disabled_num in stats beobachten). -t setzt Worker-Threads; Memcached ist pro Thread event-getrieben, also -t an CPU-Kerne anpassen, typisch 4–8. Darüber begrenzt Lock-Contention die Zugewinne. Jeder Thread besitzt einen Ausschnitt der Hash-Tabelle — mehr Threads helfen bei einem einzelnen Hot Key nicht.
# -c max client connections (default 1024)
memcached -c 4096
# each connection costs a bit of memory; set -c above your expected
# peak concurrent clients (pool size * app instances + headroom)
# -t worker threads (default 4)
memcached -t 8
# memcached is event-driven per thread; each thread runs its own
# event loop and owns a slice of the hash table. Scale -t to CPU
# cores. Beyond ~8 threads, contention often limits gains.
# check connection pressure:
stats
# STAT curr_connections 412
# STAT total_connections 10230
# STAT listen_disabled_num 0 # >0 means you hit -c and refused connsCaching-Strategien
Cache-Aside (Lazy Loading)
Cache-Aside ist das einfachste und beliebteste Muster: Die App liest zuerst den Cache, bei Miss lädt sie aus der DB und füllt den Cache nach. Es ist robust (ein Cache-Ausfall bedeutet nur mehr DB-Last), erlaubt aber Stampedes auf kalten Schlüsseln und Veraltung bis zur expliziten Invalidierung. Immer eine TTL setzen, auch bei Invalidierung beim Schreiben — als Sicherheitsnetz für verpasste Invalidierungen.
# the most common pattern — app manages the cache explicitly
def get_user(id):
key = "user:" + str(id)
val = mc.get(key) # 1) try cache
if val is not None:
return val # hit
val = db.query(id) # 2) miss -> load from DB
mc.set(key, val, ttl=3600) # 3) back-fill the cache
return val
# on write:
def update_user(id, data):
db.update(id, data)
mc.delete("user:" + str(id)) # invalidate (or set fresh value)
# pros: simple, resilient to cache failure
# cons: stampede on miss; stale until invalidatedRead-Through
Beim Read-Through ruft die Cache-Schicht selbst bei Miss einen Loader auf — die App ruft nur get auf und bekommt einen Wert. Das zentralisiert die Cache-Befüllungslogik und garantiert Konsistenz über alle Aufrufer, zum Preis eines synchronen DB-Lesevorgangs innerhalb des Cache-Aufrufs. Die meisten Memcached-Clients haben kein Read-Through eingebaut, daher implementiert man es meist als dünne Hülle um Cache-Aside.
# the cache itself is responsible for loading from the DB
# (the client library or a cache layer provides a loader callback)
mc = memcached_with_loader(load_fn=db.query_user)
def get_user(id):
# the cache calls load_fn(id) automatically on a miss
return mc.get_or_load("user:" + str(id))
# pros:
# - app code is simpler (no miss-handling logic)
# - cache population is consistent across callers
# cons:
# - the cache library must support a loader (or you wrap it)
# - a cache miss is slower (synchronous DB read inside get)Write-Through
Write-Through aktualisiert den Cache bei jedem Schreibvorgang und hält ihn frisch ohne separaten Invalidierungspfad. Der Trade-off ist Schreiblatenz (Cache + DB) und ein Reihenfolgerisiko bei Fehlern: Schreibst du Cache-zuerst und die DB schlägt fehl, hält der Cache Daten, die nicht dauerhaft sind; DB-zuerst erzeugt ein Veraltungsfenster. Die meisten Apps kombinieren Write-Through für Hot Keys mit Cache-Aside für den Rest.
# every write goes to the cache AND the DB synchronously
def update_user(id, data):
mc.set("user:" + str(id), data, ttl=3600) # cache first
db.update(id, data) # then DB
# or DB first, then cache — pick an order and stick with it
# pros:
# - cache stays fresh after writes (no stale reads)
# - no invalidation logic needed
# cons:
# - write latency = cache write + DB write
# - if the DB write fails after the cache write, cache is inconsistent
# - cache holds data even if never read (wastes memory)Write-Behind (Write-Back)
Write-Behind schreibt sofort in den Cache und persistiert asynchron über eine Queue in die DB — Sub-Millisekunden-Schreiblatenz und Lastspitzen-Absorption. Der Preis sind Konsistenz (die DB hinkt dem Cache hinterher) und Dauerhaftigkeit (ein Absturz, bevor der Worker abarbeitet, verliert Daten). Memcached allein kann das nicht; du brauchst Queue + Worker. Für schreiblastige, tolerante Workloads wie Zähler und Telemetrie reservieren.
# writes go to the cache first; DB is updated ASYNCHRONOUSLY later
# (memcached alone can't do this — it's a cache, not a queue.
# this pattern needs a worker/queue alongside it.)
def update_user(id, data):
mc.set("user:" + str(id), data, ttl=3600)
queue.push({"op":"update","id":id,"data":data}) # async DB write
# a background worker drains the queue to the DB
# pros:
# - very fast writes (cache-only latency)
# - absorbs write spikes
# cons:
# - DB lags behind cache -> reads may see newer data than DB
# - data loss if cache evicts/evacuates before the worker runs
# - complex (queue + worker + reconciliation)Cache-Invalidierung
Invalidierung ist der schwierigste Teil des Cachings. Explizites delete-on-write ist die Basis; TTL ist das Sicherheitsnetz (immer setzen). Für Sammlungen, die man nicht aufzählen kann, versionierte Schlüssel verwenden (user:1:v42) und bei Schema-/Datenänderungen die Version erhöhen, damit alte Einträge ausaltern. Zeitlich gebuckette Schlüssel (report:2024-01-01) laufen per Datum automatisch ab. Nie Wildcard-Invalidierung versuchen — Memcached kann Schlüssel nicht auflisten.
# invalidation is HARD — "there are only two hard problems in CS"
# 1) explicit invalidation on write
def update_user(id, data):
db.update(id, data)
mc.delete("user:" + str(id)) # drop stale entry
# 2) versioned keys to avoid invalidation entirely
key = "user:" + str(id) + ":v" + str(version)
# bump version on update -> old keys auto-expire via TTL
# 3) TTL as a safety net — even with explicit invalidation, set a TTL
# so a missed invalidation self-heals within (e.g.) an hour
# 4) namespacing by time/date for time-bucketed data
key = "report:" + today_date() # yesterday auto-expires
# anti-pattern: trying to invalidate "all user:* keys" —
# memcached can't enumerate keys, so use a versioned namespace insteadTTL- & Eviction-Strategien
TTL an die Datenflüchtigkeit anpassen: Stunden für Referenzdaten, Minuten für Nutzerdaten, die Fensterlänge für Rate-Limit-Zähler. Immer Jitter (±5–10%) ergänzen, um synchronisierte Ablauf-Stampedes zu vermeiden. Memcached verdrängt LRU pro Slab unter Speicherdruck, ohne pro-Item-Pinning — die einzigen Hebel sind TTL und Gesamtgröße. Bei Hot Keys ein add-basiertes Lock nutzen, damit nur ein Client bei Miss neu berechnet.
# choose TTL by data volatility:
# reference data (rarely changes) -> 1-24 hours
# user data (changes on action) -> 5-60 minutes
# computed reports -> matches refresh cadence
# sessions -> matches idle timeout
# rate-limit counters -> matches the window (60s)
# add jitter to prevent synchronized expiry / stampedes:
ttl = base + random.randint(-60, 60)
# on high memory pressure, Memcached evicts LRU items per slab.
# to AVOID eviction of critical data, give it a longer TTL OR
# store it under a key pattern you can pin (memcached has no
# explicit "no-evict" flag — TTL + sizing are your tools).
# stampede protection: lock-and-recompute on miss
if mc.add("lock:user:1", "1", ttl=30):
val = db.query(1); mc.set("user:1", val, 3600); mc.delete("lock:user:1")
else:
val = mc.get("user:1") # another client is refreshing; retry shortlyClient-Bibliotheken
Python (pymemcache)
pymemcache ist pure-Python, schnell und explizit. Den einfachen Client für einen Server nutzen und HashClient für einen Cluster mit consistent hashing. set/get sind die Basis; get_many bündelt einen Multi-Get. add+incr für Zähler und gets/cas für optimistische Updates. Immer explizite Timeouts übergeben — ein toter Knoten soll schnell fehlschlagen, nicht deinen Request-Thread aufhängen.
# pip install pymemcache
from pymemcache.client.base import Client
mc = Client(("127.0.0.1", 11211), connect_timeout=2, timeout=1)
mc.set("user:1", "alice", expire=3600)
print(mc.get("user:1")) # b"alice"
# multi-get (batched)
for k, v in mc.get_many(["user:1", "user:2", "user:3"]).items():
print(k, v)
# counter
mc.add("views", 0)
mc.incr("views", 1)
# CAS loop
while True:
val, cas = mc.gets("counter")
if mc.cas("counter", int(val) + 1, cas, expire=0):
break
# use a consistent-hashing cluster
from pymemcache.client.hash import HashClient
cluster = HashClient([("mc1", 11211), ("mc2", 11211), ("mc3", 11211)])Node.js (memcached)
Das npm-Paket memcached unterstützt Einzel- und Multi-Server-Setups (consistent hashing), Connection Pooling und Retries. set/get/getMulti (gebündelter Multi-Get) decken den normalen Weg ab. poolSize an die Nebenläufigkeit anpassen und immer ein Timeout setzen, damit ein toter Knoten schnell fehlschlägt. Die Bibliothek ist callback-basiert; für async/await-Ergonomie in Promises wrappen oder util.promisify verwenden.
// npm install memcached
const Memcached = require("memcached");
const mc = new Memcached("127.0.0.1:11211", {
timeout: 1000,
retries: 1,
poolSize: 10,
});
mc.set("user:1", "alice", 3600, (err) => {
if (err) console.error(err);
});
mc.get("user:1", (err, data) => {
console.log(data); // "alice"
});
// multi-get
mc.getMulti(["user:1", "user:2"], (err, data) => {
console.log(data["user:1"]);
});
// counter
mc.incr("views", 1, (err, val) => console.log(val));
// cluster: pass a comma-separated list, client does consistent hashing
const cluster = new Memcached("mc1:11211,mc2:11211,mc3:11211");
mc.end(); // close connections on shutdownPHP (memcached-Extension)
PHPs memcached-Extension (auf libmemcached aufbauend) ist die Produktionswahl — OPT_LIBKETAMA_COMPATIBLE setzen für consistent hashing über Server hinweg, und addServers für einen Cluster. getMulti bündelt Lesevorgänge. cas() nimmt das Token aus dem Ergebnisarray von fetch(). Die ältere memcache-Extension (ohne 'd') vermeiden; ihr fehlen Features und sie wird weniger gepflegt. Immer TTLs setzen und Memcached::RES_NOTFOUND sauber behandeln.
<?php
// requires the memcached extension (libmemcached-based)
$mc = new Memcached();
$mc->addServer("127.0.0.1", 11211);
$mc->set("user:1", "alice", 3600);
echo $mc->get("user:1"); // alice
// multi-get returns associative array
$rows = $mc->getMulti(["user:1", "user:2", "user:3"]);
// counter
$mc->set("views", 0);
$mc->increment("views", 1);
// CAS
$mc->getDelayed(["counter"], false, null);
while ($item = $mc->fetch()) {
$cas = $item["cas"];
$mc->cas($cas, "counter", intval($item["value"]) + 1);
}
// cluster with consistent hashing
$mc->setOption(Memcached::OPT_LIBKETAMA_COMPATIBLE, true);
$mc->addServers([
["mc1", 11211],
["mc2", 11211],
["mc3", 11211],
]);Ruby (dalli)
Dalli ist der kanonische Ruby-Memcached-Client — pure-Ruby, thread-sicher und der Standard-Cache-Store von Rails. Ein Array von Servern übergeben für Ketama-Clustering mit consistent hashing. Seine cas-Blockform liest bei Konflikt automatisch neu und wiederholt — deutlich ergonomischer als manuelle Schleifen. expires_in global konfigurieren und pro Aufruf überschreiben für engere TTLs.
# gem install dalli
require "dalli"
# single server
mc = Dalli::Client.new("127.0.0.1:11211", { expires_in: 3600 })
mc.set("user:1", "alice")
mc.get("user:1") # => "alice"
# multi-get (returns a hash)
mc.get_multi(["user:1", "user:2", "user:3"])
# counter
mc.incr("views", 1)
mc.decr("views", 1)
# CAS
mc.get("counter") do |val, cas|
mc.cas("counter", cas) { val.to_i + 1 }
end
# cluster with consistent hashing (ketama)
cluster = Dalli::Client.new(["mc1:11211", "mc2:11211", "mc3:11211"],
{ expires_in: 3600 })Java (spymemcached)
spymemcached ist ein hochperformanter, asynchroner NIO-basierter Java-Client. Seine API ist Future-basiert; get() blockiert, wenn du Bestätigung brauchst. Eine durch Leerzeichen getrennte Serverliste an AddrUtil übergeben für consistent hashing. gets()/cas() bieten optimistische Nebenläufigkeit, getBulk() einen gebündelten Multi-Get. Beim App-Teardown immer shutdown() aufrufen, um die IO-Threads freizugeben.
// build.gradle: implementation 'net.spy:spymemcached:2.12.3'
import net.spy.memcached.MemcachedClient;
import net.spy.memcached.AddrUtil;
MemcachedClient mc = new MemcachedClient(
AddrUtil.getAddresses("mc1:11211 mc2:11211 mc3:11211"));
// async API returns java.util.concurrent.Future
Future<Boolean> f = mc.set("user:1", 3600, "alice");
f.get(); // block for confirmation
Object val = mc.get("user:1"); // "alice"
// counter
mc.incr("views", 1);
// CAS
CASValue<Object> cv = mc.gets("counter");
CASResponse r = mc.cas("counter", cv.getCas(), newVal);
if (r == CASResponse.OK) { /* success */ }
// bulk get
Map<String, Object> rows = mc.getBulk("user:1", "user:2", "user:3");
mc.shutdown();Go (gomemcache)
gomemcache (bradfitz) ist der de-facto-Go-Client — einfach, schnell und unterstützt consistent hashing über mehrere Server. Set/Get nehmen ein Item-Struct, das key, value, TTL und das CAS-Token bündelt; CompareAndSwap macht das optimistische Update. GetMulti liefert eine Map nach Namen (fehlende Schlüssel fehlen einfach, ohne Fehler). Es ist nebenläufigkeitssicher; einen Client über Goroutines wiederverwenden.
// go get github.com/bradfitz/gomemcache/memcache
import memcache "github.com/bradfitz/gomemcache/memcache"
mc := memcache.New("mc1:11211", "mc2:11211", "mc3:11211")
// set
err := mc.Set(&memcache.Item{
Key: "user:1", Value: []byte("alice"), Expiration: 3600,
})
// get
it, err := mc.Get("user:1")
// it.Value -> []byte("alice")
// multi-get (returns map, missing keys absent)
rows, _ := mc.GetMulti([]string{"user:1", "user:2"})
// counter
mc.Increment("views", 1)
mc.Decrement("views", 1)
// CAS
it, _ = mc.Get("counter")
it.Value = []byte("6")
it.Cas = it.Cas // use existing token
mc.CompareAndSwap(it)
// delete
mc.Delete("user:1")Verteilte Architektur
Consistent Hashing
Consistent Hashing bildet Server und Schlüssel auf einen Ring ab; ein Schlüssel gehört zum nächsten Server im Uhrzeigersinn. Hinzufügen oder Entfernen eines Servers verschiebt nur dessen Schlüsselscheibe (etwa 1/N), nicht den ganzen Keyspace — deutlich besser als hash(key) % N, das bei Mitgliederwechsel fast alles neu zuordnet. Die meisten Clients nutzen die Ketama-Variante mit vielen virtuellen Knoten pro Server für ausgeglichene Verteilung.
# consistent hashing spreads keys across servers with minimal
# remapping when the pool changes.
#
# 1) hash each server onto a ring (multiple virtual nodes each)
# 2) hash the key, walk the ring clockwise to the next server
#
# ring: s1---s2---s3---s1
# ^ ^
# keyA keyB -> goes to s3
#
# adding s4 only moves keys between s3 and s4 (not the whole ring)
# removing s1 only moves keys between s1's predecessor and s2
#
# result: |keys moved| ~= keys/N when adding/removing one server
# (vs. ~all keys remapped with hash(key) % N)
# most clients implement ketama consistent hashing automatically
# when you pass a list of serversClientseitiges Sharding
Das gesamte Sharding liegt im Client: Er hasht jeden Schlüssel auf einen Server und fächert Multi-Gets parallel über Server auf. Jeder Schlüssel existiert auf genau einem Knoten — es gibt keine Replikation, ein toter Knoten verliert also seinen Keyspace-Scheibe. Es gibt keinen Proxy oder Koordinator; jeder Client muss dieselbe Serverliste und Hashing-Konfiguration (ketama) teilen, sonst landen Schlüssel auf verschiedenen Knoten und verursachen Massen-Misses.
# memcached servers do NOT coordinate — sharding is 100% client-side.
#
# the client picks ONE server per key:
# server = ring[hash(key)]
#
# a multi-get is split across servers in parallel:
# getMulti(["a","b","c"])
# -> get "a" from mc1
# -> get "b" from mc2 (concurrent, fan-out)
# -> get "c" from mc1
#
# this means:
# - each key lives on exactly ONE server (no replication)
# - a multi-get touches multiple servers but returns one result set
# - the client must know the full server list (no proxy)
# never put a replica behind the same client as a primary for the
# same key range — memcached clients do not read-replicateHashing-Algorithmen (Ketama)
Ketama ist das kanonische Consistent-Hashing-Schema für Memcached: Jeder physische Server wird mit vielen virtuellen Knoten (~160) auf den Ring abgebildet, für ausgeglichene Last. Um einen Schlüssel zu finden, wird er gehasht und im Uhrzeigersinn zum nächsten Knoten gelaufen. Die kritische Falle: Jeder Client in jeder Sprache muss denselben Algorithmus und identische Server-Label-Strings verwenden, sonst uneinig in der Zugehörigkeit → Massen-Cache-Misses nach einem Deploy.
# ketama is the de-facto consistent-hashing algorithm for memcached.
#
# for each server, create N virtual nodes (default ~160-200):
# for i in range(vnodes):
# point = hash("server:port-" + i)
# ring[point] = server
#
# to locate a key:
# point = hash(key)
# server = first node clockwise from point on the ring
#
# benefits of many virtual nodes:
# - balanced load (no single server gets a huge arc)
# - smooth redistribution on add/remove
#
# IMPORTANT: all clients must use the SAME algorithm + server labels,
# or they will disagree on which server owns a key.
# enable in clients:
# PHP: Memcached::OPT_LIBKETAMA_COMPATIBLE
# Ruby: default in dalli
# Python: HashClient (pymemcache)Server hinzufügen & entfernen
Mit consistent hashing ordnet das Hinzufügen oder Entfernen eines Servers nur ~1/N der Schlüssel neu — deutlich besser als Modulo-Hashing, das fast alles neu zuordnet. Aber ein Serverabsturz verliert seine Schlüssel dauerhaft (keine Replikation) und verursacht eine transiente Origin-Lastspitze, wenn diese Einträge neu befüllt werden. Mitgliedschaftsänderungen auf alle Clients gleichzeitig ausrollen und einen neuen Knoten vorab mit Schatten-Lesen aufwärmen, bevor er live geht.
# adding a server to the ring:
# - only ~1/N of keys remap (the slice the new server now owns)
# - those keys are cold misses until repopulated -> brief spike
#
# removing a server (e.g. crash):
# - that server's keys are GONE (no replication)
# - its slice of the ring is reassigned to neighbors
# - all reads to those keys miss until repopulated
#
# best practices for membership changes:
# 1) deploy new server list to all clients simultaneously
# 2) warm a new server with a shadow-read phase if possible
# 3) expect a transient increase in DB load (cache misses)
# 4) use weighted virtual nodes to add capacity gradually
# anti-pattern: hash(key) % N -> changes ALL key placements on
# every membership change (catastrophic for cache hit rate)Replikation & Failover
Memcached hat keine eingebaute Replikation oder Failover — ein toter Knoten verliert seine Daten, Clients leiten um. Redundanz ergibt sich entweder durch Replikation im Client (auf N Knoten schreiben, teurer), einen Proxy wie mcrouter/twemproxy oder die Akzeptanz des Verlusts mit Wiederaufbau aus dem Origin. Der idiomatische Weg ist der letzte: den Cache als Wegwerfartikel behandeln, den Pool so dimensionieren, dass der Verlust eines Knotens verkraftbar ist, und Misses aus der DB nachfüllen lassen.
# memcached has NO built-in replication or failover.
# if a node dies, its data is gone — clients reroute to the ring.
#
# to ADD replication, options:
#
# 1) client-side replication: write to N servers per key
# - the client writes to primary + replica(s) on each set
# - reads try primary, fall back to replica
# - trade-off: N x write traffic + memory, weaker consistency
#
# 2) repcached: a memcached fork with master/replica replication
# - largely unmaintained today; avoid for new projects
#
# 3) use a layer above: twemproxy / mcrouter / mc-router
# - proxy that handles sharding, pooling, failover
#
# 4) accept the loss: cache is volatile by design — rebuild from DB
# the "memcached way" is usually option 4: don't replicate, just
# size the pool so a single node loss is survivableSpeicherverwaltung (Slabs / LRU)
Slab-Allocator
Memcached nutzt einen Slab-Allocator: Speicher wird in Klassen fester Chunk-Größen geteilt, und ein Item landet im kleinsten passenden Chunk (aufgerundet). Das vermeidet malloc/free-Fragmentierung und gibt O(1)-Allokation, auf Kosten interner Fragmentierung (Verschwendung im Chunk) und Klassen-Verkalkung (Speicher kann nicht zwischen Klassen wandern). Deshalb ist eine gleichmäßige Mischung der Wertgrößen wichtig für Effizienz.
# memcached does NOT use malloc/free per item (that fragments).
# instead it pre-allocates fixed-size "slab classes" of chunks.
#
# slab class 1: chunks of 96 bytes
# slab class 2: chunks of 120 bytes
# slab class 3: chunks of 152 bytes (grow by -f factor)
# ...
#
# a 50-byte value -> rounded up to 96-byte chunk (class 1)
# a 100-byte value -> rounded up to 120-byte chunk (class 2)
#
# trade-offs:
# + no per-item malloc overhead, no heap fragmentation
# + O(1) alloc/free
# - internal fragmentation (wasted bytes inside a chunk)
# - memory is stuck per class (can't move between classes)
# inspect with:
stats slabsSlab-Klassen & Growth Factor
Slab-Klassengrößen starten beim -n-Minimum (Standard 48 Bytes) und wachsen um den -f-Faktor (Standard 1.25) bis zur -I-maximalen Item-Größe. Ein niedrigeres -f ergibt mehr, feinere Klassen (weniger Verschwendung, mehr Verkalkungsrisiko); ein höheres -f ergibt weniger, gröbere Klassen (mehr Verschwendung). Das echte Wertgrößen-Histogramm mit stats sizes prüfen und -f so tunen, dass häufige Größen auf gut gefüllte Klassen fallen.
# slab class sizes start at -n (default 48 bytes) and grow by -f:
#
# class 1: 48 bytes (base, -n)
# class 2: 48 * 1.25 = 60
# class 3: 60 * 1.25 = 75 -> 80
# class 4: 80 * 1.25 = 100
# ...
# up to the max item size (-I, default 1MB)
#
# -f default 1.25 balances class count vs. waste.
# lower (1.1) -> more classes, less waste, but more stuck memory
# higher (1.5) -> fewer classes, more waste per chunk
#
# tune -f to your value-size distribution (check stats sizes)
# example: many small JSON values -> -f 1.1 -n 80
memcached -m 512 -f 1.1 -n 80LRU-Eviction
Eviction erfolgt pro Slab-Klasse und strikt LRU innerhalb dieser Klasse: Ist eine Klasse voll, wird das am längsten ungenutzte Item dieser Klasse fallen gelassen, um Platz zu schaffen. Eine Klasse mit freien Chunks verdrängt nie — eine unausgeglichene Größenverteilung kann also in einer Klasse heftige Evictions auslösen, während eine andere leer bleibt — das klassische Slab-Verkalkungsproblem. evictions und evicted_active in stats beobachten.
# when a slab class is full and a new item arrives in that class,
# memcached evicts the LEAST RECENTLY USED item in that class.
#
# eviction is PER-SLAB-CLASS, not global:
# - a full class-1 (96B) evicts class-1 items only
# - a class with free chunks never evicts
#
# this means an unbalanced workload can evict from one class
# while another class sits idle with free chunks.
#
# check eviction pressure:
stats
# STAT evictions 1234 # total items ever evicted
# STAT evicted_active 12 # evicted even though recently used (1.6+)
# STAT evicted_unfetched 50 # evicted before ever read
stats items
# STAT items:1:evicted 500 # evictions in slab class 1
# STAT items:1:outofmemory 0Speichergrenzen (-m)
-m begrenzt den Item-Speicher in MB; wird der erreicht, fügt Memcached keine Slab-Seiten mehr hinzu und verdrängt LRU innerhalb der Klassen. -M ändert die Politik auf Fehler-bei-voll statt Verdrängen (für einen Cache selten wünschenswert). cache_memlimit ändert die Grenze zur Laufzeit. -m auf das Working Set plus Luft bemessen — Betrieb bei 100 % bedeutet ständige Evictions und einen unruhigen Cache mit niedriger Hit Rate.
# -m sets the max memory for items (in MB)
memcached -m 64 # default: 64 MB
memcached -m 4096 # 4 GB
# once -m is reached, memcached stops allocating new slab pages and
# relies on LRU eviction within each class.
#
# -M flips behavior: instead of evicting, return an ERROR on writes
# when memory is full (rarely what you want for a cache).
memcached -m 512 -M
# resize the memory cap at runtime (bytes):
cache_memlimit 2147483648 # 2 GB
# -> OK (only grows/shrinks the page pool; doesn't drop items
# unless shrinking forces eviction)
# monitor:
stats
# STAT bytes 424463360 # current bytes in use
# STAT limit_maxbytes 536870912 # the -m limitEviction-Politiken & Tuning
Memcacheds einzige Eviction-Politik ist pro-Slab-LRU — es gibt kein LFU oder Zufall. Um Evictions zu reduzieren: -m erhöhen, TTLs verkürzen, Wertgrößen ausbalancieren oder -f tunen. Moderne Builds ergänzen einen LRU-Crawler und die Möglichkeit, Slab-Seiten neu zuzuweisen (slabs reassign / slabs automove), um Verkalkung zu mildern. Eine heiße Klasse mit den evicted/outofmemory-Zählern aus stats items erkennen.
# memcached's only eviction policy is LRU (per slab class).
# (Redis offers LRU/LFU/random/TTL; memcached does not.)
#
# 1.6+ adds an LRU crawler + "temporary" vs "permanent" LRU tiers:
# lru_crawler enable
# lru_crawler tocrawl 1000
#
# to reduce evictions:
# - increase -m (more memory)
# - shorten TTLs so items self-expire before LRU drops them
# - rebalance value sizes (avoid one hot slab class)
# - tune -f so popular sizes map to well-populated classes
#
# detect a hot/evicting class:
stats items
# STAT items:5:evicted 9999 <- class 5 is under pressure
# STAT items:5:outofmemory 0
# rebalance slab memory automatically (1.5+):
slabs reassign 5 1 # move a page from class 5 to class 1
slabs automove 1 # let the server auto-rebalance (cautious mode)Slab Automove & Reassign
slabs reassign (manuell) und slabs automove (1.5+, automatisch) gestatten es, Slab-Seiten von einer Klasse mit freien Chunks in eine unter Eviction-Druck umzubuchen — die Heiler für Slab-Verkalkung. automove=1 ist ein vorsichtiger, langsamer Hintergrundmover, produktionsfähig; =2 ist aggressiv und experimentell. Vorher und nachher immer mit stats slabs prüfen — ein falsches Reassign kann eine Klasse aushungern.
# 1.5+ lets you move a slab PAGE from a class with free chunks
# to a class under memory pressure.
#
# manual one-shot move:
slabs reassign 1 5 # take a page from class 1, give to class 5
# -> DONE (or BUSY if the page is being freed)
# automatic rebalancing (runs in the background):
slabs automove 0 # off (default)
slabs automove 1 # cautious auto-move (slow, safe)
slabs automove 2 # aggressive (experimental; watch carefully)
# the automover watches evictions/free chunks and slowly shifts
# pages to relieve pressure. It's conservative by design.
# check current slab state:
stats slabs
# STAT 1:total_pages 4
# STAT 1:free_chunks 0 <- class 1 is full
# STAT 5:total_pages 12
# STAT 5:free_chunks 8000 <- class 5 has room to givePerformance-Optimierung
noreply & Pipelining
noreply schneidet die Antwort pro Schreibvorgang ab, und Pipelining bündelt viele Befehle in einen Netzwerk-Round-Trip — zusammen sind sie der größte Durchsatzhebel für Massenschreibvorgänge. Multi-Get macht dasselbe für Lesevorgänge. Der Preis von noreply ist der Verlust der Fehler-Feedbacks pro Befehl — also nur für unkritische, voluminöse Schreibvorgänge reservieren und bei allem, dessen Fehler sichtbar sein müssen, Antworten an lassen.
# noreply skips the server's response for write commands.
# use it for fire-and-forget writes to cut latency & network:
set k1 0 0 5 noreply
hello
set k2 0 0 5 noreply
world
# (no STORED echoed back)
# pipelining: send many commands in one batch without waiting for
# each response (binary protocol and most clients support this).
# ideal for bulk inserts/refreshes.
# trade-off:
# + fewer round-trips, higher throughput
# - no error feedback per command (use sparingly for critical writes)
# multi-get is the read-side equivalent: one request, N keys
get user:1 user:2 user:3 user:4Binärprotokoll
Das Binärprotokoll ist effizienter als ASCII — ein fester 24-Byte-Header statt Textparsing, native quiet-Operationen (noreply-Stil) fürs Pipelining und SASL-Unterstützung für Authentifizierung. Bei kleinen Werten und hochdurchsatzigen Massenschreibvorgängen messbar schneller. Der Server spricht beide Protokolle auf demselben Port — das Einschalten ist rein eine Client-Wahl. In Produktions-Clients bevorzugen.
# the binary protocol (vs ASCII text) is more efficient:
# - fixed 24-byte header (no string parsing)
# - supports SASL authentication
# - supports pipelining and quiet (noreply-equivalent) ops natively
# - smaller wire footprint for small values
#
# enable on the client side (the server speaks both on the same port):
# pymemcache: Client(..., allow_unicode_keys=True, default_noreply=True)
# spymemcached: use the binary connection factory
# libmemcached: MEMCACHED_BINARY_PROTOCOL
# binary quiet ops (Noop/SetQ/AddQ/...):
# pipelined writes that only reply on error — perfect for bulk loads
# the server listens for both protocols on 11211 by default;
# no server-side flag is requiredConnection Pooling
Connection Pooling ist essenziell — pro Request eine TCP-Verbindung öffnen verbraucht ephemere Ports und bringt Latenz. Einen kleinen Pool persistenter Verbindungen pro Server pro Prozess halten, bemessen nach deiner Nebenläufigkeit. total_connections vs. curr_connections in stats beobachten: Wächst total mit dem Traffic, während curr flach bleibt, poolst du; explodiert total, nicht. Die meisten Clients poolen intern, wenn konfiguriert.
# opening a TCP connection per request is extremely wasteful.
# reuse connections via a pool:
#
# - keep N persistent connections per server per app process
# - checkout -> use -> checkin (don't close)
# - size the pool to your concurrency, not your request rate
#
# pymemcache: HashClient manages a pool internally
# Node.js memcached: set poolSize
# PHP: persistent connections via memcached::OPT_CONNECT_TIMEOUT
# Java spymemcached: one MemcachedClient (thread-safe, NIO)
#
# signs of a missing pool:
# - high total_connections in stats (grows with traffic)
# - TIME_WAIT exhaustion on the server (ephemeral ports)
# - request latency dominated by connect() not get()/set()
stats
# STAT total_connections 1000000 <- too high; pool your conns
# STAT curr_connections 50 <- healthy pooled countMassenoperationen (Multi-Get)
Ein Multi-Get holt N Schlüssel in einem Round-Trip — die mit Abstand größte Leseoptimierung. Clients fächern die Schlüssel parallel über Server auf, also hängt die Latenz am langsamsten Server, nicht an der Schlüsselanzahl. Sehr große Multi-Gets (z. B. 100 Schlüssel) häppchenweise abfragen, damit kein einzelner Server-Thread monopolisiert wird; fehlende Schlüssel fehlen stillschweigend in der Ergebnis-Map.
# fetching N keys in one get is far cheaper than N single gets:
# 1 network round-trip instead of N
# server parses 1 command instead of N
# text protocol: space-separated keys
get user:1 user:2 user:3 user:4 user:5
# clients wrap this:
# pymemcache: mc.get_many([...])
# Node.js: mc.getMulti([...])
# PHP: $mc->getMulti([...])
# Go: mc.GetMulti([]string{...})
# best practices:
# - chunk very large multi-gets (e.g. 100 keys at a time)
# so no single server thread is monopolized
# - keys in a multi-get fan out to multiple servers — the client
# parallelizes, so a multi-get is bound by the SLOWEST server
# - missing keys are simply absent from the resultRichtige Wertgrößen
Weil Items auf die nächste Chunk-Größe aufgerundet werden, treibt die Wertgröße direkt die interne Fragmentierung — ein 60-Byte-Wert in einem 96-Byte-Chunk verschwendet 37 %. Werte in passender Größe halten: JSON-Whitespace trimmen, alles über ~1 KB komprimieren (und ein flags-Bit zur Markierung setzen) und Projektionen cachen statt ganzer Blobs. Das Größen-Histogramm mit stats sizes prüfen und -f tunen, damit häufige Größen nahe an Chunk-Grenzen liegen.
# because of the slab allocator, value size drives memory waste:
#
# a 60-byte value -> 96-byte chunk -> 36 bytes wasted (37%!)
# a 97-byte value -> 120-byte chunk -> 23 bytes wasted (19%)
#
# right-size values to fit chunk boundaries:
# - trim/normalize JSON before caching (drop whitespace, short keys)
# - compress large values (>1KB) with gzip/snappy; set a flags bit
# - avoid caching huge blobs; cache projections instead
#
# check your size distribution:
stats sizes # (off-peak; it locks)
# pick -f so common sizes land near chunk boundaries:
# if most values are 100-200 bytes, -f 1.25 is fine
# if values cluster at a few sizes, tune -f to match
# flags bit to mark compression:
set bigval 2 0 4096 # flags=2 means "gzip compressed" (your convention)Hot Keys vermeiden
Ein Hot Key ist ein Ein-Server-, Ein-Thread-Flaschenhals — seine Lesevorgänge serialisieren auf einem Knoten, während andere müßig sind. Auf N Buckets sharden (zufälligen Bucket lesen, beim Update in alle schreiben), eine clientseitige 1-Sekunden-TTL ergänzen, um Reloads zu bündeln, oder ihn in einen In-Process-LRU verschieben. Hot Keys per CPU-Ungleichgewicht pro Server erkennen oder — ab 1.6 — mit lru_crawler metadump auf die Zugriffsfrequenz schauen.
# a single hot key creates a bottleneck: it lives on ONE server
# and ONE worker thread, so concurrent reads serialize.
#
# symptoms: one memcached server at 100% CPU while others idle;
# one slab class churning while others are calm.
#
# fixes:
# 1) shard the hot key into N buckets:
# key = "hot:" + str(random.randint(0, 9)) # 10 buckets
# write to all N on update; read from a random one
# 2) add a short client-side TTL (e.g. 1s) to coalesce reloads
# 3) precompute and rotate (cache the rendered page, not the query)
# 4) move the hot value closer to the app (in-process LRU)
#
# detect with:
# - per-server CPU/stats imbalance
# - lru_crawler metadump all (peek at access frequency, 1.6+)Monitoring
Kern-Stats im Blick
Die vier Leitmetriken: Hit Rate (get_hits/cmd_get, Ziel >95 %), Evictions (Speicherdruck, Ziel 0 im Beharrungszustand), Speicherauslastung (bytes/limit_maxbytes, Ziel <90 %) und listen_disabled_num (Treffer des Verbindungslimits, Ziel 0). Als Raten über die Zeit tracken, nicht nur als Zähler. Eine sinkende Hit Rate oder steigende Evictions sind die frühesten Anzeichen eines ungesunden Caches.
# the four numbers to monitor continuously:
stats
# STAT cmd_get, cmd_set # throughput (ops/sec deltas)
# STAT get_hits, get_misses # hit rate = hits / cmd_get
# STAT evictions # memory pressure (rising = bad)
# STAT bytes / limit_maxbytes # memory utilization %
# derived metrics:
# hit_rate = get_hits / cmd_get # target > 95%
# eviction_r = evictions_delta / cmd_set_delta
# mem_usage = bytes / limit_maxbytes # target < 90%
# connection health:
# STAT curr_connections # active conns
# STAT listen_disabled_num # >0 = hit -c limit (refused conns)
# alert thresholds (suggestions):
# hit_rate < 90% -> investigate cold keys / undersizing
# evictions > 0 (steady)-> add memory or shorten TTLs
# listen_disabled_num > 0 -> raise -cmemcached-tool
memcached-tool ist die mitgelieferte CLI für einen schnellen Ad-hoc-Check: stats für eine pro-Slab-Tabelle, display für eine sich live aktualisierende Ansicht, dump zum Blick auf Schlüssel (nur Debug — läuft den LRU entlang). Perfekt für einen SSH-Einmalcheck, aber nicht für kontinuierliches Monitoring; mit einem Prometheus-Exporter und Grafana für Produktions-Dashboards und Alerting kombinieren.
# memcached-tool ships with the server — quick CLI stats:
memcached-tool host:port stats
memcached-tool host:port display # live-refreshing table
memcached-tool host:port dump # dump keys (debug only!)
# sample output of "stats":
# # Item_Size Max_age Pages Count Full? Evicted Evict_Time
# 1 96B 3600s 1 100 no 0 0
# 2 120B 7200s 2 250 no 0 0
# ...
# great for a one-off SSH check; not for continuous monitoring.
# for the latter, use a Prometheus exporter + Grafana.Telnet-Monitoring
Telnet oder netcat auf Port 11211 gibt sofortigen interaktiven Zugriff auf das Textprotokoll für Ad-hoc-Checks: stats, stats settings, stats items, stats slabs, version. Für Skripte nc-Einzeiler verwenden (echo 'stats' | nc -q 1 host 11211). Denken: flush_all ist destruktiv — nie beiläufig als Alias anlegen. Das ist der reibungsärmste Weg, einen Knoten zu inspizieren.
# quick interactive check via telnet/nc:
telnet localhost 11211
stats
stats settings
stats items
stats slabs
version
quit
# or one-liners with nc:
echo "stats" | nc -q 1 localhost 11211
echo "stats slabs" | nc -q 1 localhost 11211
# flush all keys (DESTRUCTIVE — use with care):
echo "flush_all" | nc -q 1 localhost 11211
# tip: pipe commands from a file for repeatable checks
nc localhost 11211 < checks.txtPrometheus-Exporter & Grafana
memcached_exporter ist die Standard-Prometheus-Integration — einen neben jedem Knoten laufen lassen und :9150 scapen. Grafana-Dashboards tracken dann Hit Rate, Eviction-Rate, Speichernutzung und pro-Slab-Füllstand. Alarme bei Hit Rate unter 90 %, ständigen Evictions, Speicher über 90 % und listen_disabled_num > 0. Das liefert kontinuierliche, historische Sichtbarkeit, die Ad-hoc-Telnet nicht kann.
# popular exporters scrape memcached stats into Prometheus:
#
# 1) memcached_exporter (official):
# https://github.com/prometheus/memcached_exporter
# run alongside each memcached instance:
memcached_exporter --memcached.address=localhost:11211 \
--web.listen-address=:9150
# 2) scrape config in prometheus.yml:
# - job_name: 'memcached'
# static_configs:
# - targets: ['mc1:9150','mc2:9150','mc3:9150']
# 3) Grafana dashboard (e.g. community id 37 or custom):
# - hit rate (get_hits / cmd_get)
# - eviction rate (rate(evictions[5m]))
# - memory usage (bytes / limit_maxbytes)
# - connections (curr_connections, listen_disabled_num)
# - per-slab fill / evictions
# alert on: hit rate < 90%, evictions > 0 steady, mem > 90%Schlüsselmetriken & Alerting
Alarme bei sinkender Hit Rate (Warnung <90 %, kritisch <75 %), ständigen Evictions, Speicher über 90 % und jeder abgewiesenen Verbindung. Cache-Metriken immer mit Origin-Metriken korrelieren — eine sinkende Hit Rate plus DB-CPU-Spitze ist die Signatur eines Cache-Miss-Sturms, und steigende Evictions plus steigende Origin-Latenz weisen auf einen zu kleinen Cache. Uptime-Resets tracken, um stille Neustarts zu erwischen.
# metric alert when severity
# ------------------------------------------------------------------
# hit_rate < 90% sustained warning
# hit_rate < 75% sustained critical
# evictions (rate) > 0 steady warning
# evictions (rate) > 100/min critical
# mem_usage > 90% warning
# mem_usage > 98% critical
# listen_disabled_num > 0 (refused conns) critical
# curr_connections > 80% of -c warning
# uptime resets (process restarted) info
# cmd_get/cmd_set rates sudden drop (app -> cache down) critical
# pair cache metrics with origin metrics:
# if cache hit rate drops AND DB CPU spikes -> cache miss storm
# if cache evictions rise AND origin latency rises -> undersizedSicherheit
Netzwerkisolation
Memcacheds Textprotokoll hat keine Authentifizierung, darf also niemals öffentlich exponiert werden — mit -l an 127.0.0.1 oder eine private NIC binden, UDP mit -U 0 deaktivieren, falls ungenutzt, und 11211 auf App-Subnetze firewallen. Ein öffentlich erreichbares Memcached ist sowohl ein offener Daten-Cache als auch ein UDP-Amplification-DDoS-Vektor (CVE-2018-1000115). Die Standard-Listen-Adresse sind alle Interfaces — immer überschreiben.
# memcached has NO authentication in the text protocol.
# it MUST NOT be exposed to the public internet.
#
# bind to loopback or a private network only:
memcached -l 127.0.0.1 # local only
memcached -l 10.0.0.5 # private NIC
memcached -l 10.0.0.5 -U 0 # also disable UDP
# firewall: deny 11211 from outside, allow only app subnets
# iptables example:
# iptables -A INPUT -p tcp --dport 11211 -s 10.0.0.0/24 -j ACCEPT
# iptables -A INPUT -p tcp --dport 11211 -j DROP
# CRITICAL: the default -l is ALL interfaces.
# A public memcached is an open cache AND a UDP amplification
# vector (CVE-2018-1000115 etc.) — disable UDP if unused.SASL-Authentifizierung (Binärprotokoll)
SASL-Authentifizierung gibt es nur auf dem Binärprotokoll (Server mit -S starten). Sie nutzt PLAIN-Anmeldeinformationen über die Setup-Phase einer Verbindung und fügt einen Round-Trip hinzu, den Pooling amortisiert. SASL in geteilten oder Multi-Tenant-Netzwerken einsetzen, wo Netzwerkisolation allein nicht reicht. Das Textprotokoll kann nicht authentifizieren — brauchst du Auth, muss das Binärprotokoll Ende-zu-Ende laufen.
# the BINARY protocol supports SASL (PLAIN) authentication.
# the text protocol does NOT.
#
# server: start with SASL enabled (built-in in most distros)
memcached -S -l 10.0.0.5
# create a SASL user (e.g. via saslpasswd2):
echo -n "myuser" | saslpasswd2 -p -a memcached myuser
# client: provide credentials
# pymemcache: Client(..., sasl_credentials=("myuser","pass"))
# spymemcached: use the binary factory + auth descriptor
# libmemcached: MEMCACHED_BEHAVIOR_SASL
# note: SASL adds a round-trip at connection setup; pooled
# connections amortize this. Use it on shared/multi-tenant networks
# where -l alone isn't enough.Verschlüsselung & TLS
Memcached hat kein natives TLS — um Traffic zu verschlüsseln, TLS in einem Sidecar wie stunnel oder HAProxy vor jedem Knoten terminieren und dahinter plain memcached auf Loopback laufen lassen. Für die meisten LAN-Deployments reichen Netzwerkisolation plus optionales SASL; TLS für netzwerkübergreifende Verbindungen oder Compliance-Umgebungen reservieren. Neuere Forks (und manche Cloud-Managed-Services) ergänzen natives TLS.
# memcached itself does NOT support TLS/SSL natively.
# to encrypt traffic, terminate TLS in front of the server:
#
# app --TLS--> stunnel/haproxy --plain--> memcached
#
# stunnel example (server side):
# [memcached]
# accept = 11443
# connect = 127.0.0.1:11211
# cert = /etc/stunnel/mc.pem
#
# the client also needs a stunnel/haproxy side, OR a client that
# speaks TLS (some newer forks/patches add native TLS).
#
# for most LAN deployments, network isolation + SASL is enough;
# reserve TLS for cross-network or compliance-required flows.Firewall & Zugriffskontrolle
Verteidigung schichten: an eine private NIC binden, auf App-Subnetze firewallen, UDP deaktivieren, in geteilten Netzwerken SASL ergänzen, als Nicht-root laufen lassen und systemd-Hardening anwenden (NoNewPrivileges, ProtectSystem, PrivateTmp). Entscheidend: niemals rohe Geheimnisse in Memcached legen — es ist ein Cache, kein Tresor; erst verschlüsseln dann cachen, oder Geheimnisse in einem dedizierten Secrets-Manager halten und nur unsensible Referenzen cachen.
# defense in depth for memcached:
#
# 1) bind to a private interface (-l 10.0.0.5)
# 2) firewall 11211 to app subnets only
# 3) disable UDP if unused (-U 0) — UDP is an amplification vector
# 4) use SASL on shared networks
# 5) TLS via stunnel for cross-network
# 6) run as a non-root user (-u memcache)
# 7) drop privileges / use systemd hardening
# 8) never store secrets in memcached unencrypted — it's a cache,
# not a vault (use a secrets manager + encrypt-then-cache)
# systemd hardening example:
# [Service]
# User=memcache
# NoNewPrivileges=true
# ProtectSystem=strict
# PrivateTmp=trueSicherheits-Best-Practices
Die Grundregeln: Memcached niemals öffentlich exponieren, immer an ein privates Interface binden, UDP deaktivieren und in geteilten Netzwerken SASL nutzen. Keine Geheimnisse oder personenbezogenen Daten unverschlüsselt speichern; Schlüssel pro Tenant namespacen, um Weitergabe über Nutzer hinweg zu verhindern. Den Server gepatcht halten, Verbindungen mit stats conns prüfen und eine Cache-Verletzung wie eine Datenpanne behandeln — jede möglicherweise gecachte Token rotieren.
# 1) NEVER expose memcached to the internet (no auth in text proto)
# 2) ALWAYS set -l to loopback or a private address
# 3) disable UDP (-U 0) unless you specifically need it
# 4) use SASL on the binary protocol for multi-tenant networks
# 5) don't store secrets/PII in the cache unencrypted
# 6) namespace keys per-tenant to avoid cross-tenant leakage
# (e.g. "tnt:42:user:1" — never shared global keys)
# 7) keep memcached updated (security CVEs do happen)
# 8) audit with stats conns to see who's connected
# 9) log and alert on unexpected connection sources
# 10) treat a cache breach as a data breach: rotate any tokens that
# might have been cachedMemcached vs. Redis
Datentypen & Features
Memcached ist ein reiner String-Key-Value-Cache; Redis ist ein Data-Structure-Server mit Listen, Hashes, Sets, Sorted Sets, Streams, Lua-Scripting, Transaktionen, Pub/Sub und Modulen. Redis' Reichtum ist eine Stärke, wenn du ihn brauchst, aber Memcacheds Minimalismus ist für reines Caching ein Feature — weniger Angriffsfläche, weniger falsch Konfigurierbares. Wähle danach, ob du serverseitige Datenstrukturen brauchst.
# Memcached:
# - strings only (key -> bytes), plus the numeric incr/decr trick
# - no lists, hashes, sets, sorted sets, streams, pub/sub
# - no server-side scripting (no Lua)
# - no transactions (single-key CAS only)
# - no keyspace notifications
#
# Redis:
# - rich types: strings, lists, hashes, sets, zsets, streams, ...
# - Lua scripting, MULTI/EXEC transactions, pub/sub
# - modules (RedisJSON, RediSearch, RedisGraph, ...)
# - per-key TTL on any type
#
# verdict: Redis is a data-structure server; memcached is a
# pure key-value cache. Pick memcached when you only need a cache.Persistenz
Memcached hat keinerlei Persistenz — ein Neustart leert ihn per Design, der Cache ist immer Wegwerfware. Redis bietet RDB-Snapshots und AOF-Dauerhaftigkeit plus Replikation und kann als primärer Datenspeicher dienen. Muss der Cache Neustarts überleben oder verbindliche Daten halten, gewinnt Redis; willst du einen reinen flüchtigen Cache, der bei Miss neu aufbaut, ist Memcacheds Einfachheit eine Tugend.
# Memcached:
# - NO persistence. A restart loses everything. By design.
# - no snapshots, no AOF, no replication
# - the cache is always disposable; rebuild from the DB on miss
#
# Redis:
# - RDB snapshots (point-in-time) and AOF (append-only log)
# - can act as a primary datastore with durability
# - replication + sentinel/cluster for HA
#
# verdict: if you need the cache to survive restarts, use Redis.
# if you want a pure volatile cache (and rebuild on miss), memcached's
# lack of persistence is simpler and faster.Replikation & Clustering
Memcached hat kein serverseitiges Clustering oder Replikation — Verteilung liegt vollständig im Client, und ein toter Knoten verliert seine Schlüssel dauerhaft. Redis bietet Master/Replica-Replikation, Sentinel für HA und Redis Cluster für Sharding mit automatischem Failover. Memcached ist einfacher zu betreiben (kein Gossip, keine Failover-Logik) bietet aber keine HA; Redis tauscht operative Komplexität gegen echte Resilienz.
# Memcached:
# - NO server-side clustering or replication
# - sharding is 100% client-side (consistent hashing)
# - a dead node loses its keys; clients reroute
# - scale out = add nodes to the ring
#
# Redis:
# - master/replica replication (async)
# - Sentinel for HA/failover
# - Redis Cluster for sharding + automatic failover
# - more moving parts, but true HA
#
# verdict: memcached is simpler to operate (no cluster gossip) but
# has no failover — a dead node is data loss for its keys.
# Redis gives you replication + failover at the cost of complexity.Performance-Charakteristik
Beide sind im Speicher und sub-millisekundenschnell. Memcached ist standardmäßig multithreaded und skaliert über Kerne für reines get/set, während Redis (meist) single-threaded für die Befehlsausführung ist — auf einer großen Multi-Core-Maschine, die nur get/set macht, kann Memcached also höhere QPS erreichen. Für die meisten realen Apps ist der Unterschied vernachlässigbar; nach Features und operativer Passung wählen, nicht nach Microbenchmarks.
# Both are in-memory and very fast (sub-millisecond, >100k ops/s).
#
# Memcached:
# - multi-threaded by default (-t workers); scales across cores
# - simple protocol, low overhead per op
# - excellent for high-throughput pure get/set
#
# Redis:
# - single-threaded command execution (Redis 6+ threads the I/O)
# - one core does the work; more cores don't speed a single command
# - richer ops can be slower, but core get/set is comparable
#
# verdict: for pure get/set at very high QPS on a big multi-core box,
# memcached's multi-threading can win. For most apps the difference
# is negligible; pick by features, not microbenchmarks.Speichereffizienz
Memcacheds Slab-Allocator ist schlank für opake Blobs, verschwendet aber Platz durch Chunk-Aufrundung; Redis hat Overhead pro Schlüssel/Feld, wählt aber kompakte Codierungen (listpack) für kleine Strukturen. Keines ist universell kleiner — Memcached gewinnt bei einheitlichen Blobs, Redis kann bei kleinen strukturierten Daten gewinnen. Mit deinen eigenen Wertformen messen, bevor du annimmst, eines sei billiger.
# Memcached:
# - slab allocator: fixed chunks, some internal fragmentation
# - no per-field overhead (it's just bytes)
# - very lean for small uniform values
# - can waste memory if value sizes don't fit slab classes
#
# Redis:
# - per-key/per-field overhead (complex internal structures)
# - many encodings (listpack, hashtable, skiplist, ...) chosen by size
# - richer structures use more memory than a flat string
# - but more memory-efficient for small structured data via listpack
#
# verdict: memcached is leaner for opaque blobs; Redis can be leaner
# for small structured data (listpack). Measure with your own data.Wann was wählen
Memcached für einen reinen, wegwerfbaren get/set-Cache, wenn operative Einfachheit und multithreaded Skalierung zählen. Redis, wenn du Datenstrukturen, Persistenz, Replikation, Clustering, Lua, Pub/Sub oder Module brauchst. Sie schließen sich nicht aus — viele Stacks fahren beides: Memcached für rohes Seiten-/Abfrage-Caching, Redis für Sessions, Leaderboards, Rate-Limiting und Streams.
# Choose Memcached when:
# - you need a pure, disposable get/set cache
# - you value operational simplicity (no clustering, no persistence)
# - you want multi-threaded scaling on a big box
# - your data is opaque blobs and you rebuild on miss
#
# Choose Redis when:
# - you need data structures (lists, hashes, sets, zsets, streams)
# - you need persistence or durability
# - you need replication / failover / clustering
# - you need server-side logic (Lua, pub/sub, modules)
# - you need per-key TTL on rich types
#
# both can coexist: memcached for raw page/query cache, Redis for
# sessions, leaderboards, rate-limiting, streams.Fehlerbehebung
Connection Refused
Connection refused heißt meist: Server läuft nicht, hört nicht auf der erwarteten Adresse (ein am Loopback gebundenes -l blockiert entfernte Clients), ist gefirewallt oder hat das -c-Verbindungslimit erreicht (listen_disabled_num > 0). Checkliste durchgehen: ps/systemctl für den Prozess, ss/netstat für den Listener, iptables für die Firewall, stats für das Verbindungslimit und journalctl für Absturz-Logs.
# symptom: client reports "connection refused" to 11211
#
# 1) is memcached running?
ps aux | grep memcached
systemctl status memcached
# 2) is it listening on the expected address/port?
ss -tlnp | grep 11211
netstat -tlnp | grep 11211
# 3) check the -l bind address (default = ALL; you may have set 127.0.0.1)
# a client on another host can't reach a loopback-bound server
# 4) firewall blocking?
iptables -L -n | grep 11211
# 5) hit the -c connection limit? (check listen_disabled_num)
echo "stats" | nc -q 1 host 11211 | grep listen_disabled
# 6) check memcached logs / journalctl
journalctl -u memcached -n 100Eviction-Stürme
Steigende Evictions bei vollem Cache bedeuten, dass dein Working Set über -m hinausgeht. Diagnose mit stats (bytes == limit_maxbytes) und stats items (welche Slab-Klasse verdrängt). Fixes: -m erhöhen, TTLs verkürzen, damit Items selbst ablaufen, Slab-Seiten mit slabs reassign/automove umverteilen und nach einem durchgehenden Writer suchen, der Werte aufbläht. Ein dauerhaft voller Cache braucht mehr Speicher oder ein kleineres Working Set.
# symptom: evictions counter rising fast, hit rate dropping
#
# diagnosis:
stats
# STAT evictions 999999 <- climbing
# STAT bytes 67108864
# STAT limit_maxbytes 67108864 <- 100% full
stats items
# STAT items:3:evicted 500000 <- slab class 3 is the victim
# STAT items:3:outofmemory 0
# fixes:
# 1) add memory: raise -m (or cache_memlimit at runtime)
# 2) shorten TTLs so items self-expire before LRU drops them
# 3) rebalance slab classes: slabs reassign <donor> <receiver>
# or: slabs automove 1
# 4) check for a runaway writer creating oversized values
# 5) review your working set — maybe you're caching too muchNiedrige Hit Rate
Eine niedrige Hit Rate (<90 %) mit hoher DB-Last heißt meist: TTLs zu kurz, das Working Set übersteigt den Speicher (Evictions), Schlüssel werden nicht wiederverwendet (flüchtige Bestandteile wie Zeitstempel im Schlüssel), es ist ein Kaltstart, oder Clients uneinig über die Ketama-Konfiguration, sodass Schlüssel auf verschiedene Server fallen. Prüfen, dass alle Clients identische Serverlisten und Hashing nutzen, und die App-Logs auf Muster der Schlüsselwiederverwendung durchsehen.
# symptom: hit rate < 90%, DB load high
#
# diagnosis:
stats
# STAT cmd_get 100000
# STAT get_hits 70000 <- 70% hit rate, too low
# STAT get_misses 30000
# common causes:
# 1) TTL too short -> items expire before reuse (raise TTL)
# 2) working set > cache memory -> evictions (see eviction storm)
# 3) keys not reused -> each request computes a unique key
# (e.g. including a timestamp; remove volatile components)
# 4) cold start -> warmup period; preheat the cache
# 5) multiple client configs -> keys hashed to different servers
# (verify all clients use the same ketama config)
# 6) cache invalidated too eagerly on writes (delete too broad)
# check TTL distribution vs access patterns in your app logsSlab-Verkalkung
Slab-Verkalkung liegt vor, wenn Speicher in Klassen feststeckt, die ihn nicht brauchen, während eine andere Klasse durch Evictions rast — Seiten wandern nicht von selbst. Diagnose mit stats slabs (free_chunks vs. total_pages) und stats items (evicted pro Klasse). Beheben mit slabs reassign (einmalig) oder slabs automove 1 (Hintergrund) und Rückfall vorbeugen, indem -f an die Verteilung deiner Wertgrößen angepasst wird.
# symptom: one slab class keeps evicting while another has free chunks
#
# diagnosis:
stats slabs
# STAT 1:total_pages 4 STAT 1:free_chunks 0 <- class 1 full
# STAT 5:total_pages 12 STAT 5:free_chunks 8000 <- class 5 idle
#
# stats items
# STAT items:1:evicted 99999 <- class 1 churning
# cause: over time, all pages got assigned to popular classes;
# memory is stuck and can't move to where it's needed.
# fixes:
# 1) one-shot: slabs reassign 5 1 # move a page class5 -> class1
# 2) auto: slabs automove 1 # cautious background rebalance
# 3) restart with a better -f growth factor that matches your data
# 4) enable lru_crawler for smarter eviction
# verify after:
stats slabsHohe Speichernutzung
Unerwartete Speichernutzung kommt meist von interner Fragmentierung (Werte passen nicht in Chunks), aufgeblähten Werten (unkomprimiertes JSON) oder schlichter Schlüsselzahl (Overhead pro Item). Diagnose mit stats (bytes vs. limit_maxbytes) und stats slabs (used vs. total chunks). Fixes: große Werte komprimieren, Whitespace und Schlüsselnamen trimmen, -f tunen, um Verschwendung zu mindern, und prüfen, dass -m zum tatsächlich benötigten Working Set passt.
# symptom: memcached using more memory than expected
#
# diagnosis:
stats
# STAT bytes 600000000 # actual item bytes
# STAT limit_maxbytes 671088640 # the -m cap
# STAT bytes_read / bytes_written help gauge traffic
stats slabs
# look at used_chunks vs total_chunks per class — internal
# fragmentation = (total_chunks * chunk_size) - bytes
# common causes:
# 1) internal fragmentation (values don't fit chunks well)
# 2) bloated values (cache full JSON with whitespace; compress!)
# 3) too many keys (key+metadata overhead per item)
# 4) memory leak in the client holding dead connections
# 5) -m is just set high and the working set filled it
# fix: compress large values, trim keys, tune -f, lower -mLangsame Antworten & Timeouts
Langsame Antworten kommen meist von einem Hot Key, der auf einem Thread serialisiert, einem übergroßen Multi-Get, das den Server blockiert, riesigen Werten, die das Netzwerk sättigen, Netzwerklatenz App-Cache, CPU-Sättigung durch zu wenige -t-Threads oder — kritisch — Memcached, das in den Swap geht (niemals Swappen erlauben; -m unter den physischen RAM pinnen). Aggressive Client-Timeouts setzen (50–100 ms), damit ein langsamer Cache zum Origin degradiert statt Requests aufzuhalten.
# symptom: get/set taking >10ms or timing out
#
# 1) a hot key serializing on one server thread (see hot keys)
# 2) huge multi-get blocking a server thread — chunk it
# 3) oversized values (multi-MB) saturating the network/parse
# 4) network latency between app and cache (co-locate them!)
# 5) server CPU saturated (-t too low for load)
# 6) swap! memcached must NEVER swap — check free -m; pin -m below RAM
#
# diagnose:
stats
# STAT curr_connections 4000 <- near -c? pool leak?
# STAT threads 4 <- raise -t?
# top -H -p <pid> <- which thread is hot?
# on the client: set aggressive timeouts (e.g. 50-100ms) so a slow
# cache degrades gracefully to the origin instead of stallingDeployment-Konfiguration
Als Daemon laufen lassen
Memcached als Daemon mit -d starten, immer Rechte mit -u an einen Nicht-root-Nutzer abgeben. Die essenziellen Produktions-Flags: -m (Speicher), -l (Bind-Adresse — niemals auf allen Interfaces lassen), -c (Verbindungslimit), -t (Threads) und -f (Slab-Growth-Factor). Eine pidfile mit -P schreiben, um Verwaltung zu erleichtern, und den Prozess mit einem kurzen Versionscheck über netcat verifizieren.
# start memcached as a background daemon (-d):
memcached -d -m 256 -p 11211 -u memcache -l 127.0.0.1 -c 2048
# common production flags:
# -d daemonize
# -u memcache drop privileges to this user
# -m 256 256 MB item memory
# -l 127.0.0.1 bind to loopback (or private NIC)
# -c 2048 max connections
# -t 8 8 worker threads
# -f 1.25 slab growth factor
# -I 1m max item size
# -v / -vv log verbosity
# -P /var/run/memcached.pid write a pidfile
# check it's up:
echo "version" | nc -q 1 127.0.0.1 11211
# -> VERSION 1.6.24Systemd-Service
Eine systemd-Unit gibt dir Auto-Neustart (Restart=on-failure), Rechteabgabe (User=memcache), File-Descriptor-Limits (LimitNOFILE für viele Verbindungen) und Security-Hardening (NoNewPrivileges, ProtectSystem, PrivateTmp). Die meisten Distributionen liefern eine Default-Unit, die du über /etc/systemd/system/memcached.service.d/override.conf überschreibst statt die ganze Datei neu zu schreiben — das ist portabler.
# /etc/systemd/system/memcached.service
[Unit]
Description=Memcached
After=network.target
[Service]
Type=simple
User=memcache
Group=memcache
ExecStart=/usr/bin/memcached -m 256 -p 11211 -l 127.0.0.1 -c 2048 -t 8 -f 1.25
Restart=on-failure
RestartSec=2
LimitNOFILE=8192
# hardening
NoNewPrivileges=true
PrivateTmp=true
ProtectSystem=strict
ReadWritePaths=/var/run
[Install]
WantedBy=multi-user.target
# enable and start:
# systemctl daemon-reload
# systemctl enable --now memcached
# systemctl status memcachedDocker-Deployment
In Docker gibt es zwei Speichergrenzen: memcacheds -m (Item-Speicher) und das Container-Limit (docker -m). Immer das Container-Limit höher als memcacheds -m setzen, um Raum für Laufzeit und Verbindungen zu lassen, sonst schlägt der OOM-Killer zu. Einen konkreten Versions-Tag pinnen (memcached:1.6) statt :latest für Reproduzierbarkeit, und restart=unless-stopped für Resilienz.
# run memcached in Docker:
docker run -d \
--name memcached \
-p 11211:11211 \
-m 512m \
--restart=unless-stopped \
memcached:1.6 \
-m 256 -c 2048 -t 4 -f 1.25
# note: -m inside the container is memcached's item memory (256 MB);
# the docker -m 512m limit caps the whole container (memcached +
# overhead). Always set the docker limit HIGHER than memcached's -m.
# docker-compose snippet:
# memcached:
# image: memcached:1.6
# command: -m 256 -c 2048 -t 4
# ports:
# - "11211:11211"
# restart: unless-stoppedMehrere Instanzen
Mehrere Memcached-Instanzen pro Host erlauben es, heiße Slab-Klassen zu isolieren, den Neustart-Einfluss pro Prozess zu verkleinern und mehr Kerne zu nutzen — der Client sieht sie einfach als zusätzliche Ringmitglieder. Der Preis sind mehr Verbindungen und prozessbezogener Slab-Seiten-Overhead. Für die meisten Workloads ist ein einziger multithreaded-Prozess (-t an Kernzahl) einfacher und ausreichend; nur bei einem konkreten Flaschenhals splitten.
# run several memcached instances per host for isolation or to
# use more cores efficiently:
#
# instance A: port 11211, 4 GB
memcached -d -m 4096 -p 11211 -l 127.0.0.1 -t 4
# instance B: port 11212, 4 GB
memcached -d -m 4096 -p 11212 -l 127.0.0.1 -t 4
# the client treats them as two ring members (more shards).
# trade-offs:
# + isolates a hot slab class to its own process
# + smaller per-process working set = simpler restarts
# - more connections to manage
# - more memory overhead per process (slab pages don't share)
# alternative: one process with -t 8 threads (simpler, usually fine)Speicherbemessung
-m auf das gemessene Working Set plus Luft bemessen, Ziel 70–80 % Auslastung bei Spitze, damit du Raum für Lastspitzen hast und keine Eviction-Churn erzeugst. Memcached niemals swappen lassen — -m unter den verfügbaren RAM halten, nach Abzug von OS und anderen Prozessen. Liegt die ständige Auslastung über 90 %, entweder -m erhöhen oder das Working Set verkleinern (kürzere TTLs, weniger Gecachtes).
# how big should -m be?
#
# 1) measure your working set: the keys actually hot in a typical hour
# 2) add headroom: target ~70-80% memory utilization at peak
# 3) leave RAM for the OS, connections, and slab overhead
#
# rule of thumb:
# -m = working_set_bytes / 0.75
#
# example: 3 GB working set -> -m 4096 (4 GB) for 75% utilization
#
# never let memcached swap:
# -m must be BELOW available RAM (check free -m)
# account for other processes on the same host
#
# monitor utilization:
stats
# STAT bytes 3221225472 # 3 GB used
# STAT limit_maxbytes 4294967296 # 4 GB cap -> 75% utilization
# if utilization > 90% steady: raise -m or shrink the working setLogging & Verbosity
Memcached ist von Natur aus still; verbosity mit -v/-vv/-vvv oder dem Laufzeitbefehl verbosity nur zum Debuggen erhöhen, denn jede Protokollierung einzelner Befehle bricht den Durchsatz. In Produktion still laufen lassen und auf stats plus einen Prometheus-Exporter für Sichtbarkeit bauen. Logs gehen unter systemd an journald, in Containern an docker logs. -vv kurz nutzen, um ein konkretes Problem nachzuverfolgen, dann zurückdrehen.
# memcached is deliberately quiet; increase verbosity for debugging:
memcached -v # log errors + warnings
memcached -vv # also log each command (very noisy!)
memcached -vvv # even more (connection-level detail)
# change at runtime without restart:
verbosity 2 # telnet in and raise the level
verbosity 0 # back to quiet
# with systemd, logs go to journald:
journalctl -u memcached -f
# with Docker:
docker logs -f memcached
# in production, run quiet (no -v) — verbose modes are only for
# debugging, as logging every command kills throughput.
# for access patterns, use stats + an exporter instead of -vv.Fortgeschrittene Themen
Binärprotokoll im Detail
Der feste 24-Byte-Header des Binärprotokolls ermöglicht effizientes Parsing, SASL-Auth und quiet-Opcodes (antwortunterdrückend), die pipelined Massenoperationen deutlich effizienter machen als das Textprotokoll. Ein Noop am Ende einer quiet-Pipeline spült sie und hebt Fehler. Die meisten Produktions-Clients nutzen oder bevorzugen das Binärprotokoll wegen seines niedrigeren Overheads pro Operation und des reicheren Feature-Sets.
# the binary protocol uses a fixed 24-byte request header:
#
# Magic (1) 0x80 request / 0x81 response
# Opcode (1) 0x01 Get / 0x02 Set / 0x03 Add / ... / 0x05 Delete ...
# Key length (2)
# Extras length (1)
# Data type (1) usually 0
# VBucket/reserved (2)
# Total body length (4) extras + key + value
# Opaque (4) client-supplied, echoed back
# CAS (8)
#
# followed by: extras | key | value
#
# "quiet" opcodes (GetQ, SetQ, ...) skip responses except on error,
# enabling efficient pipelined bulk operations.
#
# a Noop at the end flushes the pipeline and confirms success.
# prefer the binary protocol in production clients for lower overhead.UDP-Unterstützung
Memcached unterstützt UDP für hochdurchsatzige, verbindungslose Fire-and-Forget-Lookups — nützlich in Spezial-Setups, in denen TCP-Handshake-Kosten dominieren. Es ist verlustbehaftet und größenbegrenzt, also nur für idempotente Cache-Lesevorgänge nutzen. Entscheidend: UDP ist ein bekannter Amplification-DDoS-Vektor (CVE-2018-1000115); in Produktion mit -U 0 deaktivieren, außer bei einem konkreten, gefirewallten Bedarf.
# memcached can serve UDP (-U port, default 11211; -U 0 disables).
# UDP is for very high-throughput, fire-and-forget scenarios where
# a connection setup is too costly.
#
# each UDP datagram carries:
# frame header (8 bytes): request ID, sequence, total datagrams
# then the (possibly multi-datagram) command
#
# limits:
# - responses may arrive out of order or be lost
# - datagram size limits (~1400 bytes payload to avoid fragmentation)
# - no guarantees — use only for cacheable, idempotent lookups
#
# SECURITY: UDP is a known amplification vector (CVE-2018-1000115).
# DISABLE it (-U 0) unless you have a specific, firewalled use case.
memcached -U 0 # recommended in productionGroße Objekte & Chunking
Zwar lässt sich das 1-MB-Item-Limit mit -I erhöhen, große Items schaden aber Durchsatz und Slab-Balance. Das bessere Muster ist Chunking auf Anwendungsebene: den Wert in ~512-KB-Stücke unter nummerierten Schlüsseln teilen, einen Count-Schlüssel speichern und beim Lesen wieder zusammensetzen. Das hält Items slab-freundlich, verhindert die Monopolisierung von Server-Threads und macht einen Teilausfall wiederherstellbar, statt den ganzen Blob zu verlieren.
# memcached's default max item size is 1 MB (-I).
# raising it (-I 4m) works but large items hurt: they're slow to
# transfer, monopolize server threads, and risk slab fragmentation.
#
# better: chunk large values yourself:
#
def set_large(key, value, ttl=3600):
chunks = [value[i:i+512*1024] for i in range(0, len(value), 512*1024)]
for idx, c in enumerate(chunks):
mc.set(key + ":" + str(idx), c, ttl)
mc.set(key + ":n", len(chunks), ttl)
def get_large(key):
n = mc.get(key + ":n")
if n is None: return None
return b"".join(mc.get(key + ":" + str(i)) for i in range(n))
# trade-off: more keys/round-trips, but smaller items fit slabs
# better and a single chunk failure doesn't lose the whole value.Namensräume & Versionierung
Memcached hat keine echten Namensräume — mit Schlüsselpräfixen nachbauen, und ein versioniertes Präfix nutzen, um einen ganzen logischen Namensraum auf einmal zu invalidieren (einen nsver-Schlüssel erhöhen, sodass alte Schlüssel unerreichbar werden und per TTL ausaltern). Ein App-Versions-Präfix gibt jedem Deploy einen frischen Cache. Das ist der kanonische Weg zur Masseninvalidierung, da Memcached Schlüssel weder aufzählen noch per Muster löschen kann.
# memcached has no native namespaces — fake them with key prefixes.
#
# per-tenant isolation:
key = "tnt:" + tenant_id + ":user:" + user_id
# version the whole namespace to invalidate en masse:
ns_version = mc.get("nsver:user") or "1"
key = "user:" + ns_version + ":" + user_id
# to invalidate ALL user:* keys: incr "nsver:user" -> new version
# old keys become unreachable and expire via TTL
# or include a deploy version so each deploy starts fresh:
key = "v" + APP_VERSION + ":user:" + user_id
# time-bucketed namespaces for reports:
key = "report:" + today_date() # auto-expires by date
# NEVER try "flush_all user:*" — memcached can't enumerate keys.
# versioned prefixes are the canonical bulk-invalidation trick.Cache-Stampede verhindern
Eine Stampede entsteht, wenn viele Requests denselben ablaufenden Schlüssel verpassen und ihn alle neu berechnen — der Origin wird unter Beschuss genommen. Der kanonische Fix ist ein add-basiertes Lock, sodass nur ein Client neu baut, während andere kurz warten und erneut versuchen. Mit TTL-Jitter kombinieren, um synchronisierte Ablaufzeiten zu verhindern, und proaktives Refresh (vor dem Ablauf erneuern, stale ausliefern, während ein Client neu baut) bei Hot Keys, wo schon ein einzelner Miss teuer ist.
# a stampede: many requests miss the same expiring key, all
# recompute the same expensive value, overwhelming the origin.
#
# fix 1: lock-and-recompute (only ONE client rebuilds)
def get_with_lock(key, rebuild_fn, ttl=3600, lock_ttl=30):
val = mc.get(key)
if val is not None:
return val
# try to take a rebuild lock
if mc.add("lock:" + key, "1", ttl=lock_ttl):
try:
val = rebuild_fn() # only the winner recomputes
mc.set(key, val, ttl)
return val
finally:
mc.delete("lock:" + key)
else:
# another client is rebuilding; wait briefly and retry
time.sleep(0.05)
return get_with_lock(key, rebuild_fn, ttl, lock_ttl)
# fix 2: add jitter to TTLs so expirations don't synchronize
ttl = base_ttl + random.randint(-60, 60)
# fix 3: "dogpile" — serve a stale value while one client rebuilds
# (store value + a "refresh_at" timestamp; refresh proactively)Verwandte Memcached-Snippets
Copy-paste ready code for common tasks.
set / get — Key-Value-Grundlagen
Werte per Schlüssel mit Ablaufzeit und Flags speichern und abrufen.
add / replace / append / prepend
Bedingte Schreibvorgänge und In-Place-String-Konkatenation.
cas / gets — Compare-And-Swap
Optimistisches Locking: einen Schlüssel nur aktualisieren, wenn er sich seit dem Lesen nicht geändert hat.
stats — Server- & Slab-Metriken
Speicher, Hit Rate, Evictions und Slab-Allokation inspizieren.
flush_all — Alles invalidieren
Alle Schlüssel sofort logisch invalidieren (Lazy Deletion).
Ablauf, Eviction & TTL-Strategie
TTLs klug wählen und verstehen, wie Memcached unter Druck evictet.
Text- vs. Binärprotokoll & Consistent Hashing
Das richtige Protokoll wählen und ohne Reshuffling zwischen Servern sharden.
Patterns: Read-Through, Write-Behind & Session Cache
Memcached auf häufige Anwendungs-Caching-Probleme anwenden.
Was this helpful?