Guida Passo-Passo: Implementazione di un Cluster Shardato MongoDB di Base

MongoDB, un popolare database di documenti NoSQL, eccelle nella gestione di grandi volumi di dati con alte prestazioni e flessibilità. Tuttavia, man mano che i dati crescono, un singolo server o un replica set può raggiungere i suoi limiti di scalabilità. È qui che entra in gioco lo sharding, che consente la scalabilità orizzontale distribuendo i dati su più server, o shard.

Questa guida completa ti accompagnerà attraverso l'intero processo di configurazione di un cluster shardato MongoDB funzionante. Imparerai come configurare i componenti essenziali: server di configurazione (config servers), router mongos e replica set di shard. Al termine di questo tutorial, avrai una comprensione fondamentale e un'esperienza pratica nella distribuzione di un cluster shardato progettato per un'elevata scalabilità orizzontale e disponibilità.

Comprendere i Cluster Shardati MongoDB

Un cluster shardato MongoDB è costituito da tre componenti principali che lavorano insieme per distribuire e instradare i dati:

• Shard Replica Sets: Questi sono i nodi che contengono i dati effettivi. Ogni shard è un replica set per fornire alta disponibilità e ridondanza dei dati. I dati sono partizionati tra questi shard.
• Configuration Servers (Config Servers): Questi memorizzano i metadati del cluster, inclusa la mappatura dei chunk di dati agli shard. A partire da MongoDB 3.2, i config server devono essere distribuiti come replica set (CSRS - Config Server Replica Set) per alta disponibilità e consistenza.
• Router mongos: Questi agiscono come router di query, fornendo un'interfaccia per le applicazioni client. Un'istanza mongos dirige le operazioni client allo/agli shard appropriato/i in base ai metadati del cluster. Le applicazioni si connettono a mongos, non direttamente agli shard.

Diagramma concettuale di un cluster shardato MongoDB (credito immagine: documentazione ufficiale MongoDB)

Prerequisiti

Prima di iniziare, assicurati di avere quanto segue:

1. Più Macchine/VM: Per un cluster shardato veramente distribuito, avrai bisogno di almeno 6-9 macchine/VM/container Docker. Per questo tutorial di base, possiamo simularlo su una singola macchina utilizzando porte diverse, ma ricorda che una configurazione di produzione richiede risorse dedicate.
   • 3 per i Config Servers (configSrv01, configSrv02, configSrv03)
   • Minimo 2-3 per ogni Shard (es. Shard01-RS01, Shard01-RS02, Shard01-RS03; Shard02-RS01, ...)
   • 1+ per i Router mongos
2. Installazione di MongoDB: MongoDB 4.2+ installato su tutte le macchine che ospiteranno istanze mongod o mongos. Puoi trovare le istruzioni di installazione sulla Documentazione MongoDB.
3. Networking: Assicurati che tutte le macchine possano comunicare tra loro sulle porte necessarie (di default 27017, 27018, 27019, 27020 rispettivamente per i config server, gli shard e i mongos, o porte personalizzate).
4. Struttura delle Directory: Crea directory dedicate per i dati e i log per ogni istanza mongod e mongos.

Per semplicità in questa guida, useremo localhost con porte e directory diverse. In un ambiente di produzione, useresti nomi host o indirizzi IP reali.

Struttura delle Directory Raccomandata (Esempio per configurazione localhost)

mkdir -p /data/db/configdb01 /data/db/configdb02 /data/db/configdb03
mkdir -p /data/db/shard01-rs01 /data/db/shard01-rs02 /data/db/shard01-rs03
mkdir -p /data/db/shard02-rs01 /data/db/shard02-rs02 /data/db/shard02-rs03
mkdir -p /data/log/config /data/log/shard01 /data/log/shard02 /data/log/mongos

Passaggi di Implementazione

Passaggio 1: Configurare i Server di Configurazione (Config Replica Set)

I server di configurazione memorizzano i metadati per il cluster shardato. Devono essere eseguiti come un replica set.

1. Avviare le istanze mongod per i config server: Ogni istanza necessita delle opzioni --configsvr e --replSet.

   # Config Server 1
   mongod --configsvr --replSet cfgReplSet --dbpath /data/db/configdb01 --port 27019 --bind_ip localhost --logpath /data/log/config/configdb01.log --fork
   
   # Config Server 2
   mongod --configsvr --replSet cfgReplSet --dbpath /data/db/configdb02 --port 27020 --bind_ip localhost --logpath /data/log/config/configdb02.log --fork
   
   # Config Server 3
   mongod --configsvr --replSet cfgReplSet --dbpath /data/db/configdb03 --port 27021 --bind_ip localhost --logpath /data/log/config/configdb03.log --fork
   

   Suggerimento: Per la produzione, sostituire localhost con indirizzi IP o nomi host reali.

2. Inizializzare il Config Replica Set: Connettiti a una delle istanze del config server e inizializza il replica set.

