Wie man eine MongoDB Kubernetes Installation durchführt

Die Bereitstellung von Anwendungen in Kubernetes kann eine Herausforderung sein, insbesondere für zustandsbehaftete Anwendungen wie MongoDB in einem Kubernetes-Cluster. Wie können Sie die Bereitstellung erleichtern? Lassen Sie den MongoDB Kubernetes Operator automatisch zustandsbehaftete Anwendungen in Ihrem Kubernetes-Cluster bereitstellen und verwalten.

In diesem Tutorial lernen Sie, wie Sie MongoDB mit dem MongoDB Kubernetes Operator in Kubernetes bereitstellen.

Lesen Sie weiter und beginnen Sie mit der Automatisierung Ihrer Kubernetes-Bereitstellungen!

Voraussetzungen

Dieses Tutorial wird eine praktische Demonstration sein. Um mitzumachen, stellen Sie sicher, dass Sie die folgenden Anforderungen erfüllen:

• A Kubernetes cluster – This demo uses the Kubernetes cluster v1.23.

Verwandt:So erstellen Sie einen Kubernetes-Cluster mit dem AWS EKS CLI

• Kubectl installiert auf dem lokalen Rechner.

• MongoDB Compass installiert auf dem lokalen Rechner.

• Git installiert auf Ihrem Rechner.

• jq JSON-Parser installiert auf dem lokalen Rechner.

Erstellen Sie einen Namespace für MongoDB

Beim Bereitstellen von Anwendungen in Kubernetes wird immer empfohlen, einen spezifischen Namespace für Ihre Projekte zu erstellen.

Namespaces erleichtern die Verwaltung von Kubernetes-Ressourcen für Administratoren und verhindern Namenskollisionen. Gleichzeitig verhindert das Erstellen von Namespaces eine falsche Verwendung von Ressourcen in der Kubernetes-Umgebung.

Öffnen Sie Ihr Terminal und führen Sie den Befehl kubectl create aus, um einen neuen Namespace (ns) mit dem Namen mongodb auf Ihrem Kubernetes-Cluster zu erstellen.

kubectl create ns mongodb

Führen Sie nun den unten stehenden Befehl kubectl get aus, um die Liste der Namespaces auf Ihrem Kubernetes-Cluster zu überprüfen.

kubectl get ns

Sie sehen einen neuen Namespace namens mongodb, der auf Ihrem Cluster verfügbar ist, wie unten gezeigt.

Verwandt:Wie man einen Docker MongoDB-Container bereitstellt und verwaltet

Herunterladen des MongoDB Kubernetes Operators

Nachdem Sie einen Namespace erstellt haben, ist es an der Zeit, den MongoDB Kubernetes Operator herunterzuladen. Der MongoDB Kubernetes Operator ist eine Reihe von Kubernetes-Operatoren. Diese Kubernetes-Operatoren bieten automatische Bereitstellung, Konfiguration und Verwaltung von MongoDB Community in der Kubernetes-Umgebung.

Führen Sie den folgenden git-Befehl aus, um das MongoDB Kubernetes Operator-Projekt auf Ihren lokalen Computer zu clonen.

git clone <https://github.com/mongodb/mongodb-kubernetes-operator.git>

Führen Sie nun jeden der folgenden Befehle aus, um Ihr aktuelles Arbeitsverzeichnis in das Verzeichnis mongodb-kubernetes-operator zu ändern und alle verfügbaren Dateien und Verzeichnisse aufzulisten (ls).

# Ändere das Arbeitsverzeichnis zu mongodb-kubernetes-operator
cd mongodb-kubernetes-operator/

# Liste der Dateien und Verzeichnisse
ls

Sie sehen ein Unterverzeichnis namens „config“ innerhalb des Projektverzeichnisses ~/mongodb-kubernetes-operator, wie unten gezeigt. Das Unterverzeichnis config enthält Beispiele von YAML-Dateien zur Bereitstellung von MongoDB in Kubernetes.

Bereitstellung des MongoDB Operators

Jetzt, da Ihr benutzerdefinierter Namespace und der MongoDB Kubernetes Operator eingerichtet sind, sind Sie bereit, den MongoDB Operator in Ihrem Kubernetes-Cluster bereitzustellen. Wie? Sie verwenden die Konfiguration aus dem Verzeichnis config.

