Como o Redis gerencia memória?

Question

Accepted Answer

Como o Redis armazena dados em RAM, **gerenciamento de memória** é crítico — entender o limite `maxmemory`, **políticas de despejo**, otimização de memória e monitoramento é essencial para executar o Redis de forma confiável sem ficar sem memória.

## maxmemory e despejo

```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)
```

Definir `maxmemory` mais uma **política de despejo** controla o comportamento quando a memória se enche — essencial para impedir que o Redis esgote a memória do sistema ou falhe.

## Monitoramento de memória

```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 otimização de memória

```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 que a memória importa no 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 que isso importa

Entender o gerenciamento de memória do Redis é importante para **executar o Redis de forma confiável**, porque o Redis armazena dados em RAM limitada e relativamente cara, então gerenciar memória é essencial para evitar que fique sem memória (causando despejos, rejeição de escritas ou falhas).

A prática fundamental — definir **`maxmemory`** (limitando a memória do Redis) mais uma **política de despejo** — é crítica: ela controla o que acontece quando o limite é atingido (despejando chaves conforme políticas como `allkeys-lru` para um cache puro, ou `noeviction` para rejeitar escritas quando o Redis contém dados importantes), impedindo que o Redis esgote a memória do sistema.

Escolher a política de despejo correta para o caso de uso (LRU/LFU para caches, noeviction ou políticas voláteis quando os dados importam) é um julgamento de configuração-chave. **Monitorar memória** (`INFO memory` para uso, pico, fragmentação e chaves despejadas; `MEMORY USAGE` por chave) é essencial para conhecimento operacional — observando o uso contra o limite e detectando problemas.

Conhecer **técnicas de otimização de memória** — usar TTLs para expirar dados desnecessários, escolher estruturas de dados eficientes (hashes/listas pequenos usam codificações compactas, muito mais baratas que muitas chaves separadas), evitar chaves enormes (que causam picos de latência) e armazenar apenas o necessário — ajuda a caber mais na memória e executar com eficiência.

Como a natureza em memória do Redis torna a memória um recurso finito e crítico, e como o gerenciamento adequado de memória (maxmemory + política de despejo, monitoramento e otimização) é o que mantém o Redis saudável e previne falhas de falta de memória, entender o gerenciamento de memória do Redis é conhecimento importante e praticamente relevante para operar o Redis de forma confiável, uma preocupação operacional-chave que diferencia aqueles que conseguem executar o Redis em produção daqueles que apenas sabem como usá-lo, e essencial para evitar as falhas reais que vêm do crescimento de memória não gerenciado.