So führen Sie MongoDB auf Kubernetes aus

Einführung

MongoDB ist ein universelles, dokumentenbasiertes NoSQL-Datenbankprogramm. Wie bei anderen nichtrelationalen Datenbankverwaltungssystemen konzentriert sich MongoDB auf die Skalierbarkeit und die Geschwindigkeit von Abfragen.

Kubernetes arbeitet mit MongoDB zusammen, um hochgradig skalierbare und portable Datenbankbereitstellungen zu erstellen. Diese Bereitstellungen sind nützlich, wenn Sie mit großen Datenmengen und hohen Lasten arbeiten.

In diesem Tutorial erfahren Sie, wie Sie MongoDB auf Kubernetes bereitstellen. Der Leitfaden enthält Schritte zum Ausführen einer eigenständigen MongoDB-Instanz und eines Replikatsatzes.

Anforderungen

• Ein Kubernetes-Cluster mit kubectl.
• Administrativer Zugriff auf Ihr System.

Stellen Sie eine eigenständige MongoDB-Instanz bereit

MongoDB kann auf Kubernetes als eigenständige Instanz bereitgestellt werden. Diese Bereitstellung ist für den Produktionseinsatz nicht geeignet, aber für Tests und einige Aspekte der Entwicklung geeignet.

Führen Sie die folgenden Schritte aus, um eine eigenständige MongoDB-Instanz bereitzustellen.

Schritt 1:Beschriften Sie den Knoten

Beschriften Sie den Knoten, der für die MongoDB-Bereitstellung verwendet wird. Das Label wird später verwendet, um Pods einem bestimmten Knoten zuzuweisen.

Dazu:

1. Listen Sie die Knoten in Ihrem Cluster auf:

kubectl get nodes

2. Wählen Sie den Bereitstellungsknoten aus der Liste in der Befehlsausgabe aus.

3. Verwenden Sie kubectl, um den Knoten mit einem Schlüssel-Wert-Paar zu kennzeichnen.

kubectl label nodes <node> <key>=<value>

Die Ausgabe bestätigt, dass das Label erfolgreich hinzugefügt wurde.

Schritt 2:Erstellen Sie eine Speicherklasse

StorageClass unterstützt Pods bei der Bereitstellung persistenter Volume-Ansprüche auf dem Knoten. So erstellen Sie eine StorageClass:

1. Erstellen Sie mit einem Texteditor eine YAML-Datei zum Speichern der Speicherklassenkonfiguration.

nano StorageClass.yaml

2. Geben Sie Ihre Speicherklassenkonfiguration in der Datei an. Das folgende Beispiel definiert die mongodb-storageclass :

kind: StorageClass
apiVersion: storage.k8s.io/v1
metadata:
  name: mongodb-storageclass
provisioner: kubernetes.io/no-provisioner
volumeBindingMode: WaitForFirstConsumer
allowVolumeExpansion: true

3. Speichern Sie die Änderungen und verlassen Sie den Editor.

Schritt 3:Persistenten Speicher erstellen

Stellen Sie Speicher für die MongoDB-Bereitstellung bereit, indem Sie ein persistentes Volume und einen Anspruch auf persistentes Volume erstellen:

1. Erstellen Sie eine YAML-Datei für die Konfiguration des persistenten Volumes.

nano PersistentVolume.yaml

2. Ordnen Sie in der Datei Speicher zu, der zu der im vorherigen Schritt definierten Speicherklasse gehört. Geben Sie den Knoten an, der bei der Pod-Bereitstellung in nodeAffinity verwendet wird Sektion. Der Knoten wird anhand des in Schritt 1 erstellten Labels identifiziert .

apiVersion: v1
kind: PersistentVolume
metadata:
    name: mongodb-pv
spec:
  capacity:
    storage: 2Gi
  volumeMode: Filesystem
  accessModes:
    - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  storageClassName: mongodb-storageclass
  local:
    path: /mnt/data
  nodeAffinity:
    required:
      nodeSelectorTerms:
      - matchExpressions:
        - key: size
          operator: In
          values:
            - large

3. Erstellen Sie eine weitere YAML-Datei für die Konfiguration des persistenten Volume-Claims:

nano PersistentVolumeClaim.yaml

4. Definieren Sie den Claim mit dem Namen mongodb-pvc und Kubernetes anweisen, Volumes zu beanspruchen, die zu mongodb-storageclass gehören .

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: mongodb-pvc
spec:
  storageClassName: mongodb-storageclass
  accessModes:
    - ReadWriteOnce
  volumeMode: Filesystem
  resources:
    requests:
      storage: 1Gi

