Primeros pasos
Conexión y comandos básicos
Memcached usa un protocolo de texto simple en el puerto 11211. El comando set toma flags (un entero de 32 bits opaco para el servidor), exptime (expiración en segundos, 0 = sin expiración) y tamaño en bytes. Los valores se guardan como bytes crudos — el servidor nunca los inspecciona ni los modifica. memcached-tool viene con el servidor y es práctico para estadísticas rápidas.
# 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 mykeyVisión general del protocolo
Memcached soporta tanto un protocolo de texto ASCII (fácil de usar con telnet/netcat) como un protocolo binario (más eficiente, soporta autenticación SASL y operaciones atómicas). El protocolo binario usa una cabecera fija de 24 bytes y lo prefieren la mayoría de clientes de producción. Ambos protocolos operan sobre el mismo almacén de clave-valor subyacente.
# 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.24Reglas y límites de claves
Las claves están limitadas a 250 bytes y no pueden contener espacios ni caracteres de control en el protocolo de texto. El tamaño máximo de valor por defecto es 1MB (súbelo con el flag -I, por ejemplo -I 4m). Las claves no se copian — Memcached las guarda en línea, así que las claves largas consumen más memoria. Usa claves cortas y estructuradas como user:1001 en lugar de nombres descriptivos verbosos.
# 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 4mCasos de uso comunes
Memcached es mejor para cachear datos transitorios y derivados: resultados de consultas a bases de datos, sesiones, fragmentos de página renderizados, contadores de rate limit y computaciones caras. Es intencionalmente simple — sin persistencia, sin replicación, sin tipos de datos complejos. Trátalo como una caché LRU volátil: nunca guardes datos que no puedas reconstruir desde un sistema de registro.
# 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}Visión general de la arquitectura
Memcached es una caché distribuida hecha de servidores independientes y no coordinados. No hay clustering, replicación ni failover en el propio servidor — toda la lógica de distribución vive en el cliente (hashing consistente). Cada nodo posee una porción disjunta del espacio de claves; si un nodo muere, sus datos se pierden y los clientes reenrutan. Esto mantiene al servidor extremadamente simple y rápido, a costa de la durabilidad.
# 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 serverComandos básicos (set / get / delete)
set — guardar un valor
set guarda un valor incondicionalmente, sobrescribiendo cualquier clave existente. flags es un entero de 32 bits que el servidor guarda pero nunca interpreta — los clientes lo usan para codificar el formato de serialización (por ejemplo, 1 = JSON, 2 = comprimido). exptime 0 significa sin expiración; una marca de tiempo Unix > 30 días se trata como tiempo absoluto. noreply se salta la respuesta para escrituras fire-and-forget (más rápido, pero sin reporte de errores).
# syntax: set <key> <flags> <exptime> <bytes> [noreply]\r\n<data>\r\n
# response: STORED | NOT_STORED
set greeting 0 0 5
hello
# -> STORED
# with flags (app-defined 32-bit int, e.g. mark as JSON=1)
set config 1 0 14
{"a":1,"b":2}
# -> STORED
# with expiration (3600 seconds) and noreply
set token 0 3600 8 noreply
s3cr3t00
# -> (no response)
# overwrite an existing key
set greeting 0 0 7
goodbye
# -> STOREDget — recuperar valores
get recupera una o más claves en un solo viaje de ida y vuelta — el batcheo (multi-get) es crítico para el rendimiento. Cada línea VALUE devuelta repite los flags para que el cliente sepa cómo deserializar. Las claves ausentes se omiten silenciosamente (sin error). La respuesta termina con END. Los multi-gets grandes deberían fragmentarse para no bloquear un solo hilo del servidor.
# 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 — recuperar con token CAS
gets (get-extended) es idéntico a get pero añade un token cas_unique a cada línea VALUE. Este entero de 64 bits cambia en cada escritura y es la base de la concurrencia optimista de Memcached (CAS). Usa gets + cas juntos para evitar actualizaciones perdidas cuando varios clientes modifican la misma clave. El token es opaco — nunca asumas su valor ni su monotonicidad entre claves.
# gets returns a CAS unique identifier for optimistic concurrency
gets greeting
# VALUE greeting 0 7 12
# goodbye
# END
# ^ cas_unique = 12
# the cas_unique changes every time the key is written
set greeting 0 0 5
hello
gets greeting
# VALUE greeting 0 5 13
# hello
# END (cas_unique is now 13)
# use cas_unique with the cas command for safe updates
cas greeting 0 0 5 13
world
# -> STOREDdelete — eliminar una clave
delete elimina una sola clave, devolviendo DELETED o NOT_FOUND. No hay eliminación por comodines ni patrones — Memcached no tiene ningún comando de enumeración de claves, así que la eliminación masiva debe rastrearse en la aplicación (mantén un conjunto de claves en otro lugar o usa patrones de flush con espacios de nombres). Añade noreply para saltarte la respuesta. La memoria eliminada vuelve a su slab y se reutiliza.
# 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 y gat — actualizar expiración
touch (1.4.8+) actualiza la expiración de una clave sin transferir el valor — más barato que get+set para refrescar sesiones. gat obtiene el valor y actualiza el TTL atómicamente en un solo viaje de ida y vuelta, ideal para lecturas de sesión que deberían extender su vida útil. gats también devuelve el token CAS. Usa estos en lugar de get+set para evitar una carrera donde el valor cambie entre operaciones.
# 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_FOUNDComandos de almacenamiento (add / replace / append / prepend)
add — guardar solo si no existe
add guarda un valor solo si la clave NO existe ya, devolviendo NOT_STORED en caso contrario. Es la forma canónica de inicializar claves con pereza (contadores, locks) sin carrera. Combinado con incr/decr forma un patrón de contador seguro: add para crear a 0, luego incr. A diferencia de SETNX de Redis, add no tiene atajo de TTL — fija exptime en el comando.
# add fails if the key already exists
add newkey 0 0 5
hello
# -> STORED
add newkey 0 0 5
world
# -> NOT_STORED (key already exists)
# common pattern: initialize a counter only once
add counter:daily 0 0 1
0
# -> STORED on first run, NOT_STORED after
# then use incr to bump it
incr counter:daily 1
# -> 1replace — guardar solo si existe
replace guarda un valor solo si la clave YA existe — el espejo de add. Evita crear accidentalmente una entrada de caché desde una ruta de actualización obsoleta. Devuelve NOT_STORED cuando la clave está ausente. Úsalo cuando una escritura deba refrescar caché existente pero nunca poblar una entrada nueva (por ejemplo, un refresco en segundo plano que no deba resucitar una clave desalojada).
# 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 — añadir al final de un valor existente
append concatena datos al final de un valor existente, devolviendo NOT_STORED si la clave está ausente. Los argumentos flags y exptime se aceptan pero se ignoran — el valor conserva sus metadatos originales. Es genial para construir líneas de log o búferes en el sitio sin leer-modificar-escribir. Cuidado: el valor resultante debe seguir cabiendo bajo el límite de 1MB por ítem.
# 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 — anteponer a un valor existente
prepend es el espejo de append — concatena datos al INICIO de un valor existente. Como append, exige que la clave exista e ignora flags/exptime. Útil para apilar encabezados/prefijos sobre un valor en búfer. append y prepend NO son operaciones atómicas de lectura-modificación-escritura entre clientes en el sentido de que no devuelven el resultado — pero son operaciones atómicas del lado del servidor.
# 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 changeComparación de comandos de almacenamiento
Los seis comandos de almacenamiento de Memcached (set, add, replace, append, prepend, cas) difieren solo en su precondición para guardar. set es incondicional; add/replace están condicionados a la existencia; append/prepend modifican en el sitio e ignoran los metadatos; cas está condicionado al token CAS de gets. Elegir el correcto convierte una carrera de lectura-modificación-escritura en una única operación atómica del servidor.
# When does each command succeed?
#
# set -> ALWAYS (create or overwrite)
# add -> only if key does NOT exist
# replace -> only if key ALREADY exists
# append -> only if key exists (adds to end, ignores flags/exptime)
# prepend -> only if key exists (adds to start, ignores flags/exptime)
#
# All return STORED / NOT_STORED / EXISTS / NOT_FOUND as appropriate.
# set: overwrite unconditionally
# add: lazy init (counters, locks)
# replace: refresh only if already cached
# append: grow a buffer / log
# prepend: stack headers
# all accept [noreply] to skip the responseCAS (Compare-And-Swap)
gets — obtener el token CAS
gets (get-extended) es la mitad de lectura de CAS. Devuelve el valor más un token cas_unique de 64 bits que el servidor garantiza que cambia en cada modificación de esa clave. Capturas este token y se lo devuelves a cas; si el token sigue coincidiendo, tu escritura tiene éxito. Sin gets no puedes hacer un CAS seguro — un get plano omite el token.
# 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 — escritura condicional
cas escribe un valor solo si el token cas_unique aún coincide con lo que devolvió gets. STORED significa que la escritura se aplicó; EXISTS significa que otro cliente modificó primero la clave (token no coincidente); NOT_FOUND significa que la clave fue eliminada. Esto es bloqueo optimista — repite el ciclo completo gets→modificar→cas ante EXISTS. Evita las actualizaciones perdidas sin bloqueos del lado del servidor.
# 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)Caso de uso de CAS: contador seguro
CAS resuelve el problema de la actualización perdida cuando necesitas semántica de lectura-modificación-escritura (por ejemplo, actualizar un blob JSON dentro de una entrada de caché). Ante EXISTS debes releer con gets, reaplicar tu transformación y reintentar cas — típicamente con un conteo de reintentos acotado para evitar el livelock. Para contadores enteros puros, incr/decr son más simples y atómicos; recurre a CAS solo cuando el valor es estructurado.
# 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)Fallo de CAS y reintento
Un bucle CAS robusto debe manejar tres desenlaces: clave ausente (usa add, con respaldo de reintento ante NOT_STORED), token coincidente (STORED, terminado) y token no coincidente (EXISTS, reintentar). Acota los reintentos para evitar el livelock bajo contención. Si la clave falta realmente, prefiere add sobre set para que dos clientes compitiendo por crearla no se pisen entre sí.
# 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")Limitaciones de CAS
CAS es solo de una clave — Memcached no tiene transacciones multi-clave como MULTI/EXEC de Redis. Es optimista, no pesimista: bajo mucha contención muchas escrituras darán EXISTS y reintentarán, así que fragmenta las claves calientes. El cas_unique es por clave y opaco; nunca lo compares entre claves ni asumas ordenamiento. Si una clave se desaloja y se recrea, el token se reinicia, así que trata NOT_FOUND como un comienzo fresco en lugar de un fallo.
# 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)Contadores (incr / decr)
incr — incremento atómico
incr añade atómicamente un entero positivo a una clave cuyo valor es una cadena decimal, devolviendo el nuevo valor. La operación es totalmente atómica entre clientes concurrentes — sin actualizaciones perdidas. El valor debe ser ASCII numérico sin signo de 64 bits (sin signos, sin decimales). incr sobre una clave ausente devuelve NOT_FOUND; sobre datos no numéricos da error. No hay auto-creación — usa add primero.
# syntax: incr <key> <value> [noreply]
# the key's value MUST be a numeric string (ASCII digits)
set views 0 0 1
5
# -> STORED
incr views 1
# -> 6
incr views 10
# -> 16
# returns the NEW value as a decimal string
# incrementing a non-numeric value
set name 0 0 5
alice
incr name 1
# -> CLIENT_ERROR cannot increment or decrement non-numeric value
# incr on a missing key
incr missing 1
# -> NOT_FOUNDdecr — decremento atómico
decr resta atómicamente de un valor numérico y devuelve el resultado. Se recorta por abajo en 0 — nunca producirá un número negativo, lo cual es cómodo para contadores de stock/inventario pero significa que no puedes usar decr para seguir saldos netos negativos. Como incr, exige que el valor sean dígitos ASCII y que la clave exista (si no, NOT_FOUND).
# syntax: decr <key> <value> [noreply]
set views 0 0 2
16
# -> STORED
decr views 1
# -> 15
decr views 10
# -> 5
# decr NEVER goes negative — stops at 0
decr views 100
# -> 0
# decr a missing key
decr missing 1
# -> NOT_FOUND
# decr a non-numeric value -> CLIENT_ERRORInicializar contadores
Como incr/decr devuelven NOT_FOUND ante una clave ausente, los contadores deben inicializarse con add (sin carreras: el primero que llega crea a 0, los demás reciben NOT_STORED y pasan directo a incr). Nunca uses set para inicializar un contador que también hagas incr — set sobrescribe incondicionalmente y compite con los incrementos concurrentes. Usar espacios de nombres de contador por fecha y fijar un TTL hace que expiren solos.
# 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-02Casos de uso de contadores
Los contadores brillan para rate limiting (clave por IP+minuto con un TTL de 60s), estadísticas de vistas/descargas, conteos de activos diarios, inventario y métricas de rollout. Son atómicos y baratos, así que escalan a tasas de escritura muy altas. Para rate limiting, elige una granularidad de clave (por usuario, por IP) y un TTL que coincidan con tu ventana — y recuerda que decr se recorta en 0, así que el inventario no puede quedar negativo.
# 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 1Limitaciones de contadores
Los contadores son solo enteros sin signo de 64 bits — sin floats, sin negativos, sin signos. incr/decr nunca auto-crean una clave. decr se recorta en 0. Como el valor es solo una cadena, un set/replace suelto lo sobrescribirá y pisará los incrementos concurrentes — inicializa con add y por lo demás usa solo incr/decr. Para floats o contadores de varios campos, usa CAS sobre un valor estructurado.
# 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 racesExpiración y TTL
set con expiración
exptime va en segundos: 0 significa nunca expirar, los valores hasta 2592000 (30 días) son TTLs relativos, y los mayores se interpretan como marcas de tiempo Unix absolutas. Los ítems expirados no se recogen activamente en el segundo exacto — Memcached usa expiración perezosa (comprobada al acceder) más un crawler LRU en segundo plano, así que una clave rancia puede quedar hasta que se toque o se desaloje.
# 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 — actualizar TTL
touch (1.4.8+) actualiza el TTL de una clave en el sitio sin transferir el valor — mucho más barato que get+set para sesiones de ventana deslizante. Fja exptime en 1 para un borrado suave (queda expirado inmediatamente). Se aplica la misma regla de relativo vs absoluto de 30 días. touch devuelve NOT_FOUND para claves ausentes, así que quien llama debería tratarlo como 'no cacheado'.
# touch: change a key's TTL without fetching the value
# syntax: touch <key> <exptime> [noreply]
set session 0 3600 5
alice
# extend the session by another hour
touch session 3600
# -> TOUCHED
# make it never expire
touch session 0
# -> TOUCHED
# expire it immediately (poor man's delete via TTL)
touch session 1
# -> TOUCHED (effectively deleted on next access)
touch missing 60
# -> NOT_FOUNDgat y gats — get y touch
gat (1.6+) combina get y touch atómicamente en un solo viaje de ida y vuelta — perfecto para lecturas de sesión que deberían deslizar la expiración hacia adelante. gats también devuelve el token CAS. Usar get+touch por separado crea una ventana donde el TTL no se refresca y duplica los viajes; gat arregla ambos. Para lecturas deslizantes multi-clave, gat acepta varias claves.
# 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 cComportamiento de expiración
La expiración en Memcached es perezosa por defecto — una clave solo se recoge al acceder, lo que significa que los datos rancios pueden ocupar memoria hasta desalojarse. El crawler LRU (1.4.24+) añade un barrido en segundo plano que libera proactivamente los ítems expirados por slab, previniendo el desperdicio de memoria. Actívalo en producción: lru_crawler enable. Aun así, nunca dependas de tiempos de expiración precisos para la corrección.
# 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)Buenas prácticas de TTL
Fija siempre un TTL — las entradas de caché sin límite causan crecimiento de memoria sin límite y bugs de datos rancios. Añade jitter aleatorio (±5-10%) a los TTLs para que las expiraciones correlacionadas no embistan contra el origen. Usa espacios de nombres por fecha para los datos volátiles para que las entradas viejas expiren solas. Ante un fallo, recalcula y guarda en el mismo camino de código para mantener la caché caliente. Usa delete, no TTL=1, para invalidación explícita.
# 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 deleteComandos de estadísticas
stats — visión general
stats vuelca las métricas principales del servidor: cmd_get/cmd_set (operaciones totales), get_hits/get_misses (tasa de aciertos = hits/cmd_get), evictions (ítems descartados por presión de memoria), curr_items, bytes vs limit_maxbytes y conteos de conexiones. La tasa de aciertos y las evictions son los dos números que mirar primero. Es la base de cualquier monitoreo de 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 pressurestats items — conteos de ítems por slab
stats items reporta, para cada clase de slab, cuántos ítems guarda (number) y la edad de su ítem menos recientemente guardado (age). Un slab con un número alto pero edad baja está siendo revuelto; un slab con edad alta guarda datos de larga vida. Es el primer lugar donde mirar al ajustar tamaños de chunk o diagnosticar por qué un rango de tamaños concreto se está desalojando.
# item counts and age per slab class
stats items
# STAT items:1:number 100
# STAT items:1:age 1200
# STAT items:2:number 250
# STAT items:2:age 3600
# STAT items:5:number 3
# STAT items:5:age 60
# ...
# END
# items:<slabid>:number -> how many items live in that slab class
# items:<slabid>:age -> age of the LRU item (seconds since stored)
# use this to see which size classes are full / hotstats slabs — estado del asignador de slabs
stats slabs revela el layout del asignador de slabs: cada clase tiene un chunk_size (las ranuras de ítems se redondean a él), chunks_per_page, total_pages y chunks usados/libres. La memoria asignada a una clase de slab se queda ahí — no puede devolverse a otras clases. Si una clase está llena y desalojando mientras otra está vacía, tienes calcificación de slabs, abordable con el ajuste de -f (factor de crecimiento).
# memory layout of each slab class
stats slabs
# STAT 1:chunk_size 96
# STAT 1:chunks_per_page 10922
# STAT 1:total_pages 1
# STAT 1:total_chunks 10922
# STAT 1:used_chunks 100
# STAT 1:free_chunks 10822
# STAT 2:chunk_size 120
# ...
# STAT active_slabs 5
# STAT total_malloced 16777216
# END
# chunk_size -> bytes per item slot in this class
# total_chunks -> total slots
# used_chunks -> slots holding data
# free_chunks -> empty slotsstats sizes — histograma de tamaños de ítem
stats sizes construye un histograma de los tamaños reales de ítem (clave+valor+sobrecarga) para ver cuánta memoria se desperdicia en el redondeo al tamaño de chunk. Hace un escaneo completo e históricamente bloqueaba el servidor — las versiones modernas lo acotan tras una comprobación de modo seguro; pasa --disable-safe-mode para forzarlo. Corre solo con poco tráfico. La salida ayuda a elegir el factor de crecimiento -f correcto.
# 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 — inspeccionar un slab
stats cachedump lista las claves guardadas en una clase de slab dada (limitado a N entradas), útil para depuración ad-hoc. Recorre el LRU del slab y puede ser lento o estar deshabilitado por completo en algunas compilaciones — nunca lo uses para enumeración de claves en producción. Memcached deliberadamente no ofrece una forma eficiente de listar todas las claves; trátalo como una caja negra indexada por tu aplicación.
# peek at keys in a specific slab class
# syntax: stats cachedump <slab_id> <limit> [noreply]
stats cachedump 1 10
# ITEM user:1 [5 b; 1700000000 s]
# ITEM user:2 [5 b; 1700000000 s]
# ...
# END
# WARNING: for debugging only — it walks the LRU and can be slow.
# Not all builds ship cachedump; it is disabled in some distros.
# Each ITEM shows: key, [value size in bytes; storage time s]
# do NOT use this for key enumeration in production code —
# memcached has no efficient SCAN commandstats reset y otros subcomandos
stats reset pone a cero los contadores acumulados (ops, hits, misses) sin borrar datos — práctico para medir un intervalo fresco tras un despliegue. Otros subcomandos útiles: stats settings (configuración efectiva), stats conns (detalle por conexión en compilaciones recientes), stats lru_crawler (estado del crawler). Los contadores, por lo demás, son acumulativos desde el inicio del proceso, así que resetea antes de hacer benchmarks.
# 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)Ajustes y configuración
stats settings — configuración efectiva
stats settings muestra la configuración en marcha: maxbytes (-m), maxconns (-c), growth_factor (-f), item_size_max (-I), si las evictions y el CAS están habilitados, y el estado del crawler LRU. La mayoría se fijan al arrancar; solo unos pocos pueden cambiarse en runtime. Es el primer lugar para confirmar si tu servidor recogió los flags que crees que puso.
# 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 arranque
La mayor parte de la configuración ocurre vía flags de arranque. Los críticos: -m (memoria), -l (enlaza siempre a 127.0.0.1 o una red privada — nunca expongas Memcached públicamente), -c (tope de conexiones), -I (tamaño máximo de ítem) y -f (factor de crecimiento de slabs). -M cambia el comportamiento de eviction a error-when-full en lugar de eviction LRU (rara vez deseado en una caché). Ajusta -t a tu conteo de CPUs para el rendimiento.
# 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 verbosityConfiguración en runtime
Memcached expone solo unas pocas perillas de runtime: cache_memlimit (redimensionar el tope de memoria en vivo), la familia lru_crawler (habilitar/deshabilitar/ajustar el recolector en segundo plano), verbosity (nivel de log) y flush_all (invalidar la caché entera, opcionalmente con retardo). La mayoría de ajustes quedan fijos al arrancar — para cambiar -m, -c o -I reinicias el proceso. flush_all es una operación de plano de control, no un ajuste.
# 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 secondsAjustes importantes explicados
-m es el ajuste principal: dimensiona a tu working set más margen, ya que quedarse corto causa evictions y agitación de caché. -f intercambia granularidad de clase de slab contra fragmentación interna — bájalo (hacia 1.1) cuando tengas muchos ítems de tamaño estrecho. -I acota el tamaño de ítem; súbelo solo si debes cachear blobs grandes. -M se usa rara vez en una caché — convierte el OOM en errores en lugar de evictions.
# -m memory budget
# the single most important knob. Size to fit your working set
# with headroom; undersizing = evictions = cache churn.
#
# -f slab growth factor (default 1.25)
# smaller (1.1) = more slab classes, less internal fragmentation
# but more per-class memory stuck. Larger (1.5) = fewer classes,
# more waste per chunk.
#
# -I max item size (default 1m)
# raise to cache bigger blobs (e.g. -I 4m) at the cost of larger
# worst-case allocations.
#
# -M disable LRU eviction (error instead) — only for strict caches
#
# -t worker threads (default 4) — scale to CPU count for throughputLímites de conexiones e hilos
-c acota las conexiones concurrentes — fíjalo cómodamente por encima de (pool_size × instancias_de_app) o se rechazarán clientes (vigila listen_disabled_num en stats). -t fija los hilos worker; Memcached es guiado por eventos por hilo, así que escala -t a los núcleos de CPU, típicamente 4-8. Más allá, la contención de locks limita las ganancias. Cada hilo posee una porción de la tabla hash, así que más hilos no ayudan a una única clave caliente.
# -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 connsEstrategias de caché
Cache-aside (carga perezosa)
Cache-aside es el patrón más simple y popular: la app lee primero la caché, y ante un fallo carga de la base de datos y rellena la caché hacia atrás. Es resiliente (una caída de caché solo significa más carga de la base de datos) pero permite embestidas en claves frías y obsolescencia hasta la invalidación explícita. Fja siempre un TTL incluso al invalidar en escritura, como red de seguridad para invalidaciones perdidas.
# the most common pattern — app manages the cache explicitly
def get_user(id):
key = "user:" + str(id)
val = mc.get(key) # 1) try cache
if val is not None:
return val # hit
val = db.query(id) # 2) miss -> load from DB
mc.set(key, val, ttl=3600) # 3) back-fill the cache
return val
# on write:
def update_user(id, data):
db.update(id, data)
mc.delete("user:" + str(id)) # invalidate (or set fresh value)
# pros: simple, resilient to cache failure
# cons: stampede on miss; stale until invalidatedRead-through
En read-through, la propia capa de caché invoca a un cargador ante un fallo — la app solo llama a get y recibe un valor. Esto centraliza la lógica de población de caché y garantiza consistencia entre quienes llaman, al coste de una lectura sincrónica de la base de datos dentro de la llamada de caché. La mayoría de clientes de Memcached no traen read-through integrado, así que suele implementarse como un envoltorio fino alrededor de cache-aside.
# the cache itself is responsible for loading from the DB
# (the client library or a cache layer provides a loader callback)
mc = memcached_with_loader(load_fn=db.query_user)
def get_user(id):
# the cache calls load_fn(id) automatically on a miss
return mc.get_or_load("user:" + str(id))
# pros:
# - app code is simpler (no miss-handling logic)
# - cache population is consistent across callers
# cons:
# - the cache library must support a loader (or you wrap it)
# - a cache miss is slower (synchronous DB read inside get)Write-through
Write-through actualiza la caché en cada escritura, manteniéndola fresca sin un camino de invalidación aparte. La contrapartida es la latencia de escritura (caché + base de datos) y un riesgo de ordenamiento de fallos: si escribes caché primero y la escritura a la base de datos falla, la caché guarda datos que no son duraderos; escribiendo base de datos primero hay una ventana de obsolescencia. La mayoría de apps combinan write-through para claves calientes con cache-aside para el resto.
# 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 escribe en la caché inmediatamente y persiste en la base de datos de forma asíncrona vía una cola — dando latencia de escritura submilisegundo y absorción de picos. El coste es la consistencia (la base de datos va por detrás de la caché) y la durabilidad (un fallo antes de que el worker drene pierde datos). Memcached solo no puede hacer esto; necesitas cola + worker. Resérvalo para cargas intensivas en escritura y tolerantes a pérdida como contadores y telemetría.
# 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)Invalidación de caché
La invalidación es la parte más difícil del caché. El delete-al-escribir explícito es la línea base; el TTL es la red de seguridad (fja siempre uno). Para colecciones que no puedes enumerar, usa claves versionadas (user:1:v42) y sube la versión ante cambios de esquema/datos para que las entradas viejas expiren por envejecimiento. Las claves por franja temporal (report:2024-01-01) expiran solas por fecha. Nunca intentes invalidación por comodín — Memcached no puede listar claves.
# 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 insteadEstrategias de TTL y eviction
Iguala el TTL a la volatilidad de los datos: horas para datos de referencia, minutos para datos de usuario, la longitud de la ventana para contadores de rate limit. Añade siempre jitter (±5-10%) para evitar embestidas de expiración sincronizada. Memcached desaloja LRU por slab bajo presión de memoria sin fijado por ítem — las únicas palancas son el TTL y el dimensionado total. Para claves calientes, usa un lock basado en add para que solo un cliente recalcule ante un fallo.
# 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 shortlyLibrerías cliente
Python (pymemcache)
pymemcache es Python puro, rápido y explícito. Usa el Client plano para un servidor y HashClient para un clúster con hashing consistente. set/get son lo básico; get_many agrupa un multi-get. Usa add+incr para contadores y gets/cas para actualizaciones optimistas. Pasa siempre timeouts explícitos — un nodo muerto debe fallar rápido, no colgar tu hilo de petición.
# 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)
El paquete npm memcached soporta configuraciones de servidor único y multi-servidor (hashing consistente), pooling de conexiones y reintentos. set/get/getMulti (multi-get agrupado) cubren el camino común. Configura poolSize según tu concurrencia y fija siempre un timeout para que un nodo muerto falle rápido. La librería es estilo callback; envuélvela en Promises o usa util.promisify para una ergonomía async/await.
// npm install memcached
const Memcached = require("memcached");
const mc = new Memcached("127.0.0.1:11211", {
timeout: 1000,
retries: 1,
poolSize: 10,
});
mc.set("user:1", "alice", 3600, (err) => {
if (err) console.error(err);
});
mc.get("user:1", (err, data) => {
console.log(data); // "alice"
});
// multi-get
mc.getMulti(["user:1", "user:2"], (err, data) => {
console.log(data["user:1"]);
});
// counter
mc.incr("views", 1, (err, val) => console.log(val));
// cluster: pass a comma-separated list, client does consistent hashing
const cluster = new Memcached("mc1:11211,mc2:11211,mc3:11211");
mc.end(); // close connections on shutdownPHP (extensión memcached)
La extensión memcached de PHP (construida sobre libmemcached) es la elección de producción — fija OPT_LIBKETAMA_COMPATIBLE para hashing consistente entre servidores, y addServers para un clúster. getMulti agrupa las lecturas. cas() toma el token del array resultante de fetch(). Evita la extensión antigua memcache (sin 'd'); carece de características y está menos mantenida. Fja siempre TTLs y maneja Memcached::RES_NOTFOUND limpiamente.
<?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 es el cliente Memcached canónico de Ruby — Ruby puro, thread-safe y el cache store por defecto de Rails. Pasa un array de servidores para el clustering de hashing consistente (ketama). Su forma de bloque cas relee y reintenta automáticamente ante conflicto, lo cual es mucho más ergonómico que los bucles manuales. Configura expires_in globalmente y sobrescríbelo por llamada para TTLs más ajustados.
# 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 es un cliente Java de alto rendimiento, asíncrono y basado en NIO. Su API está basada en Future; get() bloquea cuando necesitas confirmación. Pasa una lista de servidores separada por espacios a AddrUtil para hashing consistente. gets()/cas() aportan concurrencia optimista, y getBulk() hace un multi-get agrupado. Llama siempre a shutdown() al desmontar la app para liberar los hilos de IO.
// 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) es el cliente Go de facto — simple, rápido y soporta hashing consistente entre varios servidores. Set/Get toman una estructura Item que agrupa clave, valor, TTL y el token CAS; CompareAndSwap hace la actualización optimista. GetMulti devuelve un mapa indexado por nombre (las claves ausentes están ausentes, no son errores). Es seguro para concurrencia; reutiliza un cliente entre goroutines.
// 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")Arquitectura distribuida
Hashing consistente
El hashing consistente mapea tanto servidores como claves a un anillo; una clave es propiedad del siguiente servidor en sentido horario. Añadir o quitar un servidor mueve solo la porción de claves de ese servidor (cerca de 1/N), no la totalidad del espacio de claves — mucho mejor que hash(key) % N que reasigna la práctica totalidad ante un cambio de miembros. La mayoría de clientes usan la variante ketama con muchos nodos virtuales por servidor para una distribución equilibrada.
# 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 serversFragmentación del lado del cliente
Toda la fragmentación vive en el cliente: hashea cada clave a un servidor y reparte los multi-gets entre servidores en paralelo. Cada clave existe en exactamente un nodo — no hay replicación, así que un nodo muerto pierde su porción del espacio de claves. No hay proxy ni coordinador; cada cliente debe compartir la misma lista de servidores y configuración de hashing (ketama) o las claves aterrizarán en nodos distintos y causarán fallos masivos.
# 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-replicateAlgoritmos de hashing (Ketama)
Ketama es el esquema canónico de hashing consistente de memcached: cada servidor físico se mapea al anillo como muchos nodos virtuales (~160) para una carga equilibrada. Localizar una clave la hashea y camina en sentido horario hasta el siguiente nodo. La trampa crítica: cada cliente en cada lenguaje debe usar el mismo algoritmo y cadenas de etiqueta de servidor idénticas, o no estarán de acuerdo en la propiedad y causarán fallos masivos de caché tras un despliegue.
# 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)Añadir y quitar servidores
Con hashing consistente, añadir o quitar un servidor reasigna solo ~1/N de las claves — mucho mejor que el hashing por módulo que reasigna la práctica totalidad. Pero un fallo de servidor aún pierde permanentemente sus claves (sin replicación), causando un pico transitorio de carga en el origen mientras esas entradas se repueblan. Despliega los cambios de miembros a cada cliente a la vez, y considera precalentar un nodo nuevo sombreando lecturas antes de que entre en producción.
# 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)Replicación y failover
Memcached no tiene replicación ni failover integrados — un nodo muerto pierde sus datos y los clientes reenrutan. Para añadir redundancia o replicas en el cliente (escribir en N nodos, más coste), o ejecutas un proxy como mcrouter/twemproxy, o aceptas la pérdida y reconstruyes desde el origen. La elección idiomática es la última: trata la caché como desechable, dimensiona el pool para que la pérdida de un nodo sea tolerable, y deja que los fallos se rellenen desde la base de datos.
# 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 survivableGestión de memoria (slabs / LRU)
Asignador de slabs
Memcached usa un asignador de slabs: la memoria se divide en clases de chunks de tamaño fijo, y un ítem se guarda en el chunk más pequeño que encaje (redondeado hacia arriba). Esto evita la fragmentación de malloc/free y da asignación O(1), al coste de fragmentación interna (espacio desperdiciado dentro de los chunks) y calcificación de clases (la memoria no puede moverse entre clases). Es por esto que una mezcla uniforme de tamaños de valor importa para la eficiencia.
# 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 slabsClases de slab y factor de crecimiento
Los tamaños de clase de slab empiezan en el mínimo -n (48 bytes por defecto) y crecen por el factor -f (1.25 por defecto) hasta el tamaño máximo de ítem -I. Un -f menor produce más clases más finas (menos desperdicio, más riesgo de calcificación de clases); un -f mayor produce menos clases más gruesas (más desperdicio). Inspecciona tu histograma real de tamaños de valor con stats sizes y ajusta -f para que los tamaños populares caigan en clases bien llenas.
# 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 80Eviction LRU
La eviction es por clase de slab y estrictamente LRU dentro de esa clase: cuando una clase se llena, el ítem menos recientemente usado de esa clase se descarta para hacer sitio. Una clase con chunks libres nunca desaloja, así que una distribución de tamaños desequilibrada puede causar mucha eviction en una clase mientras otra está inactiva — el clásico problema de calcificación de slabs. Vigila evictions y evicted_active en stats para detectarlo.
# 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 0Límites de memoria (-m)
-m acota la memoria de ítems en MB; al alcanzarse, Memcached deja de añadir páginas de slab y desaloja LRU dentro de las clases. -M cambia la política a error-when-full en lugar de desalojar (rara vez deseable en una caché). cache_memlimit redimensiona el tope en vivo. Dimensiona -m a tu working set con margen — correr al 100% significa evictions constantes y una caché revuelta y de baja tasa de aciertos.
# -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 limitPolíticas de eviction y ajuste
La única política de eviction de Memcached es LRU por slab — no hay opción LFU ni aleatoria. Para reducir evictions: sube -m, acorta los TTLs, reequilibra los tamaños de valor o ajusta -f. Las compilaciones modernas añaden un crawler LRU y la capacidad de reasignar páginas de slab (slabs reassign / slabs automove) para mitigar la calcificación. Detecta una clase caliente con los contadores evicted/outofmemory de stats items.
# 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 y reassign
slabs reassign (manual) y slabs automove (1.5+, automático) te permiten reequilibrar páginas de slab de una clase con chunks libres a otra bajo presión de eviction — la cura de la calcificación de slabs. automove=1 es un movedor en segundo plano cauteloso y lento, seguro para producción; =2 es agresivo y experimental. Verifica siempre con stats slabs antes y después — una reasignación equivocada puede dejar a una clase sin recursos.
# 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 giveOptimización de rendimiento
noreply y pipelining
noreply recorta la respuesta por escritura, y el pipelining agrupa muchos comandos en un solo viaje de red — juntos son la mayor palanca de rendimiento para escrituras masivas. Multi-get hace lo mismo para lecturas. El coste de noreply es perder la retroalimentación de error por comando, así que resérvalo para escrituras no críticas y de alto volumen, y mantén las respuestas activas en cualquier cosa donde un fallo deba hacerse visible.
# 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:4Protocolo binario
El protocolo binario es más eficiente que el ASCII — una cabecera fija de 24 bytes en lugar de parseo de texto, operaciones quiet nativas (estilo noreply) para el pipelining, y soporte de SASL para autenticación. Para valores pequeños y escrituras masivas de alto rendimiento es medible más rápido. El servidor habla ambos protocolos en el mismo puerto, así que habilitarlo es puramente una elección del cliente. Prefiérelo en clientes de producción.
# 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 requiredPooling de conexiones
El pooling de conexiones es esencial — abrir una conexión TCP por petición quema puertos efímeros y añade latencia. Mantén un pool pequeño de conexiones persistentes por servidor por proceso, dimensionado a tu concurrencia. Vigila total_connections vs curr_connections en stats: si total crece con el tráfico mientras curr se mantiene plano, estás haciendo pooling; si total explota, no. La mayoría de clientes hacen pooling internamente al configurarlo.
# 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 countOperaciones masivas (multi-get)
Un multi-get obtiene N claves en un solo viaje de ida y vuelta — la mayor optimización de lectura disponible. Los clientes reparten las claves entre servidores en paralelo, así que la latencia queda acotada por el servidor más lento en lugar del número de claves. Fragmenta los multi-gets muy grandes (por ejemplo, 100 claves) para que ningún hilo del servidor se monopolice, y recuerda que las claves ausentes están silenciosamente ausentes del mapa de resultados.
# 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 resultDimensionar bien los valores
Como los ítems se redondean al siguiente tamaño de chunk, el tamaño del valor impulsa directamente la fragmentación interna — un valor de 60 bytes en un chunk de 96 desperdicia el 37%. Dimensiona bien los valores: recorta el espacio en blanco del JSON, comprime cada valor que supere ~1KB (y usa un bit de flags para marcarlo), y cachea proyecciones en lugar de blobs enteros. Inspecciona tu histograma de tamaños con stats sizes y ajusta -f para que los tamaños comunes caigan cerca de los límites de chunk.
# 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)Evitar claves calientes
Una clave caliente es un cuello de botella de servidor único y de un solo hilo — sus lecturas se serializan en un nodo mientras otros están inactivos. Fragmenta en N cubetas (lee una cubeta aleatoria, escribe en todas al actualizar), añade un TTL de 1 segundo del lado del cliente para fusionar recargas, o muévelo a un LRU en proceso. Detecta claves calientes por desequilibrio de CPU por servidor o, en 1.6+, lru_crawler metadump para asomarte a la frecuencia de acceso.
# 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+)Monitoreo
Estadísticas principales a vigilar
Las cuatro métricas destacadas son la tasa de aciertos (get_hits/cmd_get, objetivo >95%), las evictions (presión de memoria, objetivo 0 en estado estacionario), la utilización de memoria (bytes/limit_maxbytes, objetivo <90%) y listen_disabled_num (tope de conexiones alcanzado, objetivo 0). Síguelas como tasas a lo largo del tiempo, no solo contadores. Una tasa de aciertos cayendo o evictions creciendo son los primeros signos de una caché insana.
# the four numbers to monitor continuously:
stats
# STAT cmd_get, cmd_set # throughput (ops/sec deltas)
# STAT get_hits, get_misses # hit rate = hits / cmd_get
# STAT evictions # memory pressure (rising = bad)
# STAT bytes / limit_maxbytes # memory utilization %
# derived metrics:
# hit_rate = get_hits / cmd_get # target > 95%
# eviction_r = evictions_delta / cmd_set_delta
# mem_usage = bytes / limit_maxbytes # target < 90%
# connection health:
# STAT curr_connections # active conns
# STAT listen_disabled_num # >0 = hit -c limit (refused conns)
# alert thresholds (suggestions):
# hit_rate < 90% -> investigate cold keys / undersizing
# evictions > 0 (steady)-> add memory or shorten TTLs
# listen_disabled_num > 0 -> raise -cmemcached-tool
memcached-tool es la CLI incluida para una comprobación ad-hoc rápida: stats para una tabla por slab, display para una vista que se refresca en vivo, dump para asomarte a las claves (solo depuración — recorre el LRU). Es perfecto para un one-off por SSH pero no para monitoreo continuo; emparéjalo con un exporter de Prometheus y Grafana para dashboards y alertas de producción.
# 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.Monitoreo por Telnet
Telnet o netcat al puerto 11211 da acceso interactivo instantáneo al protocolo de texto para comprobaciones ad-hoc: stats, stats settings, stats items, stats slabs, version. Usa one-liners de nc para scripts (echo 'stats' | nc -q 1 host 11211). Recuerda que flush_all es destructivo — nunca lo alias casualmente. Es la forma de menor fricción de inspeccionar un nodo.
# 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.txtExporter de Prometheus y Grafana
memcached_exporter es la integración estándar de Prometheus — corre uno junto a cada nodo y scrapea :9150. Los dashboards de Grafana entonces siguen la tasa de aciertos, la tasa de eviction, el uso de memoria y el llenado por slab. Alerta ante caídas de tasa de aciertos por debajo del 90%, cualquier eviction en estado estacionario, memoria por encima del 90% y listen_disabled_num > 0. Esto te da una visibilidad continua e histórica que el telnet ad-hoc no puede.
# 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étricas clave y alertas
Alerta ante degradación de la tasa de aciertos (aviso <90%, crítico <75%), cualquier eviction en estado estacionario, memoria por encima del 90% y cualquier conexión rechazada. Correlaciona siempre las métricas de caché con las del origen — una caída de tasa de aciertos emparejada con un pico de CPU de la base de datos es la firma de una tormenta de fallos de caché, y evictions crecientes emparejadas con latencia de origen creciente apuntan a una caché de tamaño insuficiente. Sigue los reinicios de uptime para detectar reinicios silenciosos.
# 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 -> undersizedSeguridad
Aislamiento de red
El protocolo de texto de Memcached no tiene autenticación, así que nunca debe exponerse públicamente — enlaza a 127.0.0.1 o a una NIC privada con -l, desactiva el UDP con -U 0 si no se usa, y acota con firewall el 11211 a las subredes de la app. Un Memcached alcanzable públicamente es tanto una caché de datos abierta como un vector de DDoS por amplificación UDP (CVE-2018-1000115). La dirección de escucha por defecto son todas las interfaces — anúlala siempre.
# 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.Autenticación SASL (protocolo binario)
La autenticación SASL está disponible solo en el protocolo binario (arranca el servidor con -S). Usa credenciales PLAIN durante la fase de configuración de la conexión, añadiendo un viaje de ida y vuelta que el pooling amortiza. Usa SASL en redes compartidas o multi-inquilino donde el aislamiento de red por sí solo es insuficiente. El protocolo de texto no puede autenticarse — si necesitas autenticación, debes usar el protocolo binario de extremo a extremo.
# 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.Cifrado y TLS
Memcached no tiene TLS nativo — para cifrar el tráfico, termina el TLS en un sidecar como stunnel o HAProxy delante de cada nodo, y corre memcached plano detrás en loopback. Para la mayoría de despliegues en LAN, el aislamiento de red más SASL opcional es suficiente; reserva TLS para flujos entre redes o entornos con requisitos de cumplimiento. Forks recientes (y algunos servicios gestionados en la nube) añaden TLS nativo.
# memcached itself does NOT support TLS/SSL natively.
# to encrypt traffic, terminate TLS in front of the server:
#
# app --TLS--> stunnel/haproxy --plain--> memcached
#
# stunnel example (server side):
# [memcached]
# accept = 11443
# connect = 127.0.0.1:11211
# cert = /etc/stunnel/mc.pem
#
# the client also needs a stunnel/haproxy side, OR a client that
# speaks TLS (some newer forks/patches add native TLS).
#
# for most LAN deployments, network isolation + SASL is enough;
# reserve TLS for cross-network or compliance-required flows.Firewall y control de acceso
Apila tus defensas: enlaza a una NIC privada, firewall a las subredes de la app, desactiva el UDP, añade SASL en redes compartidas, corre como usuario no root y aplica endurecimiento de systemd (NoNewPrivileges, ProtectSystem, PrivateTmp). Críticamente, nunca guardes secretos crudos en Memcached — es una caché, no una bóveda; cifra-luego-cachea o guarda los secretos en un gestor de secretos dedicado y cachea solo referencias no sensibles.
# 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=trueBuenas prácticas de seguridad
Las reglas cardinales: nunca expongas Memcached públicamente, enlaza siempre a una interfaz privada, desactiva el UDP y usa SASL en redes compartidas. No guardes secretos ni PII sin cifrar; usa espacios de nombres de claves por inquilino para evitar filtraciones entre usuarios. Mantén el servidor parcheado, audita las conexiones con stats conns, y trata una brecha de caché como una brecha de datos — rota cualquier token que pudiera haberse cacheado.
# 1) NEVER expose memcached to the internet (no auth in text proto)
# 2) ALWAYS set -l to loopback or a private address
# 3) disable UDP (-U 0) unless you specifically need it
# 4) use SASL on the binary protocol for multi-tenant networks
# 5) don't store secrets/PII in the cache unencrypted
# 6) namespace keys per-tenant to avoid cross-tenant leakage
# (e.g. "tnt:42:user:1" — never shared global keys)
# 7) keep memcached updated (security CVEs do happen)
# 8) audit with stats conns to see who's connected
# 9) log and alert on unexpected connection sources
# 10) treat a cache breach as a data breach: rotate any tokens that
# might have been cachedMemcached vs Redis
Tipos de datos y características
Memcached es una caché de clave-valor pura de cadenas; Redis es un servidor de estructuras de datos con listas, hashes, sets, sorted sets, streams, scripting Lua, transacciones, pub/sub y módulos. La riqueza de Redis es una fortaleza cuando la necesitas, pero el minimalismo de Memcached es una característica para el caché puro — menos superficie, menos que malconfigurar. Elige según si necesitas estructuras de datos del lado del servidor.
# 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.Persistencia
Memcached tiene cero persistencia — un reinicio lo vacía por diseño, y la caché siempre es desechable. Redis ofrece snapshots RDB y durabilidad AOF más replicación, así que puede servir como almacén de datos primario. Si necesitas que la caché sobreviva a reinicios o guardar datos autoritativos, gana Redis; si quieres una caché volátil pura que se reconstruye ante fallos, la simplicidad de Memcached es una virtud.
# 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.Replicación y clustering
Memcached no tiene clustering ni replicación del lado del servidor — la distribución es enteramente del lado del cliente, y un nodo muerto pierde permanentemente sus claves. Redis ofrece replicación maestro/réplica, Sentinel para HA y Redis Cluster para fragmentación con failover automático. Memcached es más simple de operar (sin gossip, sin lógica de failover) pero no ofrece HA; Redis intercambia complejidad operativa por resiliencia verdadera.
# 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.Características de rendimiento
Ambos están en memoria y por debajo del milisegundo. Memcached es multihilo por defecto y escala entre núcleos para get/set puro, mientras que Redis es (mayormente) monohilo para la ejecución de comandos — así que en una máquina multinúcleo grande haciendo solo get/set, Memcached puede alcanzar un QPS mayor. Para la mayoría de apps reales la diferencia es despreciable; elige según características y encaje operativo, no microbenchmarks.
# Both are in-memory and very fast (sub-millisecond, >100k ops/s).
#
# Memcached:
# - multi-threaded by default (-t workers); scales across cores
# - simple protocol, low overhead per op
# - excellent for high-throughput pure get/set
#
# Redis:
# - single-threaded command execution (Redis 6+ threads the I/O)
# - one core does the work; more cores don't speed a single command
# - richer ops can be slower, but core get/set is comparable
#
# verdict: for pure get/set at very high QPS on a big multi-core box,
# memcached's multi-threading can win. For most apps the difference
# is negligible; pick by features, not microbenchmarks.Eficiencia de memoria
El asignador de slabs de Memcached es magro para blobs opacos pero desperdicia espacio en el redondeo de chunks; Redis tiene sobrecarga por clave/campo pero elige codificaciones compactas (listpack) para estructuras pequeñas. Ninguno es universalmente más pequeño — Memcached gana en blobs uniformes, Redis puede ganar en datos estructurados pequeños. Mide siempre con tus propias formas de valor antes de asumir que uno es más barato.
# 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.Cuándo elegir cuál
Elige Memcached para una caché de get/set pura y desechable donde la simplicidad operativa y el escalado multihilo importan. Elige Redis cuando necesites estructuras de datos, persistencia, replicación, clustering, Lua, pub/sub o módulos. No son mutuamente excluyentes — muchos stacks corren ambos, usando Memcached para el caché crudo de páginas/consultas y Redis para sesiones, tablas de clasificación, rate limiting y streams.
# Choose Memcached when:
# - you need a pure, disposable get/set cache
# - you value operational simplicity (no clustering, no persistence)
# - you want multi-threaded scaling on a big box
# - your data is opaque blobs and you rebuild on miss
#
# Choose Redis when:
# - you need data structures (lists, hashes, sets, zsets, streams)
# - you need persistence or durability
# - you need replication / failover / clustering
# - you need server-side logic (Lua, pub/sub, modules)
# - you need per-key TTL on rich types
#
# both can coexist: memcached for raw page/query cache, Redis for
# sessions, leaderboards, rate-limiting, streams.Solución de problemas
Conexión rechazada
La conexión rechazada normalmente significa que el servidor no está corriendo, no escucha en la dirección esperada (un -l enlazado a loopback bloquea a los clientes remotos), está detrás de un firewall o ha alcanzado el tope de conexiones -c (listen_disabled_num > 0). Recorre la lista: ps/systemctl para el proceso, ss/netstat para el listener, iptables para el firewall, stats para el tope de conexiones y journalctl para los logs de fallos.
# 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 100Tormentas de eviction
Evictions crecientes con caché llena significan que tu working set excede -m. Diagnostica con stats (bytes == limit_maxbytes) y stats items (qué clase de slab está desalojando). Arreglos: sube -m, acorta los TTLs para que los ítems expiren solos, reequilibra páginas de slab con slabs reassign/automove y caza a un escritor desbocado que infla valores. Una caché persistentemente llena necesita más memoria o un working set menor.
# 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 muchBaja tasa de aciertos
Una tasa de aciertos baja (<90%) con alta carga de base de datos normalmente significa TTLs demasiado cortos, el working set excede la memoria (evictions), las claves no se reutilizan (componentes volátiles como marcas de tiempo en la clave), es un arranque frío, o los clientes no concuerdan en la configuración ketama así que las claves aterrizan en servidores distintos. Verifica que cada cliente comparta listas de servidores y hashing idénticos, y revisa los logs de tu app en busca de patrones de reutilización de claves.
# 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 logsCalcificación de slabs
La calcificación de slabs es cuando la memoria está atascada en clases que no la necesitan mientras otra clase revuelve en evictions — las páginas no pueden migrar por sí solas. Diagnostica con stats slabs (free_chunks vs total_pages) y stats items (evicted por clase). Arregla con slabs reassign (puntual) o slabs automove 1 (en segundo plano), y previene la recurrencia ajustando -f para que coincida con tu distribución de tamaños de valor.
# 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 slabsAlto uso de memoria
El uso de memoria inesperado suele ser fragmentación interna (valores que no encajan en chunks), valores inflados (JSON sin comprimir) o simplemente el número de claves (sobrecarga por ítem). Diagnostica con stats (bytes vs limit_maxbytes) y stats slabs (chunks usados vs totales). Arreglos: comprime los valores grandes, recorta espacios y nombres de clave, ajusta -f para reducir el desperdicio y verifica que -m coincide con el working set que realmente necesitas.
# 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 -mRespuestas lentas y timeouts
Las respuestas lentas suelen venir de una clave caliente serializándose en un hilo, un multi-get sobredimensionado bloqueando al servidor, valores enormes saturando la red, latencia de red de app a caché, saturación de CPU por demasiados pocos hilos -t o — críticamente — Memcached haciendo swap a disco (nunca dejes que haga swap; fija -m por debajo de la RAM física). Fja timeouts de cliente agresivos (50-100ms) para que una caché lenta degrade al origen en lugar de estancar peticiones.
# 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 stallingConfiguración de despliegue
Correr como daemon
Corre Memcached como daemon con -d, soltando siempre privilegios con -u a un usuario no root. Los flags esenciales de producción son -m (memoria), -l (dirección de enlace — nunca lo dejes en todas las interfaces), -c (tope de conexiones), -t (hilos) y -f (factor de crecimiento de slabs). Escribe un pidfile con -P para una gestión fácil, y verifica el proceso con una comprobación rápida de versión por netcat.
# 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.24Servicio systemd
Una unit de systemd te da autorreinicio (Restart=on-failure), caída de privilegios (User=memcache), límites de descriptores de archivo (LimitNOFILE para muchas conexiones) y endurecimiento de seguridad (NoNewPrivileges, ProtectSystem, PrivateTmp). La mayoría de distros traen una unit por defecto que puedes anular vía /etc/systemd/system/memcached.service.d/override.conf en lugar de reescribir el archivo completo — prefiere eso por portabilidad.
# /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 memcachedDespliegue con Docker
En Docker, recuerda que hay dos límites de memoria: el -m de memcached (memoria de ítems) y el tope de memoria del contenedor (docker -m). Fja siempre el tope del contenedor por encima del -m de memcached para dejar sitio al runtime y las conexiones, o el OOM killer golpeará. Fja un tag de versión concreto (memcached:1.6) en lugar de :latest por reproducibilidad, y restart=unless-stopped por resiliencia.
# 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-stoppedMúltiples instancias
Correr varias instancias de Memcached por host te permite aislar clases de slab calientes, reducir el impacto de reinicio por proceso y usar más núcleos — el cliente simplemente las ve como miembros adicionales del anillo. El coste es más conexiones y sobrecarga de páginas de slab por proceso. Para la mayoría de cargas, un único proceso multihilo (-t a tu conteo de núcleos) es más simple y suficiente; divide solo cuando golpees un cuello de botella concreto.
# 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)Dimensionado de memoria
Dimensiona -m a tu working set medido más margen, apuntando al 70-80% de utilización en pico para tener sitio para picos y no revolver en evictions. Nunca dejes que Memcached haga swap — mantén -m por debajo de la RAM disponible tras contar el sistema operativo y otros procesos. Si la utilización estacionaria supera el 90%, o subes -m o reduces el working set (TTLs más cortos, menos cosas cacheadas).
# how big should -m be?
#
# 1) measure your working set: the keys actually hot in a typical hour
# 2) add headroom: target ~70-80% memory utilization at peak
# 3) leave RAM for the OS, connections, and slab overhead
#
# rule of thumb:
# -m = working_set_bytes / 0.75
#
# example: 3 GB working set -> -m 4096 (4 GB) for 75% utilization
#
# never let memcached swap:
# -m must be BELOW available RAM (check free -m)
# account for other processes on the same host
#
# monitor utilization:
stats
# STAT bytes 3221225472 # 3 GB used
# STAT limit_maxbytes 4294967296 # 4 GB cap -> 75% utilization
# if utilization > 90% steady: raise -m or shrink the working setLogging y verbosidad
Memcached es silencioso por diseño; sube la verbosidad con -v/-vv/-vvv o el comando verbosity de runtime solo para depurar, ya que registrar en log cada comando aplasta el rendimiento. En producción, corre silencioso y confía en stats y un exporter de Prometheus para visibilidad. Los logs van a journald bajo systemd o docker logs en contenedores. Usa -vv brevemente para trazar un problema concreto y luego bájalo de nuevo.
# 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.Temas avanzados
Protocolo binario en profundidad
La cabecera fija de 24 bytes del protocolo binario habilita un parseo eficiente, autenticación SASL y opcodes quiet (que suprimen respuestas) que hacen las operaciones masivas en pipeline mucho más eficientes que el protocolo de texto. Un Noop al final de un pipeline quiet lo vacía y hace visibles los errores. La mayoría de clientes de producción usan por defecto o prefieren el protocolo binario por su menor sobrecarga por operación y su conjunto de características más rico.
# 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.Soporte UDP
Memcached soporta UDP para búsquedas de alto rendimiento, sin conexión y fire-and-forget — útil en configuraciones especializadas donde el coste del handshake TCP domina. Es con pérdida y de tamaño limitado, así que úsalo solo para lecturas de caché idempotentes. Críticamente, el UDP es un vector conocido de DDoS por amplificación (CVE-2018-1000115); desactívalo con -U 0 en producción salvo que tengas una necesidad concreta y acotada por firewall.
# 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 productionObjetos grandes y fragmentación
Aunque puedes subir el límite de ítem de 1MB con -I, los ítems grandes perjudican el rendimiento y el equilibrio de slabs. Un patrón mejor es la fragmentación a nivel de aplicación: divide el valor en piezas de ~512KB bajo claves numeradas, guarda una clave de conteo y reensambla al leer. Esto mantiene los ítems amigables con los slabs, evita monopolizar hilos del servidor y hace que un fallo parcial sea recuperable en lugar de perder el blob entero.
# 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.Espacios de nombres y versionado
Memcached no tiene espacios de nombres reales — simúlalos con prefijos de clave, y usa un prefijo versionado para invalidar un espacio de nombres lógico entero de una vez (sube una clave nsver para que las claves viejas queden inalcanzables y expiren por TTL). Incluir un prefijo de versión de app da a cada despliegue una caché fresca. Es la forma canónica de invalidación masiva, ya que Memcached no puede enumerar ni eliminar claves por patrón.
# 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.Prevención de embestidas de caché
Una embestida ocurre cuando muchas peticiones fallan sobre la misma clave que expira y todas la recalculan, machacando al origen. El arreglo canónico es un lock basado en add para que solo un cliente reconstruya mientras los demás esperan brevemente y reintentan. Combínalo con jitter de TTL para prevenir expiraciones sincronizadas, y refresco proactivo (refrescar antes de expirar, servir rancio mientras un cliente reconstruye) para claves calientes donde incluso un único fallo es costoso.
# 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)Fragmentos de Memcached relacionados
Copy-paste ready code for common tasks.
set / get — Clave-Valor Básico
Almacenar y recuperar valores por clave, con TTL y flags.
add / replace / append / prepend
Escrituras condicionales y concatenación in-place de strings.
cas / gets — Compare-And-Swap
Bloqueo optimista: actualizar una clave solo si no ha cambiado desde su lectura.
stats — Métricas del Servidor y Slab
Inspeccionar memoria, hit rate, evicciones y asignación por slab.
flush_all — Invalidar Todo
Invalidar lógicamente todas las claves inmediatamente (lazy delete).
Expiración, Evicción y Estrategias TTL
Elegir TTLs sabiamente y entender cómo Memcached evicta bajo presión.
Protocolo Texto/Binario y Hashing Consistente
Elegir el protocolo correcto y sharding entre servidores sin rearreglo.
Patrones: Read-Through, Write-Behind y Caché de Sesión
Aplicar Memcached a problemas comunes de cache de aplicaciones.
Was this helpful?