Bereitstellen und Konfigurieren von MongoDB-Shards mit Ansible

Datenbanksysteme funktionieren besser, wenn die Arbeitslast auf mehrere laufende Instanzen verteilt ist bzw. Daten einfach kategorisiert werden. MongoDB verwendet Sharding, sodass Daten in einer bestimmten Datenbank nach einem bestimmten Schlüssel gruppiert werden. Sharding verbessert die horizontale Skalierung, was folglich zu besserer Leistung und erhöhter Zuverlässigkeit führt. Im Allgemeinen bietet MongoDB horizontale und vertikale Skalierung im Gegensatz zu SQL-DBMS, z. B. MySQL, das nur vertikale Skalierung fördert.

MongoDB hat ein lockereres Konsistenzmodell, bei dem ein Dokument in einer Sammlung einen zusätzlichen Schlüssel haben kann, der in anderen Dokumenten in derselben Sammlung fehlen würde.

Sharding

Beim Sharding werden Daten im Grunde in separate Chunks partitioniert und dann eine Reihe von Chunks für verschiedene Shard-Server definiert. Zur Gruppierung der Daten wird ein Shard-Schlüssel verwendet, bei dem es sich häufig um ein Feld handelt, das in allen Dokumenten in der zu fragmentierenden Datenbank vorhanden ist. Sharding arbeitet Hand in Hand mit der Replikation, um den Lesedurchsatz zu beschleunigen, indem eine verteilte Arbeitslast auf eine Reihe von Servern sichergestellt wird, anstatt von einem einzelnen Server abhängig zu sein. Außerdem stellt die Replikation sicher, dass Kopien der geschriebenen Daten verfügbar sind.

Angenommen, wir haben 120 Dokumente in einer Sammlung. Diese Daten können so aufgeteilt werden, dass wir 3 Replikatsätze mit jeweils 40 Dokumenten haben, wie in der folgenden Konfiguration dargestellt. Wenn zwei Clients Anfragen senden, einer zum Abrufen eines Dokuments mit Index 35 und der andere mit Index 92, wird die Anfrage vom Abfragerouter (einem Mongos-Prozess) empfangen, der wiederum den Konfigurationsknoten kontaktiert, der Aufzeichnungen darüber führt wie die Chunk-Bereiche auf die Shards verteilt werden. Wenn die angegebene Dokumentidentität gefunden wird, wird sie vom zugehörigen Shard abgerufen. Zum Beispiel oben wird das Dokument des ersten Clients von Shard A abgerufen und für Client B wird das Dokument von Shard C abgerufen. Im Allgemeinen gibt es eine verteilte Arbeitslast, die als horizontale Skalierung definiert ist.

Wenn für die angegebenen Shards die Größe einer Sammlung in einem Shard die chunk_size überschreitet, wird die Sammlung mithilfe des definierten Shard-Schlüssels automatisch aufgeteilt und auf die Shards verteilt. Im Bereitstellungs-Setup benötigen wir für das unten stehende Beispiel 3 Replikat-Sets mit jeweils einem primären und einigen sekundären. Die primären Knoten fungieren auch als Sharding-Server.

Die empfohlene Mindestkonfiguration für eine MongoDB-Produktionsbereitstellung besteht aus mindestens drei Shard-Servern mit jeweils einem Replikatsatz. Für die beste Leistung werden die Mongos-Server auf separaten Servern bereitgestellt, während die Konfigurationsknoten in die Shards integriert sind.

MongoDB-Shards mit Ansible bereitstellen

Das separate Konfigurieren von Shards und Replikatsätzen eines Clusters ist ein umständliches Unterfangen, daher lösen wir uns auf einfache Tools wie Ansible, um die erforderlichen Ergebnisse mit viel Leichtigkeit zu erzielen. Playbooks werden verwendet, um die erforderlichen Konfigurationen und Aufgaben zu schreiben, die die Ansible-Software ausführen wird.

Der systematische Playbook-Prozess sollte wie folgt aussehen:

Mongo-Basispakete installieren (kein Server, Pymongo und Befehlszeilenschnittstelle)
Mongodb-Server installieren. Folgen Sie dieser Anleitung, um loszulegen.
Richten Sie Mongod-Instanzen und die entsprechenden Replikat-Sets ein.
Konfiguriere und richte die Konfigurationsserver ein
Konfigurieren und richten Sie den Mongos-Routingdienst ein.
Fügen Sie die Shards zu Ihrem Cluster hinzu.

Das Playbook der obersten Ebene sollte so aussehen

- name: install mongo base packages include: mongod.yml
  tags: - mongod

- name: configure config server
  include: configServer.yml
  when: inventory_hostname in groups['mongoc-servers'] 
  tags:
  - cs

- name: configure mongos server
  include: configMongos.yml
  when: inventory_hostname in groups['mongos-server'] tags:
  - mongos

