Schritt-für-Schritt-Anleitung: Bereitstellung eines grundlegenden MongoDB Sharded Clusters

MongoDB, eine beliebte NoSQL-Dokumentendatenbank, zeichnet sich durch die Verarbeitung großer Datenmengen mit hoher Leistung und Flexibilität aus. Wenn jedoch die Daten wachsen, stößt ein einzelner Server oder ein Replikatset an seine Skalierungsgrenzen. Hier kommt Sharding ins Spiel, das horizontale Skalierbarkeit ermöglicht, indem Daten auf mehrere Server oder Shards verteilt werden.

Diese umfassende Anleitung führt Sie durch den gesamten Prozess der Einrichtung eines funktionsfähigen MongoDB Sharded Clusters. Sie lernen, wie Sie die wesentlichen Komponenten konfigurieren: Konfigurationsserver (Config Server), mongos-Router und Shard-Replikatsets. Am Ende dieses Tutorials verfügen Sie über ein grundlegendes Verständnis und praktische Erfahrung in der Bereitstellung eines Sharded Clusters, der für hohe horizontale Skalierbarkeit und Verfügbarkeit ausgelegt ist.

Verständnis von MongoDB Sharded Clustern

Ein MongoDB Sharded Cluster besteht aus drei Hauptkomponenten, die zusammenarbeiten, um Daten zu verteilen und zu leiten:

• Shard-Replikatsets: Dies sind die eigentlichen datentragenden Knoten. Jeder Shard ist ein Replikatset, um hohe Verfügbarkeit und Datenredundanz zu gewährleisten. Daten werden über diese Shards partitioniert.
• Konfigurationsserver (Config Server): Diese speichern die Metadaten des Clusters, einschließlich der Zuordnung von Datenchunks zu Shards. Ab MongoDB 3.2 müssen Konfigurationsserver als Replikatset (CSRS - Config Server Replica Set) für hohe Verfügbarkeit und Konsistenz bereitgestellt werden.
• mongos-Router: Diese fungieren als Abfragerouter und bieten eine Schnittstelle für Client-Anwendungen. Eine mongos-Instanz leitet Client-Operationen basierend auf den Metadaten des Clusters an den/die entsprechenden Shard(s) weiter. Anwendungen verbinden sich mit mongos, nicht direkt mit den Shards.

Konzeptionelles Diagramm eines MongoDB Sharded Clusters (Bildnachweis: Offizielle MongoDB-Dokumentation)

Voraussetzungen

Stellen Sie vor Beginn sicher, dass Sie Folgendes haben:

1. Mehrere Maschinen/VMs: Für einen wirklich verteilten Sharded Cluster benötigen Sie mindestens 6-9 Maschinen/VMs/Docker-Container. Für dieses grundlegende Tutorial können wir dies auf einer einzelnen Maschine mit verschiedenen Ports simulieren, aber denken Sie daran, dass eine Produktionsumgebung dedizierte Ressourcen erfordert.
   • 3 für Konfigurationsserver (configSrv01, configSrv02, configSrv03)
   • Mindestens 2-3 für jeden Shard (z. B. Shard01-RS01, Shard01-RS02, Shard01-RS03; Shard02-RS01, ...)
   • 1+ für mongos-Router
2. MongoDB-Installation: MongoDB 4.2+ ist auf allen Maschinen installiert, auf denen mongod- oder mongos-Instanzen gehostet werden. Installationsanleitungen finden Sie in der MongoDB-Dokumentation.
3. Netzwerk: Stellen Sie sicher, dass alle Maschinen über die erforderlichen Ports miteinander kommunizieren können (standardmäßig 27017, 27018, 27019, 27020 für Konfigurationsserver, Shards und mongos bzw. benutzerdefinierte Ports).
4. Verzeichnisstruktur: Erstellen Sie dedizierte Daten- und Logverzeichnisse für jede mongod- und mongos-Instanz.

Vereinfacht werden wir in dieser Anleitung localhost mit verschiedenen Ports und Verzeichnissen verwenden. In einer Produktionsumgebung würden Sie tatsächliche Hostnamen oder IP-Adressen verwenden.

Empfohlene Verzeichnisstruktur (Beispiel für eine localhost-Einrichtung)

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

Bereitstellungsschritte

Schritt 1: Konfigurationsserver einrichten (Config Replica Set)

