En esta página
Redis se cae por memoria por razones que la métrica used_memory no muestra: el fork del RDB puede casi duplicar la memoria residente bajo carga de escritura, la fragmentación del asignador infla el RSS por encima de los datos, y maxmemory solo gobierna el keyspace, no los buffers de replicación, los buffers de clientes ni el fork. Dimensione para el pico más el overhead, no para el dataset.
El patrón es tan constante que funciona como una firma. Una instancia está en lo que parece una utilización cómoda, no salta ninguna alerta y, de pronto, se cae. Nadie puede reproducirlo, porque la métrica de memoria de Redis que todos vigilan nunca midió lo que la tumbó.
¿Qué limita realmente maxmemory?
Menos de lo que la mayoría de los equipos supone. La documentación de Redis lo dice claramente: para almacenar las claves de usuario, “Redis asigna como máximo la memoria que permite la configuración de maxmemory (aunque es posible que haya pequeñas asignaciones extra)”.
Esa frase dice mucho más de lo que parece. maxmemory acota el keyspace, que es solo una parte de la memoria total de Redis. No acota:
- El fork. Un guardado en segundo plano duplica las páginas a medida que se modifican. Nada de
maxmemoryrestringe eso. - Los buffers de salida de los clientes. Un consumidor lento, una sesión de
MONITORo un fan-out grande de pub/sub acumulan datos del lado del servidor a la espera de enviarse. - El backlog de replicación. Se mantiene en el primario para que las réplicas puedan hacer una resincronización parcial, y se dimensiona por separado.
- El overhead del asignador. Páginas que el asignador retiene, pero que Redis no está usando en ese momento.
Consulte sus límites reales en lugar de confiar en los valores predeterminados que recuerda, que varían según la versión y según cómo se aprovisionó la instancia:
CONFIG GET maxmemory
CONFIG GET maxmemory-policy
CONFIG GET client-output-buffer-limit
CONFIG GET repl-backlog-sizeLa consecuencia práctica: una instancia con maxmemory igual a toda la RAM del host no está protegida. Está configurada para fallar.
¿Cómo interactúan maxmemory y la expulsión?
Son dos parámetros, y uno de ellos desactiva al otro en silencio.
maxmemory fija el techo. maxmemory-policy decide qué pasa al llegar a él. Si la política es noeviction, Redis rechaza las escrituras con OOM command not allowed when used memory > 'maxmemory' y sigue respondiendo a las lecturas: un fallo deliberadamente ruidoso, correcto para un almacén de datos e incorrecto para una caché.
La trampa es la familia volatile-*. Esas políticas solo consideran las claves que tienen un TTL. Configure volatile-lru en un keyspace donde nada expira y Redis no tendrá ninguna candidata para expulsar: se comportará exactamente igual que noeviction, aunque su configuración diga otra cosa. Repasamos las ocho opciones en Política de expulsión en Redis.
Hay una asimetría que conviene conocer antes de dimensionar un conjunto de réplicas: por defecto, las réplicas ignoran maxmemory. La expulsión lo dirige el primario, que propaga DEL a medida que expulsa. La propia documentación de Redis advierte que una réplica “puede terminar usando más memoria de la configurada mediante maxmemory” y recomienda asegurarse de que las réplicas “tengan suficiente memoria para no llegar nunca a una condición real de memoria insuficiente antes de que el maestro alcance la configuración de maxmemory”. Una réplica dimensionada exactamente igual que su primario queda subdimensionada.
¿Por qué used_memory_rss es mucho mayor que used_memory?
Por la fragmentación. El ratio de memoria de Redis que interesa aquí es una cuenta sencilla:
INFO memory
# used_memory — bytes Redis has allocated for data
# used_memory_rss — resident set size: pages the OS has actually given the process
# mem_fragmentation_ratio — used_memory_rss / used_memoryUn ratio cercano a 1,0 es saludable. Muy por encima de 1 significa que el asignador retiene páginas que no contienen datos. Esto ocurre porque, como dice la documentación de Redis, “Redis no siempre libera (devuelve) memoria al sistema operativo cuando se eliminan claves. Esto no es algo propio de Redis, sino la forma en que funcionan la mayoría de las implementaciones de malloc()”. Elimine 2GB de una instancia de 5GB y lo más probable es que el RSS siga marcando cerca de 5GB.
De esto se desprenden dos cosas, y la segunda es la que se suele pasar por alto:
- Aprovisione para el pico. La documentación es explícita: “necesita aprovisionar la memoria según su uso pico de memoria. Si su carga de trabajo requiere de vez en cuando 10GB, aunque la mayor parte del tiempo baste con 5GB, necesita aprovisionar 10GB”.
- Después de un pico, el ratio miente. Redis lo dice directamente: “el ratio de fragmentación no es fiable cuando ha habido un uso de memoria que en el pico fue mucho mayor que la memoria usada actualmente”, porque el RSS refleja el pico mientras que
used_memoryrefleja el momento actual. Un ratio de 3,0 en una instancia que acaba de deshacerse de la mayor parte de su keyspace es un comportamiento esperado, no un fallo. Perseguirlo con desfragmentación es un esfuerzo inútil.
Cuando la fragmentación es realmente persistente bajo una carga estable, existe la desfragmentación activa:
CONFIG GET activedefrag
MEMORY PURGEActívela a conciencia y vigile el evento active-defrag-cycle en LATENCY LATEST: la desfragmentación consume CPU en el único hilo de comandos, así que cambia memoria por latencia.
¿Por qué se cae Redis durante una copia de seguridad?
Este es el fallo que produce el clásico “se cayó y las métricas no muestran nada”.
Redis genera los snapshots haciendo un fork. El proceso hijo escribe el RDB mientras el padre sigue dando servicio, y ambos comparten memoria mediante copy-on-write. Cada página que el padre modifica durante el guardado se duplica. Con una carga de escritura sostenida, la memoria total del proceso se acerca al doble del dataset, y nada de eso aparece en used_memory, porque no es keyspace. Esta es, con diferencia, la mayor brecha entre el consumo de memoria que muestra Redis y el real.
INFO persistence
# rdb_bgsave_in_progress — is a save running right now
# latest_fork_usec — how long the last fork() blocked the server
# rdb_last_bgsave_status — ok, or the save is failingInvestigamos caídas repetidas en el clúster de Redis de un cliente cuya utilización registrada nunca superó aproximadamente el 60 %. Nada en las métricas de Redis lo explicaba, y no se había cruzado ningún umbral de alerta. La causa era el comportamiento del fork durante las copias de seguridad, y la solución fue ajustar el memory overcommit del kernel, no un parámetro de Redis. El mismo mecanismo está detrás de varios de los fallos de disponibilidad que describimos en Alta disponibilidad en Redis.
El fork también tiene un coste de latencia, independiente de la memoria. La documentación de persistencia de Redis señala que fork() “puede tardar bastante si el dataset es grande, y puede hacer que Redis deje de atender a los clientes durante algunos milisegundos, o incluso durante un segundo si el dataset es muy grande y el rendimiento de la CPU no es bueno”. latest_fork_usec le da esa cifra para el último guardado.
Caso real: caídas al 61 % por reindexación constante
Merece la pena describir este caso en detalle, porque es la versión del problema que ningún ajuste de Redis habría resuelto.
En un proyecto de AceMQ, un cliente sufría caídas repetidas alrededor de un umbral de memoria del 61 %. La misma firma que antes: mucho margen sobre el papel y la instancia caída en la práctica. Pero el fork era solo una parte. Esto es lo que encontramos en la carga de trabajo:
- Cada heartbeat de un dispositivo disparaba una reindexación completa del documento. La aplicación almacenaba documentos de dispositivos y los indexaba para consultarlos. Un heartbeat actualizaba un campo trivial, una marca de tiempo, y la ruta de escritura reindexaba el documento entero en lugar del atributo modificado. A la escala de toda la flota, eso convertía una señal de actividad ligera en un movimiento constante de índices, con el perfil de memoria de una recarga masiva funcionando de forma permanente.
- Los índices antiguos seguían ahí. Las estructuras de índices reemplazadas no se recuperaban limpiamente, así que la memoria atribuible a la indexación crecía con el tiempo, con independencia del volumen de datos. El keyspace se veía estable; el proceso no.
- Se indexaban campos UUID sin ningún motivo. Identificadores opacos de alta cardinalidad por los que nada consultaba, y cada uno sumaba estructura de índice que la carga de trabajo nunca leía.
Sume esas tres cosas y obtendrá una instancia cuya demanda real de memoria de Redis está dominada por el mantenimiento de índices, con picos justo cuando sube el tráfico de escritura, que es también cuando un snapshot resulta más costoso. El 61 % no era un umbral en ningún sentido real. Era simplemente donde estaba la línea base cuando llegaba la siguiente coincidencia entre una reindexación y un fork.
La remediación que trabajamos con ellos fue de arquitectura, no de configuración:
- Separar los datos del heartbeat del documento indexado. Las actualizaciones de actividad no deberían tocar una estructura que haya que reindexar. Mueva los campos volátiles a su propia clave, con su propio ciclo de vida.
- Eliminar y recrear los índices periódicamente en lugar de confiar en que la recuperación incremental siga el ritmo del movimiento. Una reconstrucción programada devuelve memoria que la recolección de basura incremental nunca iba a alcanzar con esa tasa de escritura.
- Ajustar la recolección de basura de los índices para que la recuperación siga el ritmo de la tasa de escritura en lugar de quedarse atrás para siempre.
- Mover los trabajos de reindexación fuera de las horas pico, para que el trabajo masivo de indexación y el tráfico pico de escritura dejen de competir por el mismo margen.
- Dejar de indexar campos por los que nada consulta. Los UUID se eliminaron.
Nada de eso se puede descubrir con INFO memory. Si su instancia de Redis ejecuta un motor de consultas sobre documentos que se escriben con mucha más frecuencia de la que cambia su estructura, este es el primer lugar donde buscar, mucho antes de tocar maxmemory.
Solicite una evaluación de memoria de Redis
¿Se cae Redis con una utilización que sus métricas consideran segura? El overhead del fork, la fragmentación y el movimiento de índices son invisibles para used_memory. AceMQ realiza evaluaciones estructuradas de memoria de Redis que los detectan, y ofrece soporte empresarial de Redis para entornos de producción. Hable con un ingeniero de AceMQ.
¿Cómo averiguo qué está usando realmente la memoria de Redis?
Empiece por lo general y luego vaya acotando. Todos estos comandos son seguros en una instancia de producción con mucha carga, porque recorren las claves con SCAN en lugar de bloquear con KEYS.
MEMORY DOCTOR # Redis's own read on whether memory looks unhealthy
MEMORY STATS # breakdown by category: dataset, replication backlog, clients, overhead
redis-cli --memkeys # biggest keys by bytes consumed
redis-cli --bigkeys # biggest keys by element count, per type
redis-cli --keystats # both, plus size distribution and a top-N list
MEMORY USAGE <key> # exact bytes for one key--bigkeys y --memkeys responden a preguntas distintas, y la gente suele confundirlas. Un set con diez millones de miembros enteros pequeños es enorme por número de elementos y modesto en bytes; un único string que contiene un blob serializado de 200MB es lo contrario. El primero es un problema de latencia: cualquier comando O(N) sobre él bloquea el servidor. El segundo es un problema de memoria. Necesita ambas lecturas.
Limite el ritmo de cualquiera de los dos con -i 0.01 para que haga una pausa entre lotes de SCAN en una instancia cargada.
Un patrón que merece la pena nombrar: la amplificación de escritura por valores demasiado grandes. Guardar un objeto completo y reescribirlo para cambiar un solo campo significa que cada actualización paga el tamaño serializado completo en movimiento de asignaciones y, si la instancia tiene persistencia, en páginas de copy-on-write. Los hashes con actualizaciones por campo lo evitan por completo. Es la misma forma que el caso de reindexación anterior, una capa más abajo.
¿Cómo dimensionar la memoria de Redis?
Reglas prácticas para dimensionar la memoria de Redis, en orden de importancia:
- Dimensione para el pico, no para el estado estable. El RSS sigue la marca máxima alcanzada porque el asignador no devuelve las páginas con facilidad.
- En una instancia que genera snapshots bajo carga de escritura, mantenga el dataset en torno al 50–60 % de la RAM. El resto es margen para el fork. No el 80 %, y mucho menos el 100.
- Si una instancia no necesita snapshots, desactívelos. Una caché que se puede reconstruir no necesita RDB, y eliminar el fork elimina toda esa clase de fallos. Haga la persistencia en una réplica.
- Configure alertas sobre el RSS del proceso, no solo sobre
used_memory. La métrica que lo tumba no es la que muestra Redis. - Dimensione las réplicas de forma independiente. Por defecto ignoran
maxmemoryy pueden superar a su primario. - Deje
maxmemorybastante por debajo de la RAM del host. Si lo configura con toda la memoria del equipo, será el OOM killer del kernel, y no Redis, quien decida qué pasa después.
Si usa Redis como cola y la presión de memoria de Redis sigue la profundidad de la cola, la pregunta de dimensionamiento es en realidad una pregunta de arquitectura: un broker con colas respaldadas en disco no tiene este modo de fallo. Analizamos esa disyuntiva en usar Redis y RabbitMQ juntos.
Para el diagnóstico más amplio en torno a estos síntomas (comandos lentos, bloqueos de replicación, límites de conexiones), consulte nuestra guía de resolución de problemas de Redis.
Este es el paso dos de siete de la guía de fiabilidad de Redis, que aborda los problemas en el orden en que aparecen en un entorno de producción.
Preguntas frecuentes
¿Por qué se cae Redis si el uso de memoria parece normal?
Porque used_memory mide el keyspace, no el proceso. Durante un guardado en segundo plano, el copy-on-write del fork puede llevar la memoria total del proceso cerca del doble del dataset, así que una instancia que indica un 60 % de utilización puede agotar la RAM a mitad del guardado.
¿Qué limita realmente maxmemory en Redis?
La memoria que Redis asigna a los datos de usuario, más algunas asignaciones extra pequeñas. No cubre el fork durante un snapshot, y los buffers pueden llevar la memoria residente muy por encima de ese límite. Trate maxmemory como un techo para el keyspace, no para el proceso.
¿Cuál es un ratio de fragmentación de memoria saludable en Redis?
Entre 1,0 y 1,5, aproximadamente, en una instancia estable. El ratio es used_memory_rss dividido entre used_memory, así que un valor muy por encima de 1 significa que el asignador retiene páginas que Redis no está usando. El propio Redis advierte que el ratio no es fiable después de un pico grande cuya memoria ya se liberó.
¿Cómo averiguo qué está usando la memoria de Redis?
redis-cli --memkeys para las claves más grandes en bytes y --bigkeys para las más grandes por número de elementos. Ambos usan SCAN, así que son seguros en producción. MEMORY USAGE <key> da la cifra exacta de una clave, y MEMORY STATS desglosa la memoria total de Redis por categoría.
¿Cuánta RAM debe tener una instancia de Redis?
Aprovisione para el pico, no para la media: Redis no devuelve de forma fiable al sistema operativo la memoria liberada, así que el RSS sigue la marca máxima alcanzada. En una instancia que genera snapshots bajo carga de escritura, mantener el dataset en torno al 50 a 60 % de la RAM deja espacio para el overhead del fork.
¿Libera Redis memoria cuando elimino claves?
No necesariamente se la devuelve al sistema operativo. El asignador suele reutilizar el espacio liberado para claves nuevas, así que la memoria residente se mantiene estable en lugar de bajar. Es el comportamiento normal del asignador, no una fuga de Redis.
¿Las réplicas de Redis respetan maxmemory?
Por defecto, no. Las réplicas ignoran maxmemory y dejan que el primario dirija la expulsión mediante comandos DEL replicados, lo que significa que una réplica puede superar el límite del primario y llegar a una condición real de memoria insuficiente. Monitorice la memoria de las réplicas por separado.
¿Por qué la memoria sigue creciendo si el keyspace no crece?
Busque fuera del keyspace: buffers de salida de clientes con consumidores lentos, el backlog de replicación, la fragmentación del asignador y, en instancias que usan el motor de consultas, las estructuras de índices y sus residuos, que no se contabilizan como la gente espera.
Fuentes
Guías, comparativas e investigación