Der MongoDB Operator verwaltet den Lebenszyklus Ihrer MongoDB-Bereitstellung im Kubernetes-Cluster. Der Operator erstellt, verwaltet und skaliert automatisch den Zustand Ihrer MongoDB-Bereitstellung.

Um den MongoDB-Operator bereitzustellen, müssen Sie eine Kubernetes-Custom-Ressourcendefinition (CRD) und den Controller erstellen. Die Kubernetes-CRD ist erweiterbar für die Kubernetes-API, sodass Sie benutzerdefinierte Ressourcen in Kubernetes erstellen können.

1. Führen Sie den Befehl kubectl apply aus, um eine neue Kubernetes-CRD für die Bereitstellung von MongoDB zu erstellen.

Der Kubernetes-Operator ersetzt alle menschlichen Interaktionen zur Bereitstellung einer Anwendung auf Kubernetes. Der Operator ist ein Pod-Controller, der Ihre zustandsbehaftete Anwendung auf Kubernetes automatisch bereitstellt und verwaltet.

kubectl apply -f config/crd/bases/mongodbcommunity.mongodb.com_mongodbcommunity.yaml

2. Führen Sie anschließend den folgenden kubectl get-Befehl aus, um die Liste der verfügbaren crd in Ihrem Kubernetes zu überprüfen.

kubectl get crd/mongodbcommunity.mongodbcommunity.mongodb.com

Unten sehen Sie die CRD mit dem Namen mongodbcommunity.mongodbcommunity.mongodb.org.

3. Führen Sie den untenstehenden Befehl aus, um eine neue benutzerdefinierte Rollenbasierte Zugriffskontrolle (RBAC) für den MongoDB-Operator zu erstellen und implementieren Sie RBAC in den Namespace mongodb.

Dieser Befehl erstellt eine neue Rolle, Rollenbindung und Servicekonto für den MongoDB-Operator, die benutzerdefinierte Berechtigungen in Ihrem Kubernetes-Cluster sind. Diese benutzerdefinierten Berechtigungen sind erforderlich, um MongoDB automatisch bereitzustellen und zu verwalten.

kubectl apply -k config/rbac/ -n mongodb

4. Führen Sie nun jeden kubectl-Befehl unten aus, um die Rolle, Rollenbindung und das Servicekonto für den MongoDB-Operator zu überprüfen.

# Überprüfen der Rollenliste
kubectl get role mongodb-kubernetes-operator -n mongodb

# Überprüfen der Rollenbindungliste
kubectl get rolebinding mongodb-kubernetes-operator -n mongodb

# Überprüfen des Servicekontos
kubectl get serviceaccount mongodb-kubernetes-operator -n mongodb

Die Ausgabe unten zeigt, dass die Rolle, Rollenbindung und das Servicekonto mongodb-kubernetes-operator im Namespace mongodb erstellt wurden.

5. Sobald die Überprüfung abgeschlossen ist, führen Sie den kubectl-Befehl unten aus, um den MongoDB-Operator im Namespace mongodb bereitzustellen.

Dieser Befehl erstellt einen neuen Pod (mongodb-kubernetes-operator) mit dem Basis-Docker-Image (quay.io/mongodb/mongodb-kubernetes-operator). Dieser Pod wird als Controller fungieren, um MongoDB ReplicaSets automatisch im Kubernetes-Cluster bereitzustellen.

kubectl create -f config/manager/manager.yaml -n mongodb

Unten sehen Sie, dass die Bereitstellung des MongoDB-Operators erstellt wurde, aber der Pod sich noch initialisiert.

6. Führen Sie abschließend die folgenden Befehle aus, um die Bereitstellung und Pods im Namespace mongodb zu überprüfen.

# Überprüfen der Bereitstellung im mongodb-Namespace
kubectl get deployment.apps -n mongodb

# Überprüfen der Pods im mongodb-Namespace
kubectl get pods -n mongodb

Wie unten zu sehen ist, läuft der MongoDB Operator-Pod.

Deploying MongoDB ReplicaSet to Kubernetes