Konfigurationsserver speichern Metadaten für den Sharded Cluster. Sie müssen als Replikatset ausgeführt werden.

1. mongod-Instanzen für Konfigurationsserver starten: Jede Instanz benötigt die Optionen --configsvr und --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
   ```

   Tipp: Ersetzen Sie für die Produktion localhost durch tatsächliche IP-Adressen oder Hostnamen.

2. Das Config Replica Set initialisieren: Stellen Sie eine Verbindung zu einer der Konfigurationsserver-Instanzen her und initialisieren Sie das Replikatset.

   bash mongo --port 27019

   Innerhalb der Mongo-Shell:

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

   Status überprüfen:

   javascript rs.status();

Schritt 2: Shard-Replikatsets einrichten

Jeder Shard im Cluster ist ein Replikatset. Wir richten zwei Shards (shard01 und shard02) mit jeweils drei Mitgliedern ein.

1. mongod-Instanzen für Shard 1-Mitglieder starten: Jede Instanz benötigt die Optionen --shardsvr und --replSet.

   ```bash

   Shard 1 Mitglied 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 Mitglied 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 Mitglied 3

   mongod --shardsvr --replSet shard01 --dbpath /data/db/shard01-rs03 --port 27032 --bind_ip localhost --logpath /data/log/shard01/shard01-rs03.log --fork
   ```

2. Shard 1 Replica Set initialisieren: Stellen Sie eine Verbindung zu einem der Shard 1-Instanzen her.

   bash mongo --port 27030

   Innerhalb der Mongo-Shell:

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

3. mongod-Instanzen für Shard 2-Mitglieder starten (für zusätzliche Shards wiederholen):

   ```bash

   Shard 2 Mitglied 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 Mitglied 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 Mitglied 3

   mongod --shardsvr --replSet shard02 --dbpath /data/db/shard02-rs03 --port 27042 --bind_ip localhost --logpath /data/log/shard02/shard02-rs03.log --fork
   ```

4. Shard 2 Replica Set initialisieren: Stellen Sie eine Verbindung zu einem der Shard 2-Instanzen her.

   bash mongo --port 27040

   Innerhalb der Mongo-Shell:

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

Schritt 3: mongos-Router einrichten

mongos-Instanzen sind die Einstiegspunkte für Client-Anwendungen. Sie müssen wissen, wo sich die Konfigurationsserver befinden.

1. mongos-Instanzen starten: Geben Sie die Option --configdb an und listen Sie die Mitglieder des Config Replica Sets auf.

   ```bash

   Mongos Router 1

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

   Hinweis: Sie können mehrere mongos-Instanzen für Load Balancing und Hochverfügbarkeit starten. Sie alle verbinden sich mit denselben Konfigurationsservern.

Schritt 4: Mit mongos verbinden und Shards hinzufügen

Verbinden Sie sich nun mit einer mongos-Instanz und fügen Sie die Shard-Replikatsets zum Cluster hinzu.

1. Mit mongos verbinden: Verwenden Sie den Standard-MongoDB-Port 27017 oder den benutzerdefinierten Port, den Sie für mongos angegeben haben.

   bash mongo --port 27017

2. Shards hinzufügen: Verwenden Sie den Befehl sh.addShard(), geben Sie den Namen des Replikatsets und eines seiner Mitglieder an.

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

Schritt 5: Sharding für eine Datenbank und eine Collection aktivieren

Nachdem Shards hinzugefügt wurden, müssen Sie Sharding für bestimmte Datenbanken und dann für bestimmte Collections innerhalb dieser Datenbanken aktivieren. Dazu ist die Wahl eines shard key erforderlich.

1. Sharding für eine Datenbank aktivieren: Wechseln Sie zu der Datenbank, die Sie sharden möchten, und führen Sie sh.enableSharding() aus.

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

2. Eine Collection sharden: Wählen Sie einen shard key und verwenden Sie sh.shardCollection().

   Warnung: Die Wahl eines effektiven Shard-Keys ist entscheidend für Leistung und gleichmäßige Verteilung. Ein schlechter Shard-Key kann zu Hotspots oder ineffizienten Abfragen führen. Gängige Strategien sind Hashed Keys, Ranged Keys oder Compound Keys.

   In diesem Beispiel nehmen wir an, dass eine Collection mycollection ein Feld _id hat.

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