Come abilita il scaling Redis Cluster?

Question

Accepted Answer

**Redis Cluster** abilita lo **scaling orizzontale** distribuendo i dati tramite sharding su più nodi Redis — distribuendo il dataset (e il carico) in modo che Redis possa gestire dati e throughput oltre la memoria di un singolo server. Partiziona i dati tramite **hash slots** e fornisce alta disponibilità integrata.

## Sharding via hash slots

```text
Redis Cluster divides the keyspace into 16384 HASH SLOTS.
  → each key maps to a slot: slot = CRC16(key) mod 16384
  → slots are distributed across the cluster's primary nodes
  → each node owns a subset of slots (and thus a subset of the data)
→ This spreads data and load across nodes → scales memory and throughput horizontally.
```

I dati vengono partizionati tra i nodi tramite **hash slots** (16384 totali): ogni chiave si hasha in uno slot, e gli slot sono distribuiti tra i nodi primari — quindi ogni nodo contiene parte dei dati, scalando la capacità oltre un singolo server.

## Alta disponibilità integrata

```text
Each primary node has REPLICAS:
  → if a primary fails, one of its replicas is promoted (automatic failover)
  → the cluster continues serving (HA without separate Sentinel)
→ Redis Cluster combines SHARDING (scale) + REPLICATION (HA).
```

## Client e redirezione

```text
→ Clients connect to the cluster; a key's request goes to the node owning its slot.
→ If a client hits the wrong node, it gets a MOVED redirect to the right node
  (cluster-aware clients cache the slot map and route directly).
```

## Il vincolo multi-chiave (importante)

```text
⚠️ Multi-key operations only work if all keys are in the SAME slot (same node):
  → operations spanning keys on different nodes are NOT supported directly
  → use HASH TAGS to force related keys into the same slot:
     {user:1000}:profile and {user:1000}:settings → same slot ({...} part is hashed)
→ Design keys so related data that's used together shares a slot.
```

## Perché è importante

Comprendere Redis Cluster è importante per **scalare Redis orizzontalmente oltre un singolo server**, quindi è una conoscenza preziosa di livello senior per deployment Redis su larga scala.

Il valore fondamentale è lo **scaling orizzontale**: quando i dati o il throughput superano quello che la memoria di un singolo server Redis può gestire, Cluster **distribuisce i dati su più nodi** (tramite 16384 **hash slots**, ogni chiave mappata a uno slot distribuito tra i nodi primari), diffondendo dati e carico per scalare memoria e throughput oltre una singola macchina — essenziale per sistemi su larga scala.

Comprendere il **meccanismo degli hash slots** (come le chiavi si mappano agli slot e gli slot ai nodi) è fondamentale per capire come Cluster distribuisce i dati.

Sapere che Cluster fornisce **alta disponibilità integrata** (ogni primario ha repliche con failover automatico, combinando sharding e replicazione senza bisogno di Sentinel separato) è importante per l'affidabilità su scala.

Comprendere la **redirezione dei client** (redirect MOVED, client consapevoli del cluster che cachiano la mappa degli slot) spiega come le richieste raggiungono il nodo giusto.

Criticamente, comprendere il **vincolo multi-chiave** — che le operazioni multi-chiave richiedono tutte le chiavi nello stesso slot, risolte con **hash tags** (`{user:1000}:...` forzando le chiavi correlate nello stesso slot) — è essenziale perché è un vero vincolo che influenza il design delle chiavi (i dati correlati utilizzati insieme devono essere co-locati), e non comprenderlo causa errori con operazioni multi-chiave in un cluster.

Poiché scalare oltre un singolo server Redis è una necessità reale per sistemi ad alto volume, e poiché Redis Cluster (sharding via hash slots + HA integrata) è il meccanismo per ottenerlo — con il importante vincolo hash-tag/multi-chiave che influenza il design — comprendere Redis Cluster è una conoscenza importante di livello senior per scalare Redis, un argomento che dimostra la comprensione dello scaling orizzontale e i vincoli pratici (co-locazione delle chiavi) che derivano dalla distribuzione dei dati Redis su più nodi.