Kubernetes Mastery: Effiziente Skalierung von Node.js und MongoDB mit Helm

Erfahren Sie, wie Sie Ihre Node.js-Anwendung mit MongoDB auf Kubernetes mithilfe von Helm effektiv skalieren. Unser umfassender Leitfaden bietet praktische Schritte zur Einrichtung und Verwaltung Ihrer Anwendung in einer Clusterumgebung.

Kubernetes ist ein System zur Ausführung moderner, containerisierter Anwendungen im großen Maßstab. Entwickler können damit Anwendungen über Cluster von Maschinen bereitstellen und verwalten. Es ermöglicht nicht nur die Verbesserung von Effizienz und Zuverlässigkeit in Einzelinstanz-Anwendungsumgebungen, sondern ist auch darauf ausgelegt, mehrere Instanzen einer Anwendung über Gruppen von Maschinen hinweg auszuführen.

Viele Entwickler wählen bei der Erstellung von Multi-Service-Bereitstellungen mit Kubernetes den Helm-Paketmanager. Helm erleichtert den Prozess der Erstellung mehrerer Kubernetes-Ressourcen, indem es Charts und Vorlagen anbietet, die koordinieren, wie diese Objekte interagieren. Es bietet auch vorgefertigte Charts für beliebte Open-Source-Projekte.

In diesem Tutorial werden wir eine Node.js-Anwendung mit einer MongoDB-Datenbank auf einem Kubernetes-Cluster mithilfe von Helm-Charts bereitstellen. Wir verwenden das offizielle Helm MongoDB Replica Set Chart, um ein StatefulSet-Objekt zu erstellen, das aus drei Pods, einem Headless-Service und drei PersistentVolumeClaims besteht. Außerdem werden wir ein Chart erstellen, um eine Multi-Replica-Node.js-Anwendung mithilfe eines benutzerdefinierten Anwendungsimages bereitzustellen. Die in diesem Tutorial erstellte Einrichtung wird die Funktionalität des in „Containerizing a Node.js Application with Docker Compose“ beschriebenen Codes widerspiegeln und einen guten Ausgangspunkt bieten, um eine robuste Node.js-Anwendung mit einem MongoDB-Datenspeicher aufzubauen, der je nach Bedarf skaliert werden kann.

Voraussetzungen

Um dieses Tutorial abzuschließen, benötigen Sie:

• Einen Kubernetes-Cluster 1.10+ mit aktivierter rollenbasierter Zugriffskontrolle (RBAC). Diese Einrichtung wird einen centron Kubernetes-Cluster verwenden, aber Sie können auch einen Cluster auf andere Weise erstellen.
• Das kubectl-Befehlszeilentool auf Ihrem lokalen Computer oder Entwicklungsserver installiert und konfiguriert, um eine Verbindung zu Ihrem Cluster herzustellen.
• Helm auf Ihrem lokalen Computer oder Entwicklungsserver installiert und Tiller auf Ihrem Cluster installiert.
• Docker auf Ihrem lokalen Computer oder Entwicklungsserver installiert.
• Ein Docker Hub-Konto.

Schritt 1: Klonen und Verpacken der Anwendung

Um unsere Anwendung mit Kubernetes zu verwenden, müssen wir Sie verpacken, damit der kubelet-Agent das Image abrufen kann. Bevor wir die Anwendung verpacken, müssen wir jedoch die MongoDB-Verbindungs-URI im Anwendungscode ändern, um sicherzustellen, dass unsere Anwendung eine Verbindung zu den Mitgliedern des Replikatsatzes herstellen kann, den wir mit dem Helm mongodb-replicaset-Chart erstellen werden.

Unser erster Schritt besteht darin, das Repository node-mongo-docker-dev vom GitHub-Account der centron Community zu klonen. Dieses Repository enthält den Code aus dem Setup, das in „Containerizing a Node.js Application for Development With Docker Compose“ beschrieben ist. Es verwendet eine Demo-Node.js-Anwendung mit einer MongoDB-Datenbank, um zu zeigen, wie man eine Entwicklungsumgebung mit Docker Compose einrichtet.

Klonen Sie das Repository in ein Verzeichnis namens node_project:

git clone https://github.com/do-community/node-mongo-docker-dev.git node_project

Navigieren Sie zum node_project-Verzeichnis:

cd node_project

Das node_project-Verzeichnis enthält Dateien und Verzeichnisse für eine Anwendung zur Haifischinformation, die mit Benutzereingaben funktioniert. Es wurde modernisiert, um mit Containern zu arbeiten: Empfindliche und spezifische Konfigurationsinformationen wurden aus dem Anwendungscode entfernt und so umstrukturiert, dass Sie zur Laufzeit eingefügt werden, und der Status der Anwendung wurde in eine MongoDB-Datenbank ausgelagert.

Schritt 2: Erstellen von Secrets für den MongoDB-Replikatsatz

Das Chart stable/mongodb-replicaset bietet verschiedene Optionen für die Verwendung von Secrets, und wir werden zwei davon erstellen, um Sie mit unserer Chart-Bereitstellung zu verwenden:

• Ein Secret für unsere Replikat-Schlüsseldatei, die als gemeinsames Passwort zwischen den Mitgliedern des Replikatsatzes fungiert und es ihnen ermöglicht, andere Mitglieder zu authentifizieren.
• Ein Secret für unseren MongoDB-Admin-Benutzer, der als Root-Benutzer in der Admin-Datenbank erstellt wird.

