DevOps-Tools & Best Practices meistern - DevOps Knowledge Hub DevOps-Tools & Best Practices meistern - DevOps Knowledge Hub

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

Stellen Sie einen grundlegenden MongoDB-Sharded-Cluster mit Konfigurationsservern, Shard-Replica-Sets, mongos-Routern und Sharding-Verifizierung bereit.

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 die Daten jedoch wachsen, kann ein einzelner Server oder ein Replica-Set an seine Skalierungsgrenzen stoßen. Hier kommt Sharding ins Spiel, das horizontale Skalierbarkeit ermöglicht, indem Daten auf mehrere Server (Shards) verteilt werden.

Diese Anleitung führt Sie durch ein grundlegendes MongoDB-Sharded-Cluster auf localhost zu Lernzwecken. Sie konfigurieren Konfigurationsserver, Shard-Replica-Sets und einen mongos-Router und aktivieren dann Sharding für eine Sammlung.

Grundlegendes zu MongoDB-Sharded-Clustern

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

  • Shard-Replica-Sets: Dies sind die eigentlichen datentragenden Knoten. Jeder Shard ist ein Replica-Set, um Hochverfügbarkeit und Datenredundanz zu gewährleisten. Die Daten werden auf diese Shards aufgeteilt.
  • Konfigurationsserver (Config Servers): Diese speichern die Metadaten des Clusters, einschließlich der Zuordnung von Datenblöcken zu Shards. Ab MongoDB 3.2 müssen Konfigurationsserver als Replica-Set (CSRS - Config Server Replica Set) für Hochverfügbarkeit und Konsistenz bereitgestellt werden.
  • mongos-Router: Diese fungieren als Abfrage-Router 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.

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

Voraussetzungen

Stellen Sie vor Beginn sicher, dass Folgendes vorhanden ist:

  1. Mehrere Maschinen/VMs: Für ein wirklich verteiltes 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: Installieren Sie eine unterstützte MongoDB-Serverversion auf jeder Maschine, die mongod oder mongos hosten wird. Verwenden Sie mongosh für Shell-Befehle.
  3. Netzwerk: Stellen Sie sicher, dass alle Maschinen über die erforderlichen Ports miteinander kommunizieren können (Standard 27017, 27018, 27019, 27020 für Konfigurationsserver, Shards bzw. mongos oder benutzerdefinierte Ports).
  4. Verzeichnisstruktur: Erstellen Sie dedizierte Daten- und Log-Verzeichnisse für jede mongod- und mongos-Instanz.

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

Empfohlene Verzeichnisstruktur (Beispiel für localhost-Setup)

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: Einrichten von Konfigurationsservern (Config Replica Set)

Konfigurationsserver speichern Metadaten für das Sharded-Cluster. Sie müssen als Replica-Set ausgeführt werden.

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

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

  2. Initialisieren Sie das Config Replica Set: Verbinden Sie sich mit einer der Konfigurationsserver-Instanzen und initialisieren Sie das Replica-Set.

    mongosh --port 27019

    Innerhalb der Mongo-Shell:

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

    Überprüfen Sie den Status:

    rs.status();

Schritt 2: Einrichten von Shard-Replica-Sets

Jeder Shard im Cluster ist ein Replica-Set. Wir werden zwei Shards (shard01 und shard02) einrichten, jeder mit drei Mitgliedern.

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

    # Shard 1 Member 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 Member 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 Member 3
mongod --shardsvr --replSet shard01 --dbpath /data/db/shard01-rs03 --port 27032 --bind_ip localhost --logpath /data/log/shard01/shard01-rs03.log --fork

  2. Initialisieren Sie das Shard 1 Replica Set: Verbinden Sie sich mit einer der Shard 1-Instanzen.

    mongosh --port 27030

    Innerhalb der Mongo-Shell:

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

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

    # Shard 2 Member 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 Member 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 Member 3
