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.

   ```bash

   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.

   bash 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.

   ```bash

   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.

   bash 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" } ] });

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

   ```bash

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

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

   bash 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.

   ```bash

   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.

   bash mongo --port 27017

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

   javascript 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().

   javascript 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.

   ```javascript
   sh.shardCollection("mydatabase.mycollection"