Come funziona lo sharding in MongoDB?

Question

Accepted Answer

**Lo sharding** è il metodo di MongoDB per il **scaling orizzontale** — distribuire i dati su più server (**shard**) in modo che il database possa gestire set di dati e throughput oltre ciò che un singolo server può. Partiziona i dati per una **shard key**, con MongoDB che instrada le query ai shard corretti.

## Perché è importante

```text
A single server has limits (storage, RAM, write throughput). When data/load exceeds
what one server (even a powerful one) can handle, SHARDING distributes it:
  → data is split across multiple SHARDS (each a replica set)
  → each shard holds a SUBSET of the data → combined capacity scales horizontally
  → handles huge datasets and high write throughput
```

## Come funziona lo sharding

```text
The sharded cluster has three parts:
  SHARDS    → each holds a portion of the data (each shard is itself a replica set)
  mongos    → query ROUTER — apps connect here; it routes queries to the right shard(s)
  CONFIG SERVERS → store metadata (which data is on which shard)

Data is partitioned by the SHARD KEY into CHUNKS, distributed across shards.
MongoDB balances chunks across shards automatically.
```

## La shard key — la decisione più critica

```js
sh.shardCollection("mydb.orders", { customerId: 1 });   // shard by customerId
```

```text
The SHARD KEY determines how data is distributed — choosing it well is CRITICAL:
  ✓ HIGH CARDINALITY (many distinct values) → data spreads evenly
  ✓ EVEN DISTRIBUTION of reads/writes → no hot shards
  ✓ Queries include the shard key → routed to ONE shard (targeted, fast)
  ✗ A BAD shard key → uneven distribution (hotspots), or queries hitting ALL shards
    (scatter-gather, slow) → poor scaling. Hard to change later!
Strategies: ranged sharding, HASHED sharding (even distribution), zoned sharding.
```

## Query mirate vs scatter-gather

```text
Query INCLUDES the shard key → routed to the specific shard(s) → fast (targeted)
Query WITHOUT the shard key → must query ALL shards (scatter-gather) → slower
→ Design the shard key around your common query patterns.
```

## Perché conta

Lo sharding è una conoscenza importante per **scalare MongoDB a set di dati molto grandi e alto throughput**, quindi comprenderlo è una conoscenza preziosa di livello senior per distribuzioni MongoDB su larga scala.

Il valore fondamentale è lo **scaling orizzontale**: quando i dati o il carico superano ciò che un singolo server può gestire, lo sharding distribuisce i dati su più shard, scalando la capacità orizzontalmente per gestire enormi set di dati e alto throughput di scrittura che lo scaling verticale (un server più grande) non può raggiungere — una capacità chiave per i sistemi su larga scala.

Comprendere l'**architettura** (shard che ciascuno contiene un sottoinsieme di dati, il router di query `mongos` che indirizza le query, server di configurazione che memorizzano i metadati) è fondamentale.

Più criticamente, comprendere la **shard key** — il campo o i campi che determinano la distribuzione dei dati — è essenziale perché **è la decisione di sharding più consequenziale e difficile da cambiare**: una buona shard key (alta cardinalità, distribuzione uniforme, allineata ai pattern di query) distribuisce i dati e il carico uniformemente e abilita query mirate, mentre una cattiva causa hotspot (carico non uniforme), query scatter-gather (che colpiscono tutti i shard, lente), e scarso scaling.

Comprendere le **query mirate vs scatter-gather** (le query che includono la shard key si instradano a shard specifici in modo efficiente; quelle che non la includono colpiscono tutti i shard) rafforza la progettazione della shard key attorno ai pattern di query.

Poiché il scaling a dati molto grandi è una sfida reale per le applicazioni ad alta crescita, e poiché lo sharding (il meccanismo di scaling orizzontale di MongoDB) richiede una comprensione attenta — in particolare la decisione critica e difficile da cambiare della shard key e il suo impatto sulla distribuzione e l'efficienza delle query — comprendere lo sharding è una conoscenza importante di livello senior per scalare MongoDB, un argomento che dimostra la comprensione dello scaling orizzontale del database e uno in cui la decisione della shard key in particolare riflette l'expertise profonda e consequenziale di scaling MongoDB attesa per i ruoli senior che gestiscono sistemi su larga scala.