Mit diesen Secrets können wir unsere bevorzugten Parameterwerte in einer dedizierten values-Datei festlegen und das StatefulSet-Objekt und den MongoDB-Replikatsatz mit dem Helm-Chart erstellen.

Schritt 3: Konfigurieren des MongoDB Helm Charts und Erstellen einer Bereitstellung

Helm wird mit einem aktiv gepflegten Repository namens stable geliefert, das das Chart enthält, das wir verwenden werden: mongodb-replicaset. Um dieses Chart mit den gerade erstellten Secrets zu verwenden, werden wir eine Datei mit Konfigurationsparameterwerten erstellen, die mongodb-values.yaml genannt wird, und dann das Chart mit dieser Datei installieren.

Unsere mongodb-values.yaml-Datei wird weitgehend der Standard values.yaml-Datei im Repository des mongodb-replicaset-Charts entsprechen. Wir werden jedoch folgende Änderungen an unserer Datei vornehmen:

• Wir setzen den auth-Parameter auf true, um sicherzustellen, dass unsere Datenbankinstanzen mit aktivierter Autorisierung gestartet werden. Das bedeutet, dass alle Clients zur Verwendung von Datenbankressourcen und -operationen authentifiziert werden müssen.
• Wir fügen Informationen zu den Secrets hinzu, die wir im vorherigen Schritt erstellt haben, damit das Chart diese Werte verwenden kann, um die Replikat-Schlüsseldatei und den Admin-Benutzer zu erstellen.
• Wir reduzieren die Größe der PersistentVolumes, die jedem Pod im StatefulSet zugeordnet sind, um die minimale verwendbare centron-Blockspeichereinheit von 1 GB zu verwenden, obwohl Sie diese nach Ihren Speicheranforderungen anpassen können.

Bevor Sie die mongodb-values.yaml-Datei schreiben, sollten Sie jedoch zuerst überprüfen, ob Sie einen StorageClass erstellt und konfiguriert haben, um Speicherressourcen bereitzustellen.

Schritt 4: Erstellung eines benutzerdefinierten Helm-Charts

Um unsere Node.js-Applikation auf einem Kubernetes-Cluster bereitzustellen, beginnen wir mit der Erstellung eines benutzerdefinierten Helm-Charts. Hierfür führen wir den folgenden Befehl aus:

helm create nodeapp

Dadurch wird im Verzeichnis `~/node_project` ein neues Verzeichnis mit dem Namen `nodeapp` erstellt. In diesem Verzeichnis befinden sich grundlegende Dateien für unseren Chart, darunter `Chart.yaml`, `values.yaml`, und `templates/` für die Kubernetes-Manifeste.

Schritt 5: Konfiguration der Parameter

Als nächstes bearbeiten wir die `values.yaml`-Datei, um Parameter wie die Anzahl der Replikate, das Image für unsere Applikation und den Servicetyp festzulegen. Wir öffnen die Datei mit einem Texteditor:

nano nodeapp/values.yaml

In dieser Datei legen wir Werte fest, wie die Anzahl der Replikate, das verwendete Docker-Image und den Servicetyp (z. B. LoadBalancer). Zudem definieren wir Umgebungsvariablen für den Zugriff auf die Datenbank.

Schritt 6: Erstellung von ConfigMaps und Secrets

Wir erstellen Dateien für ConfigMaps und Secrets, um Konfigurationsdaten sicher zu speichern und in unserer Applikation zu verwenden. Dazu öffnen wir eine `secret.yaml`-Datei und eine `configmap.yaml`-Datei im `templates/`-Verzeichnis und fügen die entsprechenden Daten hinzu.

Schritt 7: Integration von Umgebungsvariablen

Im nächsten Schritt passen wir das Deployment-Template unserer Applikation an, um die Umgebungsvariablen aus den zuvor erstellten ConfigMaps und Secrets zu verwenden. Hierzu öffnen wir die `deployment.yaml`-Datei im `templates/`-Verzeichnis und fügen die entsprechenden Umgebungsvariablen hinzu.

Schritt 8: Bereitstellung der Applikation mit Helm

Abschließend erstellen wir unsere Applikation mit Helm und überwachen den Bereitstellungsprozess. Wir verwenden den Befehl `helm install`, um unseren Helm-Chart zu installieren und die Applikation auf dem Kubernetes-Cluster zu bereitstellen.

helm install –name nodejs ./nodeapp

Nach erfolgreicher Bereitstellung können wir den Status der Pods und Services überprüfen, um sicherzustellen, dass die Applikation ordnungsgemäß läuft und erreichbar ist.

Fazit

Mit Helm haben wir erfolgreich eine replizierte Node.js-Applikation auf einem Kubernetes-Cluster bereitgestellt. Dieser Prozess bietet eine skalierbare und flexible Möglichkeit, Anwendungen in einer Kubernetes-Umgebung zu betreiben. Durch die Nutzung von benutzerdefinierten Helm-Charts können wir die Konfiguration und Bereitstellung unserer Applikation effizient verwalten und skalieren. Kubernetes Mastery: Effiziente Skalierung von Node.js und MongoDB mit Helm