mongod --shardsvr --replSet shard02 --dbpath /data/db/shard02-rs03 --port 27042 --bind_ip localhost --logpath /data/log/shard02/shard02-rs03.log --fork

  4. Initialisieren Sie das Shard 2 Replica Set: Verbinden Sie sich mit einer der Shard 2-Instanzen.

    mongosh --port 27040

    Innerhalb der Mongo-Shell:

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

Schritt 3: Einrichten von mongos-Routern

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

  1. Starten Sie mongos-Instanzen: Geben Sie die Option --configdb an, die die Mitglieder des Config-Replica-Sets auflistet.

    # 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 Lastverteilung und Hochverfügbarkeit starten. Sie verbinden sich alle 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-Replica-Sets 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.

    mongosh --port 27017

  2. Shards hinzufügen: Verwenden Sie den Befehl sh.addShard(), der den Replica-Set-Namen und eines seiner Mitglieder angibt.

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

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

Sobald Shards hinzugefügt wurden, müssen Sie Sharding für bestimmte Datenbanken und dann für bestimmte Sammlungen innerhalb dieser Datenbanken aktivieren. Dies erfordert die Auswahl eines Shard-Keys.

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

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

  2. Eine Sammlung 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. Übliche Strategien sind gehashte Keys, bereichsbasierte Keys oder zusammengesetzte Keys.

    Für dieses Beispiel nehmen wir eine Sammlung mycollection mit einem Feld _id an.

    sh.shardCollection("mydatabase.mycollection", { _id: "hashed" });

    Ein gehashter _id-Shard-Key ist für ein Tutorial einfach, da er Einfügungen besser über Shards verteilt als ein monoton steigender bereichsbasierter _id-Key. Wählen Sie für eine echte Anwendung den Shard-Key basierend auf Ihren Abfragemustern und der Schreibverteilung, nicht nur aus Bequemlichkeit.

Schritt 6: Überprüfen des Clusters

Führen Sie diese Befehle von mongosh aus, das mit mongos verbunden ist:

sh.status();
db.adminCommand({ listShards: 1 });

Fügen Sie dann Beispieldokumente ein und überprüfen Sie, ob die shardierte Sammlung existiert:

use mydatabase;
db.mycollection.insertMany([
  { _id: 1, name: "alpha" },
  { _id: 2, name: "beta" },
  { _id: 3, name: "gamma" }
]);

db.mycollection.getShardDistribution();

Kleine Testdatensätze werden möglicherweise nicht sofort aufgeteilt, erwarten Sie also keine perfekte Verteilung nach nur wenigen Dokumenten. Die erste wichtige Überprüfung ist, dass sh.status() beide Shards auflistet und mydatabase.mycollection als shardiert anzeigt.

Produktionshinweise

Dieses localhost-Setup ist nützlich, um die Komponenten kennenzulernen, aber die Produktion erfordert mehr Sorgfalt:

  • Verwenden Sie echte Hostnamen, nicht localhost, da Replica-Set-Mitgliedsnamen in den Cluster-Metadaten gespeichert werden.
  • Führen Sie Konfigurationsserver als Drei-Mitglieder-Replica-Set aus.
  • Führen Sie jeden Shard als Replica-Set mit Mitgliedern aus, die über Ausfallsicherheitsdomänen verteilt sind.
  • Aktivieren Sie die Authentifizierung und interne Keyfile- oder x.509-Authentifizierung, bevor Sie den Cluster freigeben.
  • Sichern Sie die Metadaten der Konfigurationsserver und die Shard-Daten als Teil eines clusterbewussten Backup-Plans.
  • Überwachen Sie die Chunk-Verteilung, die Balancer-Aktivität, die Replikationsverzögerung und das Festplattenwachstum.

Abschließende Erkenntnisse

Ein MongoDB-Sharded-Cluster hat drei Aufgaben: Konfigurationsserver verfolgen Metadaten, Shard-Replica-Sets speichern Daten und mongos leitet den Client-Verkehr weiter. Bringen Sie diese Rollen zuerst zum Laufen, dann verbringen Sie den größten Teil Ihrer Entwurfszeit mit dem Shard-Key, da diese Wahl bestimmt, ob Ihr Cluster die Last sauber verteilt oder heiße Shards erzeugt.