Schritt 4:Erstellen Sie eine ConfigMap

Die ConfigMap-Datei speichert unverschlüsselte Konfigurationsinformationen, die von Pods verwendet werden.

1. Erstellen Sie eine YAML-Datei zum Speichern der Bereitstellungskonfiguration:

nano ConfigMap.yaml

2. Verwenden Sie die Datei, um Informationen zu Systempfaden, Benutzern und Rollen zu speichern. Das Folgende ist ein Beispiel für eine ConfigMap-Datei:

apiVersion: v1
kind: ConfigMap
metadata:
  name: mongodb-configmap
data:
  mongo.conf: |
    storage:
      dbPath: /data/db
  ensure-users.js: |
    const targetDbStr = 'test';
    const rootUser = cat('/etc/k8-test/admin/MONGO_ROOT_USERNAME');
    const rootPass = cat('/etc/k8-test/admin/MONGO_ROOT_PASSWORD');
    const usersStr = cat('/etc/k8-test/MONGO_USERS_LIST');

    const adminDb = db.getSiblingDB('admin');
    adminDb.auth(rootUser, rootPass);
    print('Successfully authenticated admin user');

    const targetDb = db.getSiblingDB(targetDbStr);

    const customRoles = adminDb
      .getRoles({rolesInfo: 1, showBuiltinRoles: false})
      .map(role => role.role)
      .filter(Boolean);

    usersStr
      .trim()
      .split(';')
      .map(s => s.split(':'))
      .forEach(user => {
        const username = user[0];
        const rolesStr = user[1];
        const password = user[2];

        if (!rolesStr || !password) {
          return;
        }

        const roles = rolesStr.split(',');
        const userDoc = {
          user: username,
          pwd: password,
        };

        userDoc.roles = roles.map(role => {
          if (!~customRoles.indexOf(role)) {
            return role;
          }
          return {role: role, db: 'admin'}; 
        });

        try {
          targetDb.createUser(userDoc);
        } catch (err) {
          if (!~err.message.toLowerCase().indexOf('duplicate')) {
            throw err;
          }
        }
      });

Schritt 5:Erstellen Sie ein StatefulSet

StatefulSet ist ein Kubernetes-Controller, der zum Bereitstellen von zustandsbehafteten Apps verwendet wird. Zustandsbehaftete App-Pods erfordern eindeutige Identitäten, da sie mit anderen Pods kommunizieren.

So erstellen Sie ein StatefulSet :

1. Verwenden Sie einen Texteditor, um eine YAML-Datei zu erstellen:

nano StatefulSet.yaml

2. Fügen Sie Bereitstellungsinformationen in die Datei ein, einschließlich des zu verwendenden MongoDB-Docker-Images. Die Datei verweist auch auf die zuvor erstellte ConfigMap und PersistentVolumeClaim :

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mongodb-test
spec:
  serviceName: mongodb-test
  replicas: 1
  selector:
    matchLabels:
      app: database
  template:
    metadata:
      labels:
        app: database
        selector: mongodb-test
    spec:
      containers:
      - name: mongodb-test
        image: mongo:4.0.8
        env:
          - name: MONGO_INITDB_ROOT_USERNAME_FILE
            value: /etc/k8-test/admin/MONGO_ROOT_USERNAME
          - name: MONGO_INITDB_ROOT_PASSWORD_FILE
            value: /etc/k8-test/admin/MONGO_ROOT_PASSWORD
        volumeMounts:
        - name: k8-test
          mountPath: /etc/k8-test
          readOnly: true
        - name: mongodb-scripts
          mountPath: /docker-entrypoint-initdb.d
          readOnly: true
        - name: mongodb-configmap
          mountPath: /config
          readOnly: true
        - name: mongodb-data
          mountPath: /data/db
      nodeSelector:
        size: large
      volumes:
      - name: k8-test
        secret:
          secretName: mongodb-secret
          items:
          - key: MONGO_ROOT_USERNAME
            path: admin/MONGO_ROOT_USERNAME
            mode: 0444
          - key: MONGO_ROOT_PASSWORD
            path: admin/MONGO_ROOT_PASSWORD
            mode: 0444
          - key: MONGO_USERNAME
            path: MONGO_USERNAME
            mode: 0444
          - key: MONGO_PASSWORD
            path: MONGO_PASSWORD
            mode: 0444
          - key: MONGO_USERS_LIST
            path: MONGO_USERS_LIST
            mode: 0444
      - name: mongodb-scripts
        configMap:
          name: mongodb-configmap
          items:
          - key: ensure-users.js
            path: ensure-users.js
      - name: mongodb-configmap
        configMap:
          name: mongodb-configmap
          items:
          - key: mongo.conf
            path: mongo.conf
      - name: mongodb-data
        persistentVolumeClaim:
          claimName: mongodb-pvc

