Come Redis gestisce la memoria?

Question

Accepted Answer

Poiché Redis memorizza i dati in RAM, **la gestione della memoria** è critica — comprendere il limite `maxmemory`, le **politiche di evizione**, l'ottimizzazione della memoria e il monitoraggio è essenziale per eseguire Redis in modo affidabile senza esaurire la memoria.

## maxmemory ed evizione

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

Impostare `maxmemory` più una **politica di evizione** controlla il comportamento quando la memoria si riempie — essenziale per evitare che Redis esaurisca la memoria di sistema o si arresti.

## Monitoraggio della 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
```

## Tecniche di ottimizzazione della 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
```

## Perché la memoria è importante in 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.
```

## Perché è importante

Comprendere la gestione della memoria di Redis è importante per **eseguire Redis in modo affidabile**, perché Redis memorizza i dati in RAM limitata e relativamente costosa, quindi gestire la memoria è essenziale per evitare che si esaurisca (causando evizioni, rifiuti di scrittura o arresti).

La pratica fondamentale — impostare **`maxmemory`** (limitando la memoria di Redis) più una **politica di evizione** — è critica: controlla cosa accade quando il limite viene raggiunto (evincendo chiavi secondo politiche come `allkeys-lru` per una cache pura, o `noeviction` per rifiutare le scritture quando Redis contiene dati importanti), evitando che Redis esaurisca la memoria di sistema.

Scegliere la giusta politica di evizione per il caso d'uso (LRU/LFU per cache, noeviction o politiche volatili quando i dati sono importanti) è un giudizio critico di configurazione. **Monitorare la memoria** (`INFO memory` per uso, picco, frammentazione e chiavi evinte; `MEMORY USAGE` per chiave) è essenziale per la consapevolezza operativa — osservando l'uso rispetto al limite e individuando i problemi.

Conoscere le **tecniche di ottimizzazione della memoria** — utilizzare TTL per far scadere i dati non necessari, scegliere strutture di dati efficienti (hash e liste piccoli usano codifiche compatte, molto più economiche di molte chiavi separate), evitare chiavi enormi (che causano picchi di latenza), e memorizzare solo ciò che è necessario — aiuta a contenere più dati in memoria ed eseguire in modo efficiente.

Poiché la natura in memoria di Redis rende la memoria una risorsa finita e critica, e poiché la giusta gestione della memoria (maxmemory + politica di evizione, monitoraggio e ottimizzazione) è ciò che mantiene Redis sano e previene i guasti di esaurimento della memoria, comprendere la gestione della memoria di Redis è una conoscenza importante e praticamente rilevante per operare Redis in modo affidabile, una preoccupazione operativa chiave che distingue coloro che possono eseguire Redis in produzione da coloro che sanno solo come usarlo, ed è essenziale per evitare i veri guasti che derivano dalla crescita incontrollata della memoria.