Nach Ihrer MongoDB-Bereitstellung werden Sie ReplicaSet auf Ihrem Kubernetes bereitstellen, um hohe Verfügbarkeit und Redundanz für Ihre MongoDB-Bereitstellung zu gewährleisten. Sie möchten keine Ausfallzeiten in Ihrer Bereitstellung haben.

Die Bereitstellung von MongoDB ReplicaSets mithilfe des MongoDB Kubernetes Operators ist standardmäßig sicher und verwendet die SCRAM-Authentifizierung für Benutzer. Gleichzeitig können Sie eine TLS-sichere Verbindung für Benutzer- und Anwendungsverbindungen verwenden und Prometheus-Metriken zur Überwachung von Ressourcen freigeben.

Verwandt: Einstieg in die Überwachung von Grafana & Prometheus Kubernetes-Cluster

Im Verzeichnis config/samples/ finden Sie mehrere Beispiele von YAML-Dateien für die Bereitstellung von ReplicaSet. Jede Datei kann in verschiedenen Bereitstellungsszenarien verwendet werden, aber die Standarddatei für die ReplicaSet-Bereitstellung ist mongodb.com_v1_mongodbcommunity_cr.yaml.

1. Bearbeiten Sie die YAML-Datei für Ihre Bereitstellung mit Ihrem bevorzugten Editor. In diesem Beispiel wird die Datei /mongodb.com_v1_hostpath.yaml für die lokale Bereitstellung verwendet. Diese YAML-Datei befindet sich im Verzeichnis config/samples/arbitrary_statefulset_configuration/.

Wenn Sie den MongoDB Kubernetes Operator auf Cloud-Diensten wie GKE und AKS bereitstellen, verwenden Sie die YAML-Datei mongodb.com_v1_mongodbcommunity_cr.yaml. Wenn Sie jedoch lokal in Kind oder Minikube bereitstellen, können Sie die benutzerdefinierte YAML-Datei (arbitrary_statefulset_configuration/mongodb.com_v1_hostpath.yaml) verwenden, die automatisch benutzerdefinierte PV und PVC für MongoDB ReplicaSet-Pods erstellt.

Ändern Sie unten die Anzahl (Mitglieder) der ReplicaSets, die Sie je nach Umgebung bereitstellen möchten. Standardmäßig sind es 3. In diesem Tutorial ist die Anzahl der ReplicaSets auf 2 festgelegt.

spec:
  members: 2 # Anzahl der zu erstellenden ReplicaSets
  security:
    authentication:
      modes:
      - SCRAM
  statefulSet:

Ersetzen Sie <your-password-here> durch Ihr starkes Passwort. Sie verwenden dieses Passwort, um sich bei der MongoDB-Datenbank anzumelden, und standardmäßig verwenden Sie die SCRAM-Authentifizierung.

Speichern Sie die Änderungen und schließen Sie den Editor, wenn Sie mit dem Passwort zufrieden sind.

---
apiVersion: v1
kind: Secret
metadata:
  name: my-user-password
type: Opaque
stringData:
  password: <your-password-here> # Passwort für MongoDB-Administrator festlegen

Verwandt:Wie Sie die Kontrolle über Ihre MongoDB-Sicherheit übernehmen

2. Führen Sie anschließend den folgenden kubectl-Befehl aus, um das MongoDB ReplicaSet mithilfe der mongodb.com_v1_hostpath.yaml in den Namespace mongodb zu bereitstellen.

Dieser Befehl erstellt Folgendes:

• A new custom resource (MongoDBCommunity) with the name mdb0 under the mongodbcommunity.mongodb.com/v1 CRD

• Kubernetes Secrets zum Speichern von MongoDB-Benutzerpasswörtern. Gleichzeitig werden einige PVs und PVCs mit dem Typ hostPath für das MongoDB Replica Set erstellt.

Die Bereitstellung wird einige Zeit dauern, abhängig von der Größe der zu erstellenden ReplicaSets und dem Kubernetes-Cluster selbst.

kubectl apply -f config/samples/arbitrary_statefulset_configuration/mongodb.com_v1_hostpath.yaml -n mongodb

3. Nach der Bereitstellung führen Sie jeden der folgenden Befehle aus, um die benutzerdefinierten Ressourcen und Pods im Namespace mongodb zu überprüfen.

# Überprüfen des MongoDBCommunity CRD
kubectl get mongodbcommunity -n mongodb