Schritt 6:Erstellen Sie ein Geheimnis

Das Secret-Objekt wird verwendet, um vertrauliche Informationen über die Bereitstellung zu speichern.

1. Erstellen Sie mit Ihrem Texteditor eine geheime YAML-Datei.

nano Secret.yaml

2. Geben Sie Informationen für den Zugriff auf die MongoDB-Datenbank an.

apiVersion: v1
kind: Secret
metadata:
  name: mongodb-secret
type: Opaque
data:
  MONGO_ROOT_USERNAME: YWRtaW4K
  MONGO_ROOT_PASSWORD: cGFzc3dvcmQK
  MONGO_USERNAME: dGVzdAo=
  MONGO_PASSWORD: cGFzc3dvcmQK
  MONGO_USERS_LIST: dGVzdDpkYkFkbWluLHJlYWRXcml0ZTpwYXNzd29yZAo=

3. Speichern Sie die Änderungen und beenden Sie.

Schritt 7:Erstellen Sie einen MongoDB-Dienst

So erstellen Sie einen MongoDB-Dienst:

1. Erstellen Sie ein Headless-Service-Objekt.

nano Service.yaml

Der Headless-Dienst ermöglicht es Benutzern, sich direkt mit Pods zu verbinden.

2. Fügen Sie den Dienstnamen und die Definition in der YAML-Datei hinzu.

apiVersion: v1
kind: Service
metadata:
  name: mongodb-test
  labels:
    app: database
spec:
  clusterIP: None
  selector:
    app: database

3. Speichern Sie die Änderungen und beenden Sie die Datei.

Schritt 8:Wenden Sie die MongoDB-Konfiguration mit Kustomize an

Verwenden Sie Kustomize, um die MongoDB-Konfigurationsdateien einfach anzuwenden:

1. Erstellen Sie eine kustomization.yaml Datei:

nano kustomization.yaml

2. In den resources Listen Sie im Abschnitt alle YAML-Dateien auf, die in den vorherigen Schritten erstellt wurden:

apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

resources:
  - ConfigMap.yaml
  - PersistentVolumeClaim.yaml
  - PersistentVolume.yaml
  - Secret.yaml
  - Service.yaml
  - StatefulSet.yaml
  - StorageClass.yaml

Speichern Sie die Datei im selben Verzeichnis wie die anderen Dateien.

3. Stellen Sie MongoDB mit dem folgenden Befehl bereit:

kubectl apply -k .

4. Verwenden Sie kubectl, um zu prüfen, ob der Pod bereit ist.

kubectl get pod

Wenn der Pod 1/1 anzeigt in READY Spalte, fahren Sie mit dem nächsten Schritt fort.

Schritt 9:Verbindung zur eigenständigen MongoDB-Instanz herstellen

1. Stellen Sie mit dem folgenden kubectl-Befehl eine Verbindung zum MongoDB-Pod her:

kubectl exec -it mongodb-test-0 -- sh

2. Wenn # Eingabeaufforderung erscheint, geben Sie ein:

mongo

MongoDB-Shell wird geladen.

3. Wechseln Sie zur Testdatenbank:

use test

4. Authentifizieren Sie sich mit dem folgenden Befehl:

db.auth('[username]','[password]')

Zahl 1 in der Ausgabe bestätigt die erfolgreiche Authentifizierung.

Stellen Sie ein ReplicaSet bereit

MongoDB als ReplicaSet bereitstellen stellt sicher, dass die angegebene Anzahl von Pods zu einem bestimmten Zeitpunkt ausgeführt wird. ReplicaSet-Bereitstellungen werden für Produktionsumgebungen empfohlen.

Schritt 1:Rollenbasierte Zugriffskontrolle (RBAC) einrichten

Die Aktivierung der rollenbasierten Zugriffssteuerung ist eine der Best Practices für die Kubernetes-Sicherheit. RBAC stellt sicher, dass kein Benutzer mehr Berechtigungen als nötig hat.

So richten Sie RBAC ein:

1. Erstellen Sie eine YAML-Datei mit einem Texteditor.

nano rbac.yaml

2. Geben Sie Zugriffsregeln für Ihre MongoDB-Bereitstellung an. Das folgende Beispiel zeigt eine RBAC-YAML-Datei:

apiVersion: v1
kind: ServiceAccount
metadata:
  name: mongo-account
  namespace: default
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: mongo-role
rules:
- apiGroups: [""]
  resources: ["configmaps"]
  verbs: ["*"]