- name: add shards
  include: addShards.yml
  when: inventory_hostname in groups['mongos-servers'] 
  tags:
  - mongos
  - shards

Wir können die obige Datei als mongodbCluster.yml speichern.

Multiplenines Become a MongoDB DBA – Bringing MongoDB to ProductionErfahren Sie, was Sie wissen müssen, um MongoDBDownload for Free bereitzustellen, zu überwachen, zu verwalten und zu skalieren

Eine einfache mongodb.yml-Datei sieht folgendermaßen aus:

---
- hosts: ansible-test
  remote_user: root
  become: yes
  tasks:
  - name: Import the public key used by the package management system
    apt_key: keyserver=hkp://keyserver.ubuntu.com:80 id=7F0CEB10 state=present
  - name: Add MongoDB repository
    apt_repository: repo='deb <a class="vglnk" href="https://downloads-distro.mongodb.org/repo/ubuntu-upstart" rel="nofollow"><span>http</span><span>://</span><span>downloads</span><span>-</span><span>distro</span><span>.</span><span>mongodb</span><span>.</span><span>org</span><span>/</span><span>repo</span><span>/</span><span>ubuntu</span><span>-</span><span>upstart</span></a> dist 10gen' state=present
  - name: install mongodb
    apt: pkg=mongodb-org state=latest update_cache=yes
    notify:
    - start mongodb
  handlers:
    - name: start mongodb
      service: name=mongod state=started

Zu den allgemeinen Parametern, die bei der Bereitstellung eines Replikatsatzes erforderlich sind, benötigen wir diese beiden weiteren, um die Shards hinzuzufügen.

Scherbe: standardmäßig ist es null. Dies ist eine Shard-Verbindungszeichenfolge, die das Format /host:port haben sollte. Beispiel:replica0/siteurl1.com:27017
Zustand: standardmäßig ist der Wert vorhanden, was vorschreibt, dass der Shard vorhanden sein sollte, andernfalls kann man ihn auf abwesend setzen.

Nachdem Sie einen Replikatsatz wie in diesem Blog erklärt bereitgestellt haben, können Sie mit dem Hinzufügen der Shards fortfahren.

# add a replicaset shard named replica0 with a member running on port 27017 on mongodb0.example.net
- mongodb_shard:
    login_user: admin
    login_password: root
    shard: "replica0/mongodb1.example.net:27017"
    state: present

# add a standalone mongod shard running on port 27018 of mongodb2.example.net
- mongodb_shard:
    login_user: admin
    login_password: root
    shard: "mongodb2.example.net:27018"
    state: present

# Single node shard running on localhost
- name: Ensure shard replica0 exists
  mongodb_shard:
    login_user: admin
    login_password: root
    shard: "replica0/localhost:3001"
    state: present

# Single node shard running on localhost
- name: Ensure shard replica0 exists
  mongodb_shard:
    login_user: admin
    login_password: root
    shard: "replica0/localhost:3002"
    state: present

Nachdem wir all diese Konfigurationen eingerichtet haben, führen wir das Playbook mit dem Befehl

aus

ansible-playbook -i hosts mongodbCluster.yml

Sobald das Playbook abgeschlossen ist, können wir uns bei einem der Mongos-Server anmelden und den Befehl sh.status() ausgeben. Wenn die Ausgabe in etwa so aussieht wie unten, wurden die Shards bereitgestellt. Außerdem können Sie den Schlüssel mongodb_shard sehen, wenn er erfolgreich bewertet wurde.

mongos> sh.status()
    --- Sharding Status --- 
      sharding version: { "_id" : 1, "version" : 3 }
      shards:
        {  "_id" : "shardA",  "host" : "locahhost1/web2:2017,locahhost3:2017" }
        {  "_id" : "shardB",  "host" : "locahhost3/web2:2018,locahhost3:2019" }
{  "_id" : "shardC",  "host" : "locahhost3/web2:2019,locahhost3:2019" }

    databases:
        {  "_id" : "admin",  "partitioned" : false,  "primary" : "config" }

So entfernen Sie einen Shard namens „replica0“

- mongodb_shard:
    login_user: admin
    login_password: root
    shard: replica0
    state: absent

Schlussfolgerung

Ansible hat eine wichtige Rolle bei der Vereinfachung des Bereitstellungsprozesses gespielt, da wir nur die Aufgaben definieren müssen, die ausgeführt werden müssen. Stellen Sie sich zum Beispiel vor, Sie hätten 40 Replikat-Set-Mitglieder und Sie müssten jedem Shards hinzufügen. Den normalen Weg zu gehen, wird ewig dauern und ist anfällig für viele menschliche Fehler. Mit Ansible definieren Sie diese Aufgaben einfach in einer einfachen Datei namens Playbook und Ansible kümmert sich um die Aufgaben, wenn die Datei ausgeführt wird.