# Überprüfen der Pods im Namespace mongodb
kubectl get pods -n mongodb

Die Ausgabe unten zeigt Folgendes:

• Die benutzerdefinierte Ressource MongoDBCommunity mit dem Namen mdb0 wird mit MongoDB v4.4.0 ausgeführt.

• Die beiden MongoDB ReplicaSet-Pods werden mit dem Namen mdb0-0 und mdb0-1 ausgeführt. Jeder Pod enthält zwei verschiedene Container, den mongod- und den mongodb-agent-Container.

4. Führen Sie abschließend einen weiteren kubectl-Befehl aus, um die pv und pvc im Namespace mongodb zu überprüfen.

kubectl get pv,pvc -n mongodb

Die Ausgabe unten zeigt Ihnen einige pv und pvc, die von den MongoDB ReplicaSet-Pods verwendet werden.

Erstellen eines neuen Benutzers und einer Datenbank für die MongoDB-Bereitstellung

Sie haben die Bereitstellung des MongoDB-Operators und der ReplicaSets in Ihrem Kubernetes-Cluster zu diesem Zeitpunkt abgeschlossen. Der nächste Schritt besteht darin, eine neue MongoDB-Datenbank und einen Benutzer für Ihre Anwendung zu erstellen.

Sie werden ein neues Kubernetes-Secret für den neuen Benutzer erstellen, die benutzerdefinierte Ressource des ReplicaSet-Bereitstellung bearbeiten und das ReplicaSet in Ihrem Cluster aktualisieren.

1. Erstellen Sie eine neue YAML-Datei mit Ihrem bevorzugten Editor und füllen Sie das folgende Kubernetes-Geheimnis aus. Sie können die YAML-Datei nach Belieben benennen, aber in diesem Tutorial heißt die Datei new-user.yaml.

Diese YAML-Datei erstellt ein neues Kubernetes-Geheimnis mit dem Namen myappdata und dem Passwort myapppassword.

---
apiVersion: v1
kind: Secret
metadata:
  name: myappdata # Name des Geheimnisses meta.data
type: Opaque
stringData:
  password: myapppassword # Passwort für den neuen Benutzer

2. Führen Sie anschließend den Befehl kubectl unten aus, um die Konfiguration new-user.yaml auszuführen.

Dieser Befehl erstellt und wendet ein neues Kubernetes-Geheimnis auf Ihrem Cluster an und wendet dieses Geheimnis auf den Namespace mongodb an.

kubectl apply -f new-user.yaml -n mongodb

3. Bearbeiten Sie die YAML-Datei Ihrer ReplicaSet CRD-Konfiguration (mongodb.com_v1_hostpath.yaml) im Verzeichnis config/samples/arbitrary_statefulset_configuration

Fügen Sie der Datei mongodb.com_v1_hostpath.yaml die folgende Konfiguration hinzu, die die Datenbank und den Benutzer für MongoDB erstellt.

Stellen Sie sicher, dass Sie scram-secret-myapp durch Ihre eigenen scram-Anmeldeinformationen ersetzen, speichern Sie die Änderungen an der Datei und schließen Sie den Editor.

    - name: appuser # Neuer Benutzer appuser
      db: admin # Ermöglicht die Authentifizierung für die Datenbank admin
      passwordSecretRef:
        name: myappdata # Das Kubernetes-Geheimnis
      roles:
        - name: dbAdmin # Rolle dbAdmin einrichten
          db: appdb1 # für die appdb1
      scramCredentialsSecretName: scram-secret-myapp

4. Führen Sie nun den untenstehenden Befehl aus, um die neuen Änderungen, die Sie in der Datei mongodb.com_v1_hostpath.yaml in Schritt drei vorgenommen haben, anzuwenden.

kubectl apply -f config/samples/arbitrary_statefulset_configuration/mongodb.com_v1_hostpath.yaml -n mongodb

5. Führen Sie abschließend jeden der untenstehenden Befehle aus, um die detaillierten MongoDB-Verbindungen für Ihre Anwendung zu generieren. Diese Befehle generieren die detaillierten MongoDB-Verbindungen für Ihre Anwendungen im JSON-Format und analysieren die Ausgabe mithilfe des Befehlszeilenprogramms jq.