- apiGroups: [""]
  resources: ["deployments"]
  verbs: ["list", "watch"]
- apiGroups: [""]
  resources: ["services"]
  verbs: ["*"]
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get","list", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: mongo_role_binding
subjects:
- kind: ServiceAccount
  name: mongo-account
  namespace: default
roleRef:
  kind: ClusterRole
  name: mongo-role
  apiGroup: rbac.authorization.k8s.io

3. Speichern Sie die Datei und wenden Sie sie mit kubectl an:

kubectl apply -f rbac.yaml

Schritt 2:Erstellen Sie eine StatefulSet-Bereitstellung

1. Erstellen Sie eine StatefulSet-Bereitstellungs-YAML:

nano StatefulSet.yaml

2. Geben Sie die Anzahl der Replikate in der Datei und das zu verwendende MongoDB-Docker-Image an und stellen Sie eine Volume-Claim-Vorlage für die Bereitstellung dynamischer Volumes bereit:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mongodb-replica
  namespace: default
spec:
  serviceName: mongo
  replicas: 2
  selector:
    matchLabels:
      app: mongo
  template:
    metadata:
      labels:
        app: mongo
        selector: mongo
    spec:
      terminationGracePeriodSeconds: 30
      serviceAccount: mongo-account
      containers:
      - name: mongodb
        image: docker.io/mongo:4.2
        env:
        command: ["/bin/sh"]
        args: ["-c", "mongod --replSet=rs0 --bind_ip_all"]
        resources:
          limits:
            cpu: 1
            memory: 1500Mi
          requests:
            cpu: 1
            memory: 1000Mi
        ports:
        - name: mongo-port
          containerPort: 27017
        volumeMounts:
        - name: mongo-data
          mountPath: /data/db
  volumeClaimTemplates:
  - metadata:
      name: mongo-data
    spec:
      accessModes:
        - ReadWriteOnce
      resources:
        requests:
          storage: 10Gi

3. Speichern Sie die Datei und verwenden Sie kubectl apply, um eine Bereitstellung zu erstellen:

kubectl apply -f StatefulSet.yaml

Schritt 3:Erstellen Sie einen Headless-Dienst

So erstellen Sie einen kopflosen Dienst:

1. Erstellen Sie eine Dienst-YAML-Datei:

nano Service.yaml

2. Definieren Sie einen Dienst, der die direkte Kommunikation mit Pods ermöglicht:

apiVersion: v1
kind: Service
metadata:
  name: mongo
  namespace: default
  labels:
    name: mongo
spec:
  ports:
    - port: 27017
      targetPort: 27017
  clusterIP: None
  selector:
    app: mongo

3. Wenden Sie YAML mit kubectl an.

kubectl apply -f Service.yaml

Schritt 4:Replikationshost einrichten

So richten Sie die Pod-Replikation ein:

1. Geben Sie den Pod mit kubectl exec ein :

kubectl exec -it mongodb-replica-0 -n default -- mongo

Die Willkommensnachricht der MongoDB-Shell wird angezeigt.

2. Starten Sie die Replikation, indem Sie den folgenden Befehl an der Eingabeaufforderung der MongoDB-Shell eingeben:

rs.initiate()

Das "ok" : 1 Linie zeigt an, dass die Initiierung erfolgreich war.

3. Definieren Sie die Variable namens cfg . Die Variable führt rs.conf() aus .

var cfg = rs.conf()

4. Verwenden Sie die Variable, um den primären Server zur Konfiguration hinzuzufügen:

cfg.members[0].host="mongodb-replica-0.mongo:27017"

Die Ausgabe zeigt den Namen des primären Servers.

5. Bestätigen Sie die Konfiguration, indem Sie den folgenden Befehl ausführen:

rs.reconfig(cfg)

Das "ok" : 1 Zeile bestätigt die erfolgreiche Konfiguration.

6. Verwenden Sie rs.add() Befehl, um einen weiteren Pod zur Konfiguration hinzuzufügen.

rs.add("mongodb-replica-1.mongo:27017")

Die Ausgabe zeigt, dass das Replikat hinzugefügt wurde.

7. Überprüfen Sie den Status des Systems, indem Sie Folgendes eingeben:

rs.status()

Die "members" Abschnitt sollte zwei Repliken zeigen. Das primäre Replikat wird oben in der Ausgabe aufgeführt.

Das sekundäre Replikat befindet sich unter dem primären Replikat.

Die ReplicaSet-Bereitstellung von MongoDB ist eingerichtet und betriebsbereit.