¿Cómo gestiona Redis la memoria?

Question

Accepted Answer

Dado que Redis almacena datos en RAM, **la gestión de memoria** es crítica — entender el límite `maxmemory`, **políticas de evicción**, optimización de memoria y monitoreo es esencial para ejecutar Redis de forma confiable sin agotar la memoria.

## maxmemory y evicción

```text
Set a memory limit so Redis doesn't consume all RAM:
  maxmemory 2gb                       # cap Redis at 2GB
  maxmemory-policy allkeys-lru        # what to do when the limit is reached

When the limit is hit, Redis EVICTS keys per the policy (or rejects writes):
  allkeys-lru   → evict least-recently-used (any key) — common for a pure cache
  allkeys-lfu   → evict least-frequently-used
  volatile-lru  → evict LRU among keys WITH a TTL only
  volatile-ttl  → evict keys closest to expiry
  noeviction    → reject writes when full (good if Redis holds important data)
```

Establecer `maxmemory` más una **política de evicción** controla el comportamiento cuando la memoria se llena — esencial para evitar que Redis agote la memoria del sistema o se bloquee.

## Monitoreo de memoria

```bash
INFO memory               # used_memory, peak, fragmentation ratio, etc.
MEMORY USAGE key          # memory used by a specific key
MEMORY DOCTOR             # diagnostics/recommendations
DBSIZE                    # number of keys
# watch: used_memory vs maxmemory, evicted_keys, fragmentation
```

## Técnicas de optimización de memoria

```text
✓ Set TTLs → expire data that's no longer needed (don't let data accumulate forever)
✓ Use efficient data structures → small hashes/lists/sets use compact encodings (ziplist/
  listpack) → much less memory than many separate keys
✓ Shorter key names (minor, but adds up at scale)
✓ Store only what you need; consider compression for large values
✓ Avoid huge keys (a single huge value/collection) — they cause latency spikes
```

## Por qué la memoria es importante en Redis

```text
RAM is LIMITED and more expensive than disk. Running out of memory →
  evictions (cache misses), rejected writes, or crashes.
→ Capacity planning, eviction policy, TTLs, and monitoring keep Redis healthy.
```

## Por qué es importante

Entender la gestión de memoria de Redis es importante para **ejecutar Redis de forma confiable**, porque Redis almacena datos en RAM limitada y relativamente costosa, por lo que la gestión de memoria es esencial para evitar que se agote (causando eviciones, escrituras rechazadas o bloqueos).

La práctica fundamental — establecer **`maxmemory`** (limitando la memoria de Redis) más una **política de evicción** — es crítica: controla qué sucede cuando se alcanza el límite (evictando claves según políticas como `allkeys-lru` para un caché puro, o `noeviction` para rechazar escrituras cuando Redis contiene datos importantes), previniendo que Redis agote la memoria del sistema.

Elegir la política de evicción correcta para el caso de uso (LRU/LFU para cachés, noeviction o políticas volátiles cuando los datos importan) es un juicio de configuración clave. **Monitorear memoria** (`INFO memory` para uso, pico, fragmentación y claves evictadas; `MEMORY USAGE` por clave) es esencial para la conciencia operativa — observar el uso contra el límite y detectar problemas.

Conocer **técnicas de optimización de memoria** — usar TTLs para expirar datos innecesarios, elegir estructuras de datos eficientes (hashes/listas pequeños usan codificaciones compactas, mucho más baratas que muchas claves separadas), evitar claves enormes (que causan picos de latencia) y almacenar solo lo necesario — ayuda a ajustar más en memoria y ejecutar de forma eficiente.

Ya que la naturaleza en memoria de Redis hace que la memoria sea un recurso finito y crítico, y dado que la gestión de memoria adecuada (maxmemory + política de evicción, monitoreo y optimización) es lo que mantiene Redis saludable y previene fallos por falta de memoria, entender la gestión de memoria de Redis es conocimiento importante y prácticamente relevante para operar Redis de forma confiable, una preocupación operativa clave que distingue a quienes pueden ejecutar Redis en producción de quienes solo saben cómo usarlo, y esencial para evitar los fallos reales que provienen del crecimiento de memoria no gestionado.