Ersetzen Sie mdb0-admin-mongoadmin durch Ihre Umgebungsdetails wie folgt:

• mdb0 – Der Metadatenname der MongoDB-Ressourcen.

• admin – Die zu authentifizierende Datenbank.

• mongoadmin – Der Benutzer, den Sie zur Authentifizierung verwenden werden.

# Abrufen von Administratorauthentifizierungsdetails und Verbindungen
kubectl get secrets mdb0-admin-mongoadmin -n mongodb -o json | jq -r '.data | with_entries(.value |= @base64d)'

# Abrufen von Appuser-Authentifizierungsdetails und Verbindungen
kubectl get secrets mdb0-admin-appuser -n mongodb -o json | jq -r '.data | with_entries(.value |= @base64d)'

Die Ausgabe unten zeigt Ihnen, wie Sie eine Verbindung zu MongoDB über die Standard- und StandardSrv-Verbindungen herstellen können. Sie sehen auch den Benutzernamen und das Passwort Ihrer MongoDB-Bereitstellung.

Verbindung zur MongoDB-Bereitstellung herstellen

Sie haben MongoDB erfolgreich auf dem Kubernetes-Cluster mithilfe des MongoDB Kubernetes Operators bereitgestellt. Aber wie wissen Sie, ob die Bereitstellung funktioniert? Sie werden die Verbindung der lokalen Datenbank und des Benutzers zu MongoDB im Kubernetes-Cluster überprüfen.

Um die Verbindung zu Ihrer MongoDB-Bereitstellung zu überprüfen, verwenden Sie Portweiterleitung. Portweiterleitung in Kubernetes ermöglicht es Ihnen, einen Weiterleitungsport von einem beliebigen Kubernetes-Dienst zu Ihrem lokalen Port zu erstellen.

1. Führen Sie den folgenden kubectl-Befehl aus, um die Liste der Dienste (svc) im Namespace mongodb abzurufen (-n).

kubectl get svc -n mongodb

Unten sehen Sie den Dienst namens mdb0-svc, der den Port 27017 (Standardport von MongoDB) öffnet.

2. Führen Sie anschließend den folgenden Befehl aus, um eine Portweiterleitung zum Kubernetes-Cluster zu erstellen.

Dieser Befehl erstellt eine neue Portweiterleitung auf dem Kubernetes-Dienst (mdb0-svc) und leitet den lokalen Port 27017 zum Kubernetes-Dienstport 27017 weiter.

kubectl port-forward service/mdb0-svc -n mongodb 27017:27017

3. Öffnen Sie schließlich Ihre MongoDB Compass-Anwendung auf Ihrem lokalen Rechner, fügen Sie eine neue Verbindung im folgenden Format hinzu und klicken Sie auf Verbinden, um eine Verbindung zu MongoDB herzustellen.

Ändern Sie das Benutzername- und Passwortfeld mit Ihrem MongoDB-Benutzer und -Passwort.

# Als mongoadmin verbinden
mongodb://mongoadmin:secretpassword@localhost:27017/admin?ssl=false

# Als appuser verbinden
mongodb://appuser:myapppassword@localhost:27017/admin?ssl=false

Bei erfolgreicher Verbindung erhalten Sie das folgende Fenster, das die korrekte Bereitstellung von MongoDB auf Kubernetes bestätigt.

Für den Benutzer mongoadmin sehen Sie Standarddatenbanken (local, config und admin).

Für den Benutzer appuser sehen Sie nur eine Berechtigungsdatenbank mit dem Namen appdb1.

Abschluss

In diesem Tutorial haben Sie gelernt, wie Sie MongoDB mithilfe des MongoDB Kubernetes Operators im Kubernetes-Cluster bereitstellen. Sie haben auch grundlegende Anwendungen des Kubernetes Operators behandelt. Bis jetzt verfügen Sie bereits über solide Kenntnisse darüber, wie Anwendungen automatisch auf Kubernetes bereitgestellt und verwaltet werden.

Warum richten Sie keine TLS-Verbindung in Ihrer MongoDB-Bereitstellung ein, um auf diesem neu gewonnenen Wissen aufzubauen? Eine TLS-Verbindung sichert Verbindungen zwischen Replikatsätzen und schützt Client- oder App-Verbindungen mit MongoDB.