mongo --port 27019 ```

All'interno della shell mongo:

```javascript
rs.initiate({
   _id: "cfgReplSet",
   configsvr: true,
   members: [
      { _id : 0, host : "localhost:27019" },
      { _id : 1, host : "localhost:27020" },
      { _id : 2, host : "localhost:27021" }
   ]
});
```

Verifica lo stato:

```javascript
rs.status();
```

Passaggio 2: Configurare gli Shard Replica Set

Ogni shard nel cluster è un replica set. Configureremo due shard (shard01 e shard02), ciascuno con tre membri.

1. Avviare le istanze mongod per i membri dello Shard 1: Ogni istanza necessita delle opzioni --shardsvr e --replSet.

   # Shard 1 Membro 1
   mongod --shardsvr --replSet shard01 --dbpath /data/db/shard01-rs01 --port 27030 --bind_ip localhost --logpath /data/log/shard01/shard01-rs01.log --fork
   
   # Shard 1 Membro 2
   mongod --shardsvr --replSet shard01 --dbpath /data/db/shard01-rs02 --port 27031 --bind_ip localhost --logpath /data/log/shard01/shard01-rs02.log --fork
   
   # Shard 1 Membro 3
   mongod --shardsvr --replSet shard01 --dbpath /data/db/shard01-rs03 --port 27032 --bind_ip localhost --logpath /data/log/shard01/shard01-rs03.log --fork
   

2. Inizializzare lo Shard 1 Replica Set: Connettiti a una delle istanze dello Shard 1.

mongo --port 27030 ```

All'interno della shell mongo:

```javascript
rs.initiate({
   _id : "shard01",
   members: [
      { _id : 0, host : "localhost:27030" },
      { _id : 1, host : "localhost:27031" },
      { _id : 2, host : "localhost:27032" }
   ]
});
```

1. Avviare le istanze mongod per i membri dello Shard 2 (ripetere per shard aggiuntivi):

   # Shard 2 Membro 1
   mongod --shardsvr --replSet shard02 --dbpath /data/db/shard02-rs01 --port 27040 --bind_ip localhost --logpath /data/log/shard02/shard02-rs01.log --fork
   
   # Shard 2 Membro 2
   mongod --shardsvr --replSet shard02 --dbpath /data/db/shard02-rs02 --port 27041 --bind_ip localhost --logpath /data/log/shard02/shard02-rs02.log --fork
   
   # Shard 2 Membro 3
   mongod --shardsvr --replSet shard02 --dbpath /data/db/shard02-rs03 --port 27042 --bind_ip localhost --logpath /data/log/shard02/shard02-rs03.log --fork
   

2. Inizializzare lo Shard 2 Replica Set: Connettiti a una delle istanze dello Shard 2.

mongo --port 27040 ```

All'interno della shell mongo:

```javascript
rs.initiate({
   _id : "shard02",
   members: [
      { _id : 0, host : "localhost:27040" },
      { _id : 1, host : "localhost:27041" },
      { _id : 2, host : "localhost:27042" }
   ]
});
```

Passaggio 3: Configurare i Router mongos

Le istanze mongos sono i punti di ingresso per le applicazioni client. Devono sapere dove si trovano i config server.

1. Avviare le istanze mongos: Fornisci l'opzione --configdb, elencando i membri del config replica set.

   # Router Mongos 1
   mongos --configdb cfgReplSet/localhost:27019,localhost:27020,localhost:27021 --port 27017 --bind_ip localhost --logpath /data/log/mongos/mongos01.log --fork
   

   Nota: Puoi avviare più istanze mongos per il bilanciamento del carico e l'alta disponibilità. Tutte si connettono agli stessi config server.

Passaggio 4: Connettersi a mongos e Aggiungere Shard

Ora, connettiti a un'istanza mongos e aggiungi gli shard replica set al cluster.

1. Connettersi a mongos: Usa la porta MongoDB predefinita 27017 o la porta personalizzata che hai specificato per mongos.

mongo --port 27017 ```

1. Aggiungere Shard: Usa il comando sh.addShard(), specificando il nome del replica set e uno dei suoi membri.

   sh.addShard("shard01/localhost:27030");
   sh.addShard("shard02/localhost:27040");
   

Passaggio 5: Abilitare lo Sharding per un Database e una Collection

Una volta aggiunti gli shard, devi abilitare lo sharding per database specifici e poi per collection specifiche all'interno di tali database. Ciò richiede la scelta di una shard key.

1. Abilitare lo Sharding per un Database: Passa al database che desideri shardare ed esegui sh.enableSharding().

   use mydatabase;
   sh.enableSharding("mydatabase");
   

2. Shardare una Collection: Scegli una shard key e usa sh.shardCollection().

   Attenzione: Scegliere una shard key efficace è fondamentale per le prestazioni e una distribuzione uniforme. Una shard key scadente può portare a hot spot o query inefficienti. Le strategie comuni includono chiavi hash, chiavi a intervallo o chiavi composite.

   Per questo esempio, assumiamo una collection mycollection con un campo _id.

   sh.shardCollection("mydatabase.mycollection"