Skip to content

Memcached Aide-mémoire

Système de cache d'objets en mémoire distribué et haute performance.

01

Premiers pas

Connexion et commandes de base

Memcached utilise un protocole texte simple sur le port 11211. La commande set prend flags (un entier 32 bits opaque pour le serveur), exptime (expiration en secondes, 0 = pas d'expiration) et la taille en octets. Les valeurs sont stockées en octets bruts — le serveur ne les inspecte ni ne les modifie jamais. memcached-tool est fourni avec le serveur et pratique pour des stats rapides.

memcached
# 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 mykey

Aperçu du protocole

Memcached supporte un protocole texte ASCII (facile avec telnet/netcat) et un protocole binaire (plus efficace, supporte l'authentification SASL et des opérations atomiques). Le protocole binaire utilise un en-tête fixe de 24 octets et est préféré par la plupart des clients de production. Les deux protocoles opèrent sur le même magasin clé-valeur sous-jacent.

memcached
# 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.24

Règles et limites des clés

Les clés sont limitées à 250 octets et ne peuvent contenir d'espaces ni de caractères de contrôle dans le protocole texte. La taille max par défaut d'une valeur est 1 Mo (augmentez avec le flag -I, ex. -I 4m). Les clés ne sont pas copiées — Memcached les stocke en ligne, donc des clés longues consomment plus de mémoire. Utilisez des clés courtes et structurées comme user:1001 plutôt que des noms descriptifs verbeux.

memcached
# 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 4m

Cas d'usage courants

Memcached excelle pour le cache de données transitoires dérivées : résultats de requêtes DB, sessions, fragments de pages rendus, compteurs de rate-limiting et calculs coûteux. Il est volontairement simple — pas de persistance, pas de réplication, pas de types de données complexes. Traitez-le comme un cache LRU volatile : ne stockez jamais des données que vous ne pouvez pas reconstruire depuis un système de référence.

memcached
# 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}

Aperçu de l'architecture

Memcached est un cache distribué fait de serveurs indépendants et non coordonnés. Pas de clustering, réplication ni failover dans le serveur lui-même — toute la logique de distribution vit dans le client (hachage cohérent). Chaque nœud possède une tranche disjointe de l'espace de clés ; si un nœud meurt, ses données sont perdues et les clients re-routent. Cela garde le serveur ultra simple et rapide, au prix de la durabilité.

memcached
# 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 server
02

Commandes de base (set / get / delete)

set — Stocker une valeur

set stocke une valeur sans condition, écrasant toute clé existante. flags est un entier 32 bits que le serveur stocke mais n'interprète jamais — les clients l'utilisent pour encoder le format de sérialisation (ex. 1 = JSON, 2 = compressé). exptime 0 signifie pas d'expiration ; un timestamp Unix > 30 jours est traité comme temps absolu. noreply saute la réponse pour des écritures fire-and-forget (plus rapide, mais sans rapport d'erreur).

memcached
# 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
# -> STORED

get — Récupérer des valeurs

get récupère une ou plusieurs clés en un seul aller-retour — le batching (multi-get) est critique pour la performance. Chaque ligne VALUE retournée renvoie les flags pour que le client sache désérialiser. Les clés absentes sont silencieusement omises (pas d'erreur). La réponse se termine par END. Les multi-gets volumineux doivent être découpés pour ne pas bloquer un thread serveur.

memcached
# 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 — Récupérer avec token CAS

gets (get étendu) est identique à get mais ajoute un token cas_unique à chaque ligne VALUE. Cet entier 64 bits change à chaque écriture et fonde la concurrence optimiste de Memcached (CAS). Utilisez gets + cas ensemble pour éviter les mises à jour perdues quand plusieurs clients modifient la même clé. Le token est opaque — ne présumez jamais de sa valeur ni de sa monotonie entre clés.

memcached
# 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
# -> STORED

delete — Supprimer une clé

delete supprime une seule clé, retournant DELETED ou NOT_FOUND. Pas de suppression par wildcard ou motif — Memcached n'a aucune commande d'énumération de clés, donc la suppression en masse doit être suivie par l'application (maintenez un ensemble de clés ailleurs ou utilisez des motifs de flush par namespace). Ajoutez noreply pour sauter la réponse. La mémoire libérée retourne à son slab et est réutilisée.

memcached
# 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 et gat — Mettre à jour l'expiration

touch (1.4.8+) met à jour l'expiration d'une clé sans transférer la valeur — moins coûteux que get+set pour rafraîchir des sessions. gat récupère la valeur et met à jour le TTL atomiquement en un aller-retour, idéal pour des lectures de session qui doivent prolonger leur durée de vie. gats retourne aussi le token CAS. Utilisez ces commandes plutôt que get+set pour éviter une course où la valeur change entre les opérations.

memcached
# 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_FOUND
03

Commandes de stockage (add / replace / append / prepend)

add — Stocker seulement si absent

add stocke une valeur seulement si la clé n'existe PAS déjà, retournant NOT_STORED sinon. C'est la manière canonique d'initialiser paresseusement des clés (compteurs, verrous) sans course. Combiné à incr/decr, il forme un motif de compteur sûr : add pour créer à 0, puis incr. Contrairement à SETNX de Redis, add n'a pas de raccourci TTL — réglez exptime dans la commande.

memcached
# 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
# -> 1

replace — Stocker seulement si présent

replace stocke une valeur seulement si la clé EXISTE déjà — le miroir de add. Il empêche de créer accidentellement une entrée de cache depuis un chemin de mise à jour périmé. Retourne NOT_STORED quand la clé est absente. Utilisez-le quand une écriture doit rafraîchir un cache existant sans jamais créer une nouvelle entrée (ex. un rafraîchissement en arrière-plan qui ne doit pas ressusciter une clé évincée).

memcached
# 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 — Ajouter à une valeur existante

append concatène des données à la FIN d'une valeur existante, retournant NOT_STORED si la clé est absente. Les arguments flags et exptime sont acceptés mais ignorés — la valeur garde ses métadonnées d'origine. Parfait pour construire des lignes de log ou des tampons en place sans read-modify-write. Attention : la valeur résultante doit toujours tenir sous la limite de 1 Mo.

memcached
# 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 — Préfixer une valeur existante

prepend est le miroir de append — il concatène des données au DÉBUT d'une valeur existante. Comme append, il exige que la clé existe et ignore flags/exptime. Utile pour empiler des en-têtes/préfixes sur une valeur tamponnée. append et prepend ne sont PAS du read-modify-write atomique entre clients au sens où ils ne retournent pas le résultat — mais ce sont des opérations atomiques côté serveur.

memcached
# 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 change

Comparaison des commandes de stockage

Les six commandes de stockage de Memcached (set, add, replace, append, prepend, cas) ne diffèrent que par leur précondition d'écriture. set est inconditionnel ; add/replace sont conditionnés à l'existence ; append/prepend modifient en place et ignorent les métadonnées ; cas est conditionné au token CAS de gets. Choisir la bonne transforme une course read-modify-write en une seule opération serveur atomique.

memcached
# 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 response
04

CAS (Compare-And-Swap)

gets — Obtenir le token CAS

gets (get étendu) est la moitié lecture du CAS. Il retourne la valeur plus un token cas_unique 64 bits que le serveur garantit changer à chaque modification de cette clé. Vous capturez ce token et le redonnez à cas ; si le token correspond toujours, votre écriture réussit. Sans gets, pas de CAS sûr — un get simple omet le token.

memcached
# 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 — Écriture conditionnelle

cas écrit une valeur seulement si le token cas_unique correspond toujours à ce que gets a retourné. STORED signifie que l'écriture s'est appliquée ; EXISTS signifie qu'un autre client a modifié la clé avant (token différent) ; NOT_FOUND signifie que la clé a été supprimée. C'est du verrouillage optimiste — rejouez la boucle gets→modification→cas sur EXISTS. Cela évite les mises à jour perdues sans verrou côté serveur.

memcached
# 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 d'usage CAS : compteur sûr

CAS résout le problème de mise à jour perdue quand vous avez besoin de sémantique read-modify-write (ex. mettre à jour un blob JSON dans une entrée de cache). Sur EXISTS, il faut relire avec gets, réappliquer votre transformation et rejouer cas — typiquement avec un nombre de tentatives borné pour éviter le live-lock. Pour des compteurs entiers purs, incr/decr sont plus simples et atomiques ; réservez CAS aux valeurs structurées.

memcached
# 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)

Échec CAS et nouvelle tentative

Une boucle CAS robuste doit gérer trois issues : clé absente (utilisez add, retombez sur une nouvelle tentative si NOT_STORED), token correspondant (STORED, terminé), token différent (EXISTS, réessayez). Limitez les tentatives pour éviter le live-lock sous contention. Si la clé manque réellement, préférez add à set pour que deux clients en course à la création ne s'écrasent pas mutuellement.

memcached
# 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")

Limites du CAS

CAS ne marche que sur une seule clé — Memcached n'a pas de transactions multi-clés comme MULTI/EXEC de Redis. Il est optimiste, pas pessimiste : sous forte contention, beaucoup d'écritures tombent sur EXISTS et réessayent, donc fragmentez les clés chaudes. Le cas_unique est par clé et opaque ; ne le comparez jamais entre clés ni ne présumez d'un ordre. Si une clé est évincée puis recréée, le token se réinitialise : traitez NOT_FOUND comme un nouveau départ, pas un échec.

memcached
# 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)
05

Compteurs (incr / decr)

incr — Incrément atomique

incr ajoute atomiquement un entier positif à une clé dont la valeur est une chaîne décimale, retournant la nouvelle valeur. L'opération est pleinement atomique entre clients concurrents — aucune mise à jour perdue. La valeur doit être numérique ASCII non signée 64 bits (pas de signes, pas de décimales). incr sur une clé absente retourne NOT_FOUND ; sur des données non numériques il échoue. Pas d'auto-création — utilisez add d'abord.

memcached
# 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_FOUND

decr — Décrément atomique

decr soustrait atomiquement d'une valeur numérique et retourne le résultat. Il est borné à 0 — il ne produit jamais de nombre négatif, pratique pour des compteurs de stock mais cela signifie qu'on ne peut pas suivre des soldes négatifs nets avec decr. Comme incr, il exige des chiffres ASCII et une clé existante (sinon NOT_FOUND).

memcached
# 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_ERROR

Initialiser les compteurs

Comme incr/decr retournent NOT_FOUND sur une clé absente, les compteurs doivent être initialisés avec add (sans course : le premier appelant crée à 0, les autres reçoivent NOT_STORED et passent directement à incr). N'initialisez jamais un compteur que vous incrémentez avec set — set écrase sans condition et fait la course aux incréments concurrents. Namespacez les compteurs par date et réglez un TTL pour qu'ils expirent automatiquement.

memcached
# 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-02

Cas d'usage des compteurs

Les compteurs brillent pour le rate limiting (clé par IP+minute avec TTL de 60s), les statistiques de vues/téléchargements, les comptes d'utilisateurs actifs quotidiens, l'inventaire et les métriques de déploiement. Ils sont atomiques et bon marché, donc supportent de très hauts taux d'écriture. Pour le rate limiting, choisissez une granularité de clé (par utilisateur, par IP) et un TTL qui matchent votre fenêtre — et rappelez-vous que decr est borné à 0, donc l'inventaire ne peut pas devenir négatif.

memcached
# 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 1

Limites des compteurs

Les compteurs sont des entiers non signés 64 bits uniquement — pas de flottants, pas de négatifs, pas de signes. incr/decr ne créent jamais une clé automatiquement. decr est borné à 0. Comme la valeur n'est qu'une chaîne, un set/replace égaré l'écrasera et anéantira les incréments concurrents — initialisez avec add et n'utilisez ensuite que incr/decr. Pour des flottants ou des compteurs multi-champs, utilisez CAS sur une valeur structurée.

memcached
# 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 races
06

Expiration et TTL

set avec expiration

exptime est en secondes : 0 signifie jamais expirer, les valeurs jusqu'à 2592000 (30 jours) sont des TTL relatifs, et les valeurs supérieures sont interprétées comme des timestamps Unix absolus. Les éléments expirés ne sont pas récoltés activement à la seconde exacte — Memcached utilise une expiration paresseuse (vérifiée à l'accès) plus un crawler LRU en arrière-plan, donc une clé périmée peut persister jusqu'à être touchée ou évincée.

memcached
# 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 — Mettre à jour le TTL

touch (1.4.8+) met à jour le TTL d'une clé en place sans transférer la valeur — bien moins cher que get+set pour des sessions à fenêtre glissante. Réglez exptime à 1 pour une suppression douce (la clé devient immédiatement expirée). La même règle des 30 jours relatif-vs-absolu s'applique. touch retourne NOT_FOUND pour les clés absentes, donc les appelants doivent le traiter comme « non caché ».

memcached
# 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_FOUND

gat et gats — Get et touch

gat (1.6+) combine get et touch atomiquement en un seul aller-retour — parfait pour des lectures de session qui doivent faire glisser l'expiration. gats retourne aussi le token CAS. Utiliser get+touch séparément crée une fenêtre où le TTL n'est pas rafraîchi et double les aller-retours ; gat corrige les deux. Pour des lectures glissantes multi-clés, gat accepte plusieurs clés.

memcached
# 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 c

Comportement d'expiration

L'expiration dans Memcached est paresseuse par défaut — une clé n'est récoltée qu'à l'accès, ce qui signifie que des données périmées peuvent occuper la mémoire jusqu'à éviction. Le crawler LRU (1.4.24+) ajoute un balayage en arrière-plan qui libère proactivement les éléments expirés par slab, évitant le gaspillage mémoire. Activez-le en production : lru_crawler enable. Même ainsi, ne comptez jamais sur un timing d'expiration précis pour la correction.

memcached
# 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)

Bonnes pratiques du TTL

Réglez toujours un TTL — des entrées de cache sans limite causent une croissance mémoire illimitée et des bugs de données périmées. Ajoutez un jitter aléatoire (±5–10 %) aux TTL pour que des expirations corrélées ne fassent pas déferler l'origine. Namespacez les données volatiles par date pour que les vieilles entrées expirent seules. Sur un miss, recalculez et stockez dans le même chemin de code pour garder le cache chaud. Utilisez delete, pas TTL=1, pour une invalidation explicite.

memcached
# 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 delete
07

Commandes de statistiques

stats — Aperçu

stats déverse les métriques cœur du serveur : cmd_get/cmd_set (total d'opérations), get_hits/get_misses (taux de hit = hits/cmd_get), evictions (éléments jetés sous pression mémoire), curr_items, bytes vs limit_maxbytes, et les comptes de connexions. Le taux de hit et les évictions sont les deux chiffres à surveiller d'abord. C'est le socle de tout monitoring Memcached.

memcached
# 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 pressure

stats items — Effectifs par slab

stats items rapporte, pour chaque classe de slab, combien d'éléments elle contient (number) et l'âge de son élément le moins récemment stocké (age). Un slab avec un number élevé mais un age faible est brassé ; un slab avec un age élevé contient des données durables. C'est le premier endroit à regarder pour régler les tailles de chunks ou diagnostiquer pourquoi une gamme de tailles est évincée.

memcached
# 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 / hot

stats slabs — État de l'allocateur

stats slabs révèle la disposition de l'allocateur de slabs : chaque classe a un chunk_size (les emplacements d'éléments y sont arrondis), chunks_per_page, total_pages, et des chunks used/free. La mémoire assignée à une classe de slab y reste — elle ne peut pas être rendue aux autres classes. Si une classe est pleine et évince pendant qu'une autre est vide, vous avez une calcification de slabs, adressable avec le réglage de -f (facteur de croissance).

memcached
# 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 slots

stats sizes — Histogramme des tailles

stats sizes construit un histogramme des tailles réelles des éléments (clé+valeur+overhead) pour voir combien de mémoire est gaspillée par l'arrondi aux tailles de chunks. Il fait un scan complet et verrouillait historiquement le serveur — les versions modernes le cantonnent derrière un contrôle de safe-mode ; passez --disable-safe-mode pour le forcer. À ne lancer qu'à faible trafic. La sortie aide à choisir le bon facteur de croissance -f.

memcached
# 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 — Inspecter un slab

stats cachedump liste les clés d'une classe de slab donnée (limité à N entrées), utile pour du débogage ponctuel. Il parcourt le LRU du slab et peut être lent ou entièrement désactivé dans certaines builds — ne l'utilisez jamais pour l'énumération de clés en production. Memcached n'offre délibérément aucun moyen efficace de lister toutes les clés ; traitez-le comme une boîte noire indexée par votre application.

memcached
# 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 command

stats reset et autres sous-commandes

stats reset remet à zéro les compteurs cumulés (ops, hits, misses) sans perdre les données — pratique pour mesurer un intervalle frais après un déploiement. Autres sous-commandes utiles : stats settings (config effective), stats conns (détail par connexion sur les builds récents), stats lru_crawler (état du crawler). Les compteurs sont sinon cumulatifs depuis le démarrage du processus, donc reset avant de benchmarker.

memcached
# 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)
08

Réglages et configuration

stats settings — Configuration effective

stats settings montre la configuration en cours : maxbytes (-m), maxconns (-c), growth_factor (-f), item_size_max (-I), si évictions et CAS sont activés, et l'état du crawler LRU. La plupart sont figés au démarrage ; seuls quelques-uns peuvent changer à l'exécution. C'est le premier endroit pour vérifier si votre serveur a bien pris les flags que vous croyez.

memcached
# 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, ...)

Flags de démarrage

La plupart de la configuration passe par des flags de démarrage. Les critiques : -m (mémoire), -l (attachez toujours à 127.0.0.1 ou un réseau privé — n'exposez jamais Memcached publiquement), -c (plafond de connexions), -I (taille max d'élément) et -f (facteur de croissance des slabs). -M inverse le comportement d'éviction en erreur-à-plein au lieu du LRU (rarement souhaité pour un cache). Réglez -t selon vos CPU pour le débit.

memcached
# 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 verbosity

Configuration à l'exécution

Memcached n'expose que quelques molettes à l'exécution : cache_memlimit (redimensionner le plafond mémoire à chaud), la famille lru_crawler (activer/désactiver/régler le récolteur en arrière-plan), verbosity (niveau de log) et flush_all (invalider tous les éléments, optionnellement différée). La plupart des réglages restent figés au démarrage — pour changer -m, -c ou -I, redémarrez le processus. flush_all est une opération de control-plane, pas un réglage.

memcached
# 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 seconds

Réglages importants expliqués

-m est le réglage vedette : dimensionnez-le à votre working set plus de la marge, car un sous-dimensionnement cause évictions et brassage de cache. -f échange la granularité des classes de slab contre la fragmentation interne — baissez-le (vers 1.1) quand vous avez beaucoup d'éléments de tailles proches. -I plafonne la taille des éléments ; ne l'augmentez que si vous devez cacher de gros blobs. -M est rarement utilisé pour un cache — il transforme l'OOM en erreurs au lieu d'évictions.

memcached
# -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 throughput

Limites de connexions et threads

-c plafonne les connexions concurrentes — réglez-le confortablement au-dessus de (pool_size × instances d'app) sinon les clients seront refusés (surveillez listen_disabled_num dans stats). -t règle les threads de travail ; Memcached est événementiel par thread, donc calibrez -t sur les cœurs CPU, typiquement 4 à 8. Au-delà, la contention de verrous limite les gains. Chaque thread possède une tranche de la table de hachage, donc plus de threads n'aide pas une seule clé chaude.

memcached
# -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 conns
09

Stratégies de cache

Cache-Aside (chargement paresseux)

Cache-aside est le motif le plus simple et le plus répandu : l'app lit d'abord le cache, et sur un miss charge depuis la DB et remplit le cache a posteriori. Résilient (une panne de cache signifie juste plus de charge DB) mais permet des stampedes sur clés froides et de l'obsolescence jusqu'à invalidation explicite. Réglez toujours un TTL même en invalidant à l'écriture, comme filet de sécurité contre les invalidations ratées.

memcached
# 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 invalidated

Read-Through

En read-through, la couche de cache invoque elle-même un loader sur un miss — l'app appelle simplement get et reçoit une valeur. Cela centralise la logique de peuplement du cache et garantit la cohérence entre appelants, au prix d'une lecture DB synchrone dans l'appel de cache. La plupart des clients Memcached n'embarquent pas de read-through, donc c'est généralement implémenté comme un fin wrapper autour du cache-aside.

memcached
# 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 met à jour le cache à chaque écriture, le gardant frais sans chemin d'invalidation séparé. Le compromis : latence d'écriture (cache + DB) et risque d'ordre d'échec — écrire le cache d'abord et échouer en DB laisse le cache détenir des données non durables ; écrire la DB d'abord ouvre une fenêtre d'obsolescence. La plupart des apps combinent write-through pour les clés chaudes et cache-aside pour le reste.

memcached
# 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 écrit au cache immédiatement et persiste en DB de façon asynchrone via une file — donnant une latence d'écriture sub-milliseconde et une absorption des pics. Le coût : cohérence (la DB prend du retard sur le cache) et durabilité (un crash avant que le worker vide la file perd des données). Memcached seul ne sait pas faire ; il faut une file + un worker. Réservez-le aux charges en écriture tolérantes aux pertes, comme compteurs et télémétrie.

memcached
# 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)

Invalidation du cache

L'invalidation est la partie la plus dure du caching. Le delete explicite à l'écriture est la base ; le TTL est le filet de sécurité (réglez-en toujours un). Pour les collections non énumérables, utilisez des clés versionnées (user:1:v42) et incrémentez la version aux changements de schéma/données pour que les vieilles entrées vieillissent. Les clés par tranches temporelles (report:2024-01-01) expirent seules à la date. N'essayez jamais d'invalidation par wildcard — Memcached ne peut pas lister les clés.

memcached
# 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 instead

Stratégies de TTL et d'éviction

Accordez le TTL à la volatilité des données : heures pour des données de référence, minutes pour des données utilisateur, la longueur de fenêtre pour les compteurs de rate-limit. Ajoutez toujours du jitter (±5–10 %) pour éviter des stampedes d'expiration synchronisés. Memcached évince en LRU par slab sous pression mémoire sans épinglage par élément — les seuls leviers sont le TTL et le dimensionnement total. Pour les clés chaudes, utilisez un verrou basé sur add pour qu'un seul client recalcule sur un miss.

memcached
# 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 shortly
10

Bibliothèques clientes

Python (pymemcache)

pymemcache est pur Python, rapide et explicite. Utilisez le Client simple pour un serveur unique et HashClient pour un cluster avec hachage cohérent. set/get sont la base ; get_many batche un multi-get. Utilisez add+incr pour les compteurs et gets/cas pour les mises à jour optimistes. Passez toujours des timeouts explicites — un nœud mort doit échouer vite, pas suspendre votre thread de requête.

memcached
# 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)

Le package npm memcached supporte des configurations mono et multi-serveurs (hachage cohérent), le pooling de connexions et les retries. set/get/getMulti (multi-get batché) couvrent le chemin courant. Configurez poolSize selon votre concurrence et réglez toujours un timeout pour qu'un nœud mort échoue vite. La bibliothèque est en style callback ; enveloppez-la en Promises ou utilisez util.promisify pour un confort async/await.

memcached
// 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 shutdown

PHP (extension memcached)

L'extension PHP memcached (bâtie sur libmemcached) est le choix de production — réglez OPT_LIBKETAMA_COMPATIBLE pour un hachage cohérent entre serveurs, et addServers pour un cluster. getMulti batche les lectures. cas() prend le token du tableau de résultat de fetch(). Évitez l'ancienne extension memcache (sans « d ») ; elle manque de fonctionnalités et est moins maintenue. Réglez toujours des TTL et gérez proprement Memcached::RES_NOTFOUND.

memcached
<?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 est le client Ruby Memcached canonique — pur Ruby, thread-safe, et le store de cache par défaut de Rails. Passez un tableau de serveurs pour un cluster à hachage cohérent (ketama). Sa forme de bloc cas relit et réessaie automatiquement en cas de conflit, bien plus ergonomique que des boucles manuelles. Configurez expires_in globalement et surchargez par appel pour des TTL plus serrés.

memcached
# 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 est un client Java hautes performances, asynchrone et basé NIO. Son API est basée Future ; get() bloque quand vous avez besoin de confirmation. Passez une liste de serveurs séparée par espaces à AddrUtil pour le hachage cohérent. gets()/cas() offrent la concurrence optimiste, et getBulk() un multi-get batché. Appelez toujours shutdown() à l'arrêt de l'app pour libérer les threads IO.

memcached
// 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) est le client Go de facto — simple, rapide, et supporte le hachage cohérent sur plusieurs serveurs. Set/Get prennent une struct Item qui regroupe clé, valeur, TTL et token CAS ; CompareAndSwap fait la mise à jour optimiste. GetMulti retourne une map indexée par nom (les clés absentes sont absentes, pas des erreurs). Il est concurrency-safe ; réutilisez un client entre goroutines.

memcached
// 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")
11

Architecture distribuée

Hachage cohérent

Le hachage cohérent place serveurs et clés sur un anneau ; une clé appartient au serveur suivant dans le sens horaire. Ajouter ou retirer un serveur ne déplace que sa tranche de clés (environ 1/N), pas tout l'espace de clés — bien mieux que hash(key) % N qui remappe presque tout à chaque changement. La plupart des clients utilisent la variante ketama avec beaucoup de nœuds virtuels par serveur pour une répartition équilibrée.

memcached
# 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 servers

Sharding côté client

Tout le sharding vit dans le client : il hache chaque clé vers un serveur et distribue les multi-gets en parallèle. Chaque clé existe sur exactement un nœud — pas de réplication, donc un nœud mort perd sa tranche de l'espace de clés. Pas de proxy ni de coordinateur ; chaque client doit partager la même liste de serveurs et la même config de hachage (ketama) sinon les clés atterriront sur des nœuds différents et causeront des misses massifs.

memcached
# 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-replicate

Algorithmes de hachage (Ketama)

Ketama est le schéma de hachage cohérent canonique de memcached : chaque serveur physique est projeté sur l'anneau comme beaucoup de nœuds virtuels (~160) pour un chargement équilibré. Localiser une clé : hacher puis marcher dans le sens horaire jusqu'au nœud suivant. Le piège critique : chaque client dans chaque langage doit utiliser le même algorithme et des chaînes d'étiquettes de serveur identiques, sinon ils désaccordent la propriété et provoquent des misses massifs après un déploiement.

memcached
# 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)

Ajouter et retirer des serveurs

Avec le hachage cohérent, ajouter ou retirer un serveur remappe seulement ~1/N des clés — bien mieux que le hachage modulo qui remappe presque tout. Mais le crash d'un serveur perd quand même définitivement ses clés (pas de réplication), causant un pic transitoire de charge sur l'origine pendant le repeuplement. Déployez les changements de membres à tous les clients d'un coup, et envisagez de pré-chauffer un nouveau nœud en doublant les lectures avant sa mise en service.

memcached
# 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)

Réplication et failover

Memcached n'a ni réplication ni failover intégrés — un nœud mort perd ses données et les clients re-routent. Pour ajouter de la redondance : répliquer dans le client (écrire sur N nœuds, plus coûteux), tourner un proxy comme mcrouter/twemproxy, ou accepter la perte et reconstruire depuis l'origine. Le choix idiomatique est le dernier : traitez le cache comme consommable, dimensionnez le pool pour que la perte d'un nœud soit tolérable, et laissez les misses remplir depuis la DB.

memcached
# 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 survivable
12

Gestion mémoire (Slabs / LRU)

Allocateur de slabs

Memcached utilise un allocateur de slabs : la mémoire est divisée en classes de chunks de taille fixe, et un élément est stocké dans le plus petit chunk qui l'abrite (par arrondi supérieur). Cela évite la fragmentation malloc/free et donne une allocation O(1), au prix d'une fragmentation interne (espace perdu dans les chunks) et d'une calcification des classes (la mémoire ne peut pas migrer entre classes). C'est pourquoi une répartition homogène des tailles de valeurs compte pour l'efficacité.

memcached
# 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 slabs

Classes de slabs et facteur de croissance

Les tailles des classes de slabs démarrent au minimum -n (défaut 48 octets) et croissent par le facteur -f (défaut 1.25) jusqu'à la taille max -I. Un -f bas donne plus de classes plus fines (moins de gaspillage, plus de risque de calcification) ; un -f haut donne moins de classes plus grossières (plus de gaspillage). Inspectez votre histogramme réel des tailles avec stats sizes et réglez -f pour que les tailles populaires tombent sur des classes bien remplies.

memcached
# 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 80

Éviction LRU

L'éviction est par classe de slab et strictement LRU dans cette classe : quand une classe est pleine, l'élément le moins récemment utilisé de cette classe est jeté pour faire place. Une classe avec des chunks libres n'évince jamais, donc une distribution de tailles déséquilibrée peut causer de fortes évictions dans une classe pendant qu'une autre chôme — le classique problème de calcification des slabs. Surveillez evictions et evicted_active dans stats pour le repérer.

memcached
# 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 0

Limites mémoire (-m)

-m plafonne la mémoire des éléments en Mo ; une fois atteint, Memcached cesse d'ajouter des pages de slab et évince en LRU dans les classes. -M change la politique en erreur-à-plein au lieu d'évincer (rarement souhaitable pour un cache). cache_memlimit redimensionne le plafond à chaud. Dimensionnez -m à votre working set avec marge — tourner à 100 % signifie évictions constantes et un cache brassé à faible taux de hit.

memcached
# -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 limit

Politiques d'éviction et réglages

La seule politique d'éviction de Memcached est le LRU par slab — pas d'option LFU ni aléatoire. Pour réduire les évictions : augmentez -m, raccourcissez les TTL, rééquilibrez les tailles de valeurs ou réglez -f. Les builds modernes ajoutent un crawler LRU et la capacité de réassigner des pages de slab (slabs reassign / slabs automove) pour atténuer la calcification. Détectez une classe chaude avec les compteurs evicted/outofmemory de stats items.

memcached
# 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 et reassign

slabs reassign (manuel) et slabs automove (1.5+, automatique) permettent de rééquilibrer les pages de slab d'une classe avec des chunks libres vers une classe sous pression d'éviction — le remède à la calcification. automove=1 est un déplaceur d'arrière-plan prudent et lent, sûr en production ; =2 est agressif et expérimental. Vérifiez toujours avec stats slabs avant et après — une mauvaise réassignation peut affamer une classe.

memcached
# 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 give
13

Optimisation des performances

noreply et pipelining

noreply coupe la réponse par écriture, et le pipelining batche beaucoup de commandes en un seul aller-retour réseau — ensemble, c'est le plus grand levier de débit pour les écritures en masse. Le multi-get fait pareil pour les lectures. Le coût de noreply est la perte du retour d'erreur par commande, réservez-le donc aux écritures non critiques à fort volume et gardez les réponses pour tout ce dont un échec doit être signalé.

memcached
# 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:4

Protocole binaire

Le protocole binaire est plus efficace que l'ASCII — un en-tête fixe de 24 octets au lieu d'un parseur texte, des opérations quiet natives (style noreply) pour le pipelining, et le support SASL pour l'auth. Pour de petites valeurs et des écritures en masse à haut débit, il est mesurablement plus rapide. Le serveur parle les deux protocoles sur le même port, donc l'activer est un choix purement côté client. Préférez-le dans les clients de production.

memcached
# 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 required

Pooling de connexions

Le pooling de connexions est essentiel — ouvrir une connexion TCP par requête brûle des ports éphémères et ajoute de la latence. Gardez un petit pool de connexions persistantes par serveur et par processus, dimensionné à votre concurrence. Surveillez total_connections vs curr_connections dans stats : si total croît avec le trafic pendant que curr reste plat, vous pooléz ; si total explose, non. La plupart des clients poolent en interne quand configurés.

memcached
# 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 count

Opérations en masse (multi-get)

Un multi-get récupère N clés en un aller-retour — la plus grande optimisation de lecture disponible. Les clients répartissent les clés sur les serveurs en parallèle, donc la latence est bornée par le serveur le plus lent plutôt que par le nombre de clés. Découpez les très gros multi-gets (ex. 100 clés) pour ne pas monopoliser un thread serveur, et rappelez-vous que les clés absentes sont silencieusement absentes de la map de résultat.

memcached
# 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 result

Dimensionner les valeurs

Comme les éléments sont arrondis à la taille de chunk supérieure, la taille des valeurs pilote directement la fragmentation interne — une valeur de 60 octets dans un chunk de 96 gaspille 37 %. Dimensionnez bien : rognez les espaces du JSON, compressez au-delà de ~1 Ko (et utilisez un bit de flags pour le marquer), et cachez des projections plutôt que des blobs entiers. Inspectez votre histogramme de tailles avec stats sizes et réglez -f pour que les tailles courantes tombent près des frontières de chunks.

memcached
# 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)

Éviter les clés chaudes

Une clé chaude est un goulot mono-serveur, mono-thread — ses lectures se sérialisent sur un nœud pendant que les autres chôment. Fragmentez-la en N buckets (lisez un bucket aléatoire, écrivez sur tous à la mise à jour), ajoutez un TTL côté client d'une seconde pour fusionner les rechargements, ou déplacez-la dans un LRU intra-processus. Détectez les clés chaudes par déséquilibre CPU entre serveurs ou, en 1.6+, avec lru_crawler metadump pour apercevoir la fréquence d'accès.

memcached
# 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+)
14

Monitoring

Stats cœur à surveiller

Les quatre métriques vedettes : le taux de hit (get_hits/cmd_get, cible >95 %), les évictions (pression mémoire, cible 0 en régime établi), l'utilisation mémoire (bytes/limit_maxbytes, cible <90 %) et listen_disabled_num (plafond de connexions atteint, cible 0). Suivez-les en taux dans le temps, pas seulement en compteurs. Un taux de hit qui chute ou des évictions qui montent sont les premiers signes d'un cache mal en point.

memcached
# 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 -c

memcached-tool

memcached-tool est le CLI fourni pour un contrôle ponctuel rapide : stats pour une table par slab, display pour une vue rafraîchie en direct, dump pour apercevoir les clés (débogage seulement — il parcourt le LRU). Parfait pour un one-off en SSH, pas pour un monitoring continu ; associez-le à un exporteur Prometheus et Grafana pour des tableaux de bord et alertes de production.

memcached
# 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.

Monitoring par telnet

Telnet ou netcat vers le port 11211 donne un accès interactif immédiat au protocole texte pour des contrôles ponctuels : stats, stats settings, stats items, stats slabs, version. Utilisez des one-liners nc pour les scripts (echo 'stats' | nc -q 1 host 11211). Rappelez-vous que flush_all est destructif — ne l'aliasez jamais à la légère. C'est la manière la plus frugale d'inspecter un nœud.

memcached
# 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.txt

Exporteur Prometheus et Grafana

memcached_exporter est l'intégration Prometheus standard — tournez-en un à côté de chaque nœud et scrapez :9150. Les tableaux de bord Grafana suivent ensuite le taux de hit, le taux d'éviction, l'usage mémoire et le remplissage par slab. Alertez sur un taux de hit sous 90 %, toute éviction en régime établi, une mémoire au-delà de 90 % et listen_disabled_num > 0. Cela donne une visibilité continue et historique que le telnet ponctuel ne peut pas.

memcached
# 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%

Métriques clés et alerting

Alertez sur la dégradation du taux de hit (avertissement <90 %, critique <75 %), toute éviction en régime établi, une mémoire au-delà de 90 % et toute connexion refusée. Corrélez toujours les métriques du cache avec celles de l'origine — une chute du taux de hit couplée à un pic de CPU DB est la signature d'une tempête de cache-miss, et des évictions montantes couplées à une latence d'origine croissante pointent vers un cache sous-dimensionné. Suivez les réinitialisations d'uptime pour attraper les redémarrages silencieux.

memcached
# 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 -> undersized
15

Sécurité

Isolement réseau

Le protocole texte de Memcached n'a aucune authentification, donc il ne doit jamais être exposé publiquement — attachez à 127.0.0.1 ou une NIC privée avec -l, désactivez UDP avec -U 0 si inutilisé, et pare-feu 11211 vers les seuls sous-réseaux d'app. Un Memcached publiquement joignable est à la fois un cache de données ouvert et un vecteur d'amplification DDoS UDP (CVE-2018-1000115). L'adresse d'écoute par défaut est toutes interfaces — surchargez-la toujours.

memcached
# 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.

Authentification SASL (protocole binaire)

L'authentification SASL n'existe que sur le protocole binaire (démarrez le serveur avec -S). Elle utilise des credentials PLAIN durant la phase d'établissement de connexion, ajoutant un aller-retour que le pooling amortit. Utilisez SASL sur des réseaux partagés ou multi-tenant où l'isolement réseau seul ne suffit pas. Le protocole texte ne peut pas s'authentifier — si vous avez besoin d'auth, il faut le protocole binaire de bout en bout.

memcached
# 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.

Chiffrement et TLS

Memcached n'a pas de TLS natif — pour chiffrer le trafic, terminez le TLS dans un sidecar comme stunnel ou HAProxy devant chaque nœud, puis faites tourner memcached en clair derrière, sur le loopback. Pour la plupart des déploiements LAN, l'isolement réseau plus SASL optionnel suffit ; réservez TLS aux flux inter-réseaux ou aux environnements à exigence de conformité. Des forks récents (et certains services gérés cloud) ajoutent un TLS natif.

memcached
# 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.

Pare-feu et contrôle d'accès

Superposez vos défenses : attachez à une NIC privée, pare-feu vers les sous-réseaux d'app, désactivez UDP, ajoutez SASL sur les réseaux partagés, tournez comme utilisateur non root, et appliquez le durcissement systemd (NoNewPrivileges, ProtectSystem, PrivateTmp). Critique : ne stockez jamais de secrets bruts dans Memcached — c'est un cache, pas un coffre ; chiffrez-puis-cachez ou gardez les secrets dans un gestionnaire dédié et ne cachez que des références non sensibles.

memcached
# 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=true

Bonnes pratiques de sécurité

Les règles cardinales : n'exposez jamais Memcached publiquement, attachez toujours à une interface privée, désactivez UDP, et utilisez SASL sur les réseaux partagés. Ne stockez pas de secrets ni de PII non chiffrés ; namespacez les clés par tenant pour prévenir les fuites entre utilisateurs. Gardez le serveur à jour, auditez les connexions avec stats conns, et traitez une breach du cache comme une breach de données — rotez tout token qui aurait pu être caché.

memcached
# 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 cached
16

Memcached vs Redis

Types de données et fonctionnalités

Memcached est un cache clé-valeur à chaînes pures ; Redis est un serveur de structures de données avec listes, hashes, sets, sorted sets, streams, scripting Lua, transactions, pub/sub et modules. La richesse de Redis est un atout quand vous en avez besoin, mais le minimalisme de Memcached est une fonctionnalité pour du pur caching — moins de surface, moins de misconfigurations possibles. Choisissez selon le besoin de structures de données côté serveur.

memcached
# 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.

Persistance

Memcached n'a aucune persistance — un redémarrage le vide par conception, et le cache est toujours jetable. Redis offre des snapshots RDB et la durabilité AOF plus la réplication, donc il peut servir de magasin de données primaire. Si vous avez besoin que le cache survive aux redémarrages ou détienne des données autoritaires, Redis gagne ; si vous voulez un pur cache volatile qui se reconstruit au miss, la simplicité de Memcached est une vertu.

memcached
# 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.

Réplication et clustering

Memcached n'a ni clustering ni réplication côté serveur — la distribution est entièrement côté client, et un nœud mort perd définitivement ses clés. Redis offre la réplication master/replica, Sentinel pour la HA, et Redis Cluster pour le sharding avec failover automatique. Memcached est plus simple à opérer (pas de gossip, pas de logique de failover) mais n'offre aucune HA ; Redis échange de la complexité opérationnelle contre une vraie résilience.

memcached
# 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.

Caractéristiques de performance

Les deux sont en mémoire et sub-milliseconde. Memcached est multi-threadé par défaut et s'adapte sur plusieurs cœurs pour du pur get/set, tandis que Redis est (presque) mono-threadé pour l'exécution des commandes — donc sur une grosse machine multi-cœur ne faisant que du get/set, Memcached peut atteindre un QPS supérieur. Pour la plupart des apps réelles, la différence est négligeable ; choisissez selon les fonctionnalités et l'adéquation opérationnelle, pas les microbenchmarks.

memcached
# 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.

Efficacité mémoire

L'allocateur de slabs de Memcached est économe pour des blobs opaques mais gaspille par arrondi aux chunks ; Redis a un overhead par clé/champ mais choisit des encodages compacts (listpack) pour les petites structures. Aucun n'est universellement plus petit — Memcached gagne pour des blobs uniformes, Redis peut gagner pour des petites données structurées. Mesurez toujours avec vos propres formes de valeurs avant de présumer que l'un est moins cher.

memcached
# 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.

Quand choisir lequel

Choisissez Memcached pour un cache get/set pur et jetable où la simplicité opérationnelle et le scaling multi-threadé comptent. Choisissez Redis quand vous avez besoin de structures de données, persistance, réplication, clustering, Lua, pub/sub ou modules. Ils ne s'excluent pas — beaucoup de stacks tournent avec les deux : Memcached pour le caching brut de pages/requêtes et Redis pour les sessions, leaderboards, rate-limiting et streams.

memcached
# 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.
17

Dépannage

Connexion refusée

Connexion refusée signifie généralement que le serveur ne tourne pas, n'écoute pas sur l'adresse attendue (un -l lié au loopback bloque les clients distants), est pare-feué, ou a atteint le plafond -c (listen_disabled_num > 0). Suivez la checklist : ps/systemctl pour le processus, ss/netstat pour l'écouteur, iptables pour le pare-feu, stats pour le plafond de connexions, et journalctl pour les logs de crash.

memcached
# 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 100

Tempêtes d'éviction

Des évictions montantes avec un cache plein signifient que votre working set dépasse -m. Diagnostiquez avec stats (bytes == limit_maxbytes) et stats items (quelle classe de slab évince). Correctifs : augmentez -m, raccourcissez les TTL pour que les éléments expirent seuls, rééquilibrez les pages de slab avec slabs reassign/automove, et traquez un écrivain incontrôlé qui enflerait les valeurs. Un cache persistamment plein exige plus de mémoire ou un working set plus petit.

memcached
# 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 much

Faible taux de hit

Un faible taux de hit (<90 %) avec une forte charge DB signifie généralement des TTL trop courts, un working set qui dépasse la mémoire (évictions), des clés non réutilisées (composants volatils comme des timestamps dans la clé), un démarrage à froid, ou des clients désaccordés sur la config ketama si bien que les clés atterrissent sur des serveurs différents. Vérifiez que tous les clients partagent des listes de serveurs et un hachage identiques, et fouillez vos logs d'app pour des motifs de réutilisation de clés.

memcached
# 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 logs

Calcification des slabs

La calcification des slabs survient quand la mémoire reste coincée dans des classes qui n'en ont pas besoin pendant qu'une autre classe brasse par évictions — les pages ne migrent pas seules. Diagnostiquez avec stats slabs (free_chunks vs total_pages) et stats items (evicted par classe). Corrigez avec slabs reassign (ponctuel) ou slabs automove 1 (arrière-plan), et prévenez la récurrence en réglant -f pour matcher votre distribution de tailles de valeurs.

memcached
# 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 slabs

Usage mémoire élevé

Un usage mémoire inattendu vient généralement de la fragmentation interne (valeurs qui ne tiennent pas les chunks), de valeurs enflées (JSON non compressé), ou du simple nombre de clés (overhead par élément). Diagnostiquez avec stats (bytes vs limit_maxbytes) et stats slabs (chunks used vs total). Correctifs : compressez les grandes valeurs, rognez espaces et noms de clés, réglez -f pour réduire le gaspillage, et vérifiez que -m correspond au working set réellement nécessaire.

memcached
# 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 -m

Réponses lentes et timeouts

Les réponses lentes viennent généralement d'une clé chaude se sérialisant sur un thread, d'un multi-get surdimensionné bloquant le serveur, de valeurs énormes saturant le réseau, de la latence réseau app-cache, d'une saturation CPU par trop peu de threads -t, ou — critique — de Memcached qui swappe (ne le laissez jamais swapper ; épinglez -m sous la RAM physique). Réglez des timeouts clients agressifs (50–100 ms) pour qu'un cache lent dégrade vers l'origine au lieu de suspendre les requêtes.

memcached
# 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 stalling
18

Configuration de déploiement

Tourner comme démon

Faites tourner Memcached comme démon avec -d, en abandonnant toujours les privilèges avec -u vers un utilisateur non root. Les flags de production essentiels : -m (mémoire), -l (adresse d'écoute — ne la laissez jamais sur toutes interfaces), -c (plafond de connexions), -t (threads) et -f (facteur de croissance des slabs). Écrivez un pidfile avec -P pour une gestion facile, et vérifiez le processus par un rapide contrôle de version via netcat.

memcached
# 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.24

Service systemd

Une unité systemd apporte le redémarrage automatique (Restart=on-failure), l'abandon de privilèges (User=memcache), les limites de descripteurs de fichiers (LimitNOFILE pour beaucoup de connexions) et le durcissement de sécurité (NoNewPrivileges, ProtectSystem, PrivateTmp). La plupart des distros fournissent une unité par défaut que vous surchargez via /etc/systemd/system/memcached.service.d/override.conf plutôt que de réécrire tout le fichier — préférez cela pour la portabilité.

memcached
# /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 memcached

Déploiement Docker

Dans Docker, rappelez-vous qu'il y a deux limites mémoire : le -m de memcached (mémoire des éléments) et le plafond mémoire du conteneur (docker -m). Réglez toujours le plafond du conteneur au-dessus du -m de memcached pour laisser de la place au runtime et aux connexions, sinon l'OOM killer frappera. Épinglez un tag de version précis (memcached:1.6) plutôt que :latest pour la reproductibilité, et restart=unless-stopped pour la résilience.

memcached
# 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-stopped

Instances multiples

Faire tourner plusieurs instances Memcached par hôte permet d'isoler des classes de slabs chaudes, de réduire l'impact de redémarrage par processus et d'exploiter plus de cœurs — le client les voit simplement comme des membres supplémentaires de l'anneau. Le coût : plus de connexions et un overhead de pages de slab par processus. Pour la plupart des charges, un seul processus multi-threadé (-t au nombre de cœurs) est plus simple et suffisant ; scindez seulement face à un goulot précis.

memcached
# 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)

Dimensionnement mémoire

Dimensionnez -m à votre working set mesuré plus de la marge, en visant 70–80 % d'utilisation au pic pour avoir de la place et ne pas brasser d'évictions. Ne laissez jamais Memcached swapper — gardez -m sous la RAM disponible après comptage de l'OS et des autres processus. Si l'utilisation en régime établi dépasse 90 %, augmentez -m ou réduisez le working set (TTL plus courts, moins de choses cachées).

memcached
# 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 set

Logs et verbosité

Memcached est discret par conception ; augmentez la verbosité avec -v/-vv/-vvv ou la commande runtime verbosity uniquement pour le débogage, car logger chaque commande écrase le débit. En production, tournez discret et fiez-vous aux stats et à un exporteur Prometheus pour la visibilité. Les logs vont à journald sous systemd ou docker logs en conteneurs. Utilisez -vv brièvement pour tracer un problème précis, puis redescendez.

memcached
# 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.
19

Sujets avancés

Protocole binaire en profondeur

L'en-tête fixe de 24 octets du protocole binaire permet un parsing efficace, l'auth SASL, et des opcodes quiet (supprimant les réponses) qui rendent les opérations en masse pipelinées bien plus efficaces que le protocole texte. Un Noop à la fin d'un pipeline quiet le vide et fait remonter les erreurs. La plupart des clients de production passent au binaire par défaut ou le préfèrent pour son overhead par opération plus faible et son ensemble de fonctionnalités plus riche.

memcached
# 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.

Support UDP

Memcached supporte UDP pour des lookups sans connexion à haut débit, fire-and-forget — utile dans des configurations spécialisées où le coût du handshake TCP domine. C'est lossy et limité en taille, donc ne l'utilisez que pour des lectures de cache idempotentes. Critique : UDP est un vecteur connu d'amplification DDoS (CVE-2018-1000115) ; désactivez-le avec -U 0 en production sauf besoin précis et pare-feué.

memcached
# 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 production

Grands objets et chunking

Bien qu'on puisse augmenter la limite de 1 Mo avec -I, les grands éléments nuisent au débit et à l'équilibre des slabs. Un meilleur motif est le chunking au niveau applicatif : découpez la valeur en morceaux de ~512 Ko sous des clés numérotées, stockez une clé de compte, et réassemblez à la lecture. Cela garde les éléments compatibles slabs, évite de monopoliser les threads serveur, et rend un échec partiel récupérable au lieu de perdre tout le blob.

memcached
# 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.

Namespacing et versioning

Memcached n'a pas de vrais namespaces — simulez-les par préfixes de clés, et utilisez un préfixe versionné pour invalider tout un namespace logique d'un coup (incrémentez une clé nsver pour que les vieilles clés deviennent inatteignables et vieillissent via le TTL). Inclure un préfixe de version d'app donne un cache frais à chaque déploiement. C'est la façon canonique d'invalider en masse, puisque Memcached ne peut ni énumérer ni supprimer par motif.

memcached
# 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.

Prévention des cache stampedes

Un stampede survient quand beaucoup de requêtes ratent la même clé expirante et la recalculent toutes, martelant l'origine. Le correctif canonique est un verrou basé sur add pour qu'un seul client reconstruise pendant que les autres attendent brièvement et réessaient. Combinez avec du jitter de TTL pour prévenir des expirations synchronisées, et un rafraîchissement proactif (rafraîchir avant expiration, servir périmé pendant qu'un client reconstruit) pour les clés chaudes où même un seul miss coûte cher.

memcached
# 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)

Was this helpful?