Lernpfad: Einen monolithischen Dienst in eine GKE-Anwendung umwandeln – Anwendung in einem GKE-Cluster bereitstellen

Dies ist die fünfte und letzte Anleitung in einem Lernpfad, in dem Sie erfahren, wie Sie eine monolithische Anwendung modularisieren und containerisieren.

Der Lernpfad besteht aus den folgenden Anleitungen:

  1. Übersicht
  2. Monolith verstehen
  3. Monolith modularisieren
  4. Modulare App für die Containerisierung vorbereiten
  5. Modulare App containerisieren
  6. Anwendung in einem GKE-Cluster bereitstellen (diese Anleitung)

Im vorherigen Tutorial Modulare App in Container packen haben Sie die modulare Cymbal Books-App für die Bereitstellung vorbereitet. Sie haben die Module der App in Containern verpackt, die resultierenden Container getestet und die Container-Images in Artifact Registry übertragen.

In dieser Anleitung stellen Sie die containerisierte App in einem Google Kubernetes Engine-Cluster bereit. Mit diesem Schritt wird die Umwandlung der Cymbal Books-App in ein modulares und skalierbares System abgeschlossen, das auf einem Kubernetes-Cluster ausgeführt wird.

Kosten

Wenn Sie die Schritte in dieser Anleitung ausführen, fallen Kosten für Ihr Google Cloud-Konto an. Die Kosten fallen an, sobald Sie GKE aktivieren und die Cymbal Books-Beispielanwendung bereitstellen. Dazu gehören Clustergebühren für GKE, wie auf der Preisseite beschrieben, und Gebühren für die Ausführung von Compute Engine-VMs.

Um unnötige Gebühren zu vermeiden, sollten Sie GKE deaktivieren oder das Projekt löschen, sobald Sie diese Anleitung abgeschlossen haben.

Hinweise

Bevor Sie mit dieser Anleitung beginnen, müssen Sie die vorherigen Anleitungen der Reihe durchgearbeitet haben. Eine Übersicht über die gesamte Reihe und Links zu den einzelnen Anleitungen finden Sie unter Lernpfad: Monolith in eine GKE-App umwandeln – Übersicht.

Insbesondere müssen Sie die Schritte in der vorherigen Anleitung Modulare App in Container packen ausgeführt haben.

GKE-Cluster einrichten

Bevor Sie die modulare Cymbal Books App bereitstellen können, müssen Sie zuerst einen GKE-Cluster erstellen. Dieser Cluster stellt die Infrastruktur bereit, in der die Container Ihrer App ausgeführt werden.

In dieser Anleitung verwenden Sie die gcloud CLI, um den Cluster zu erstellen. Alternativ können Sie die Google Cloud Console verwenden, die eine grafische Benutzeroberfläche (GUI) zum Erstellen und Verwalten von Google Cloud-Ressourcen wie GKE-Clustern bietet.

GKE-Cluster erstellen und prüfen

Ein GKE-Cluster bietet die Rechenressourcen, die zum Ausführen Ihrer Container in Kubernetes erforderlich sind. So erstellen Sie einen Cluster mit der gcloud CLI:

  1. Rufen Sie die Google Cloud Console auf.

  2. Klicken Sie in der Console auf die Schaltfläche Cloud Shell aktivieren Cloud Shell aktivieren.

    In einem Frame im unteren Teil der Console wird eine Cloud Shell-Sitzung geöffnet.

  3. Legen Sie Ihr Standardprojekt in der Google Cloud CLI fest:

    gcloud config set project PROJECT_ID

    Ersetzen Sie PROJECT_ID durch die Projekt-ID des Projekts, das Sie im Abschnitt Projekt auswählen oder erstellen der vorherigen Anleitung erstellt oder ausgewählt haben. Google Cloud Eine Projekt-ID ist ein eindeutiger String, der Ihr Projekt von allen anderen Projekten in Google Cloudunterscheidet. Die Projekt-ID finden Sie in der Projektauswahl. Auf dieser Seite sehen Sie die Projekt-IDs für jedes Ihrer Google Cloud-Projekte.

  4. Erstellen Sie einen GKE-Cluster.

    gcloud container clusters create CLUSTER_NAME \
    --zone=ZONE \
    --num-nodes=2

    Ersetzen Sie Folgendes:

    • CLUSTER_NAME: ein Name für Ihren Cluster, z. B. cymbal-cluster.

    • ZONE: Die Zone, in der der Cluster erstellt werden soll, z. B. us-central1-a oder europe-west1-b. Eine vollständige Liste der verfügbaren Zonen finden Sie unter Regionen und Zonen.

  5. Rufen Sie die Anmeldedaten des Clusters ab, damit die kubectl-Befehlszeile eine Verbindung zum Cluster herstellen kann:

    gcloud container clusters get-credentials CLUSTER_NAME \
    --zone=ZONE

    Mit diesem Befehl wird Ihre Kubernetes-Konfigurationsdatei aktualisiert, die standardmäßig in ~/.kube/config gespeichert ist. Diese Konfigurationsdatei enthält die Anmeldedaten, die kubectl für die Interaktion mit Ihrem GKE-Cluster benötigt.

  6. Prüfen Sie, ob kubectl mit dem Cluster verbunden ist, indem Sie die Clusterknoten auflisten:

    kubectl get nodes

    Wenn die Einrichtung erfolgreich ist, werden mit diesem Befehl die Knoten in Ihrem GKE-Cluster aufgelistet. Da Sie den Cluster mit --num-nodes=2 erstellt haben, sollten Informationen zu zwei Knoten angezeigt werden, etwa so:

    NAME                                         STATUS    ROLES    AGE    VERSION
gke-nov18-default-pool-6a8f9caf-bryg   Ready     <none>   30s    v1.30.8-gke.1128000
gke-nov18-default-pool-6a8f9caf-ut0i   Ready     <none>   30s    v1.30.8-gke.1128000

    In diesem Beispiel befinden sich beide Knoten im Status Ready. Dieser Status bedeutet, dass der GKE-Cluster bereit ist, Ihre containerisierten Arbeitslasten zu hosten.

Anwendung bereitstellen

Nachdem Sie einen GKE-Cluster erstellt haben, können Sie die Cymbal Books App darin bereitstellen. Wenn Sie eine App in einem Cluster bereitstellen möchten, wenden Sie das Kubernetes-Manifest auf den Cluster an.

Kubernetes-Manifest anwenden

Stellen Sie die App in Cloud Shell im GKE-Cluster bereit, indem Sie die folgenden Befehle ausführen:

  1. Wechseln Sie zum Stammverzeichnis der containerisierten Anwendung:

    cd kubernetes-engine-samples/quickstarts/monolith-to-microservices/containerized/

  2. Wenden Sie das Kubernetes-Manifest an:

    kubectl apply -f kubernetes_manifest.yaml

Der vorherige Befehl weist Kubernetes an, die in der Datei kubernetes-manifest.yaml angegebenen Ressourcen zu erstellen. Zu diesen Ressourcen gehören Dienste, eine Bereitstellung und Pods.

Sie haben Dienste zum ersten Mal im Abschnitt Modularen Code ändern der Anleitung Modulare App für die Containerisierung vorbereiten kennengelernt. In dieser Anleitung haben Sie den Code der App so aktualisiert, dass Dienstnamen anstelle von localhost verwendet werden. Durch dieses Update kann Kubernetes Anfragen zwischen Modulen weiterleiten und dafür sorgen, dass die Module innerhalb eines Clusters miteinander kommunizieren können. Wenn Sie das Manifest jetzt anwenden, erstellt Kubernetes die Dienste im Cluster.

Ein Deployment ist ein Kubernetes-API-Objekt, mit dem Sie mehrere Replikate von Pods ausführen können, die auf die Knoten in einem Cluster verteilt sind. Im nächsten Abschnitt wird erläutert, was Pods sind.

Was ist ein Kubernetes-Pod?

Im vorherigen Tutorial haben Sie für jedes Modul der Cymbal Books App ein Container-Image erstellt, z. B. basierend auf den Modulen home_app und book_details_app.

Wenn Sie das Kubernetes-Manifest mit dem Befehl kubectl apply bereitstellen, ruft Kubernetes Ihre Container-Images aus Artifact Registry in den Cluster ab. Im Cluster werden aus den Container-Images Container und die Container werden in Pods ausgeführt.

Ein Pod ist eine isolierte Umgebung, in der Container ausgeführt werden. Er führt die folgenden Aufgaben aus:

  • CPU und Arbeitsspeicher zuweisen: Ein Pod stellt die Ressourcen bereit, die Container für den Betrieb benötigen.
  • Netzwerk bereitstellen: Jeder Pod hat eine eigene IP-Adresse. Dadurch kann der Pod mit anderen Pods kommunizieren.

Pods werden auf Knoten ausgeführt. Das sind die Maschinen, die Rechenleistung für den Cluster bereitstellen. Kubernetes weist Pods automatisch Knoten zu und verteilt die Pods auf die Knoten des Clusters, um das Risiko einer Überlastung eines einzelnen Knotens zu verringern. Durch diese Verteilung können die Rechen- und Arbeitsspeicherressourcen des Clusters effizient genutzt werden.

Deployment prüfen

Nachdem Sie das Kubernetes-Manifest mit dem Befehl kubectl apply angewendet haben, prüfen Sie, ob die App erfolgreich im Cluster bereitgestellt wurde. Prüfen Sie, ob die Pods und Dienste ordnungsgemäß ausgeführt werden, um die Bereitstellung zu bestätigen.

Pods prüfen

Führen Sie den folgenden Befehl aus, um die Pods in Ihrem Cluster aufzurufen:

kubectl get pods

Mit diesem Befehl werden die Pods und ihr aktueller Status aufgeführt. Suchen Sie nach der Spalte STATUS, um zu prüfen, ob alle Pods mit Running gekennzeichnet sind. Das bedeutet, dass sie erfolgreich ausgeführt werden und bereit sind, Anfragen zu bearbeiten. Die erwartete Ausgabe sieht in etwa so aus:

NAME                             READY   STATUS    RESTARTS   AGE
home-app-67d59c6b6d-abcde        1/1     Running   0          30s
book-details-app-6d8bcbc58f-xyz  1/1     Running   0          30s
book-reviews-app-75db4c4d7f-def  1/1     Running   0          30s
images-app-7f8c75c79c-ghi        1/1     Running   0          30s

Der Status eines Pods wird anfangs als Pending angezeigt, während er erstellt wird und seine Container gestartet werden. Wenn ein Pod über einen längeren Zeitraum im Status Pending verbleibt, fehlen dem Cluster möglicherweise genügend Ressourcen, damit der Pod in einen fehlerfreien Status Running übergehen kann. Wenn ein Pod den Status CrashLoopBackOff hat, liegt möglicherweise ein Problem mit dem Container vor. Schritte zur Fehlerbehebung werden später im Tutorial beschrieben.

Dienste prüfen

Dienste ermöglichen die Kommunikation zwischen Pods und den Zugriff externer Clients (z. B. Nutzer, automatisierte Skripts oder Monitoring-Tools) auf die App. Führen Sie den folgenden Befehl aus, um die Dienste in Ihrem Cluster aufzurufen:

kubectl get services

Die Ausgabe dieses Befehls sieht in etwa so aus:

NAME               TYPE           CLUSTER-IP      EXTERNAL-IP       PORT(S)        AGE
home-app-service   LoadBalancer   10.12.3.4       35.185.1.2        80:30837/TCP   30s
details-service    ClusterIP      10.12.3.5       <none>            80/TCP         30s
reviews-service    ClusterIP      10.12.3.6       <none>            80/TCP         30s
images-service     LoadBalancer   10.12.3.7       34.125.6.3        80:32014/TCP   30s

Die wichtigsten Felder in der Ausgabe sind:

  • TYPE: Dieses Feld gibt an, wie der Dienst verfügbar gemacht wird. Dienste vom Typ LoadBalancer ermöglichen den externen Zugriff auf die App.
  • EXTERNAL-IP: Bei einem Dienst vom Typ LoadBalancer wird im Feld EXTERNAL-IP die öffentliche IP-Adresse angezeigt, die Nutzer in ihren Webbrowser eingeben können, um auf die App zuzugreifen. Bei einem Dienst vom Typ ClusterIP ist dieses Feld leer, da ClusterIP-Dienste nur innerhalb des Clusters zugänglich sind.

Deployment testen

Nachdem Sie die Cymbal Books App im GKE-Cluster bereitgestellt haben, prüfen Sie, ob die App zugänglich ist und die Container miteinander kommunizieren können.

Auf die Anwendung zugreifen

So prüfen Sie, ob die App zugänglich ist:

  1. Rufen Sie die externe IP-Adresse für home-app-service ab:

    kubectl get services

    Suchen Sie in der Ausgabe nach der Spalte **EXTERNAL-IP** und notieren Sie die IP-Adresse, die mit home-app-service verknüpft ist.

  2. Öffnen Sie einen Webbrowser und geben Sie die folgende URL ein:

    http://EXTERNAL-IP

    Ersetzen Sie EXTERNAL-IP durch die IP-Adresse, die Sie im vorherigen Schritt ermittelt haben.

  3. Prüfe, ob die Startseite der Cymbal Books App korrekt geladen wird.

Kommunikation zwischen Diensten überprüfen

Die Container in der Cymbal Books App nutzen Dienste, um Informationen auszutauschen. Gehen Sie so vor, um sicherzustellen, dass die Container effektiv kommunizieren können:

  1. Rufen Sie die externe IP-Adresse für home-app-service wie oben beschrieben ab.

  2. Über die App-Oberfläche können Sie Interaktionen zwischen Containern testen. Prüfen Sie dazu, ob die folgenden Funktionen funktionieren, indem Sie auf alle verfügbaren Links in der Benutzeroberfläche der App klicken:

    • Buchcover prüfen: Prüfen Sie, ob die Buchcover sowohl auf der Startseite als auch auf der Buchdetailseite korrekt geladen werden. Wenn dies der Fall ist, kommunizieren die Container home_app und book_details_app erfolgreich mit dem Container images_app.
    • Buchdetails ansehen: Rufen Sie von der Startseite aus die Detailseite eines Buchs auf. Wenn Sie die Details eines Buchs sehen, kommuniziert der home_app-Container korrekt mit dem book_details_app.
    • Buchrezensionen ansehen: Klicken Sie auf einen Link zu einer Buchrezension, um zu prüfen, ob der home_app-Container mit dem book_reviews_app-Container kommunizieren kann.

Ihre Anwendung wird jetzt in einem GKE-Cluster ausgeführt.

Glückwunsch! Sie haben gesehen, wie Sie eine monolithische Anwendung in ein modulares, containerisiertes System umwandeln, das in einem Live-GKE-Cluster ausgeführt wird. Dabei haben Sie gelernt, wie Sie eng gekoppelten Code in unabhängige Module aufteilen, Container-Images erstellen und in ein Repository übertragen, Kubernetes-Manifeste definieren und Ihre App aus der Registry in GKE bereitstellen. Das ist eine große Leistung und spiegelt die realen Schritte wider, die Teams unternehmen, um Anwendungen für die Cloud zu modernisieren.

Fehlerbehebung

Wenn die App nicht reagiert oder Container nicht miteinander kommunizieren können, führen Sie die folgenden Schritte zur Fehlerbehebung aus, um häufige Probleme zu diagnostizieren und zu beheben.

Status der Pods prüfen

Listen Sie zuerst alle Pods in Ihrem Cluster auf, um festzustellen, ob sie wie erwartet ausgeführt werden:

kubectl get pods

Prüfen Sie die Ausgabe, um zu bestätigen, dass sich jeder Pod im Status Running befindet. Wenn ein Pod nicht ausgeführt wird, notieren Sie sich seinen Namen für die weitere Untersuchung.

Pod-Logs prüfen

Wenn ein Pod Anfragen nicht richtig verarbeitet, suchen Sie in den Logs nach Fehlermeldungen:

kubectl logs POD_NAME

Ersetzen Sie POD_NAME durch den Namen des Pods, den Sie prüfen möchten. Dieser Befehl ist nützlich, um Startprobleme oder Laufzeitfehler zu identifizieren.

Pod für detaillierte Informationen beschreiben

Wenn ein Pod länger als fünf Minuten nicht den Status Running hat, sondern beispielsweise den Status Pending, ContainerCreating oder CrashLoopBackOff, können Sie mit dem folgenden Befehl detaillierte Informationen zum Status und zu den Ereignissen des Pods aufrufen:

kubectl describe pod POD_NAME

Ersetzen Sie POD_NAME durch den Namen des Pods, für den Sie detaillierte Informationen erhalten möchten.

Der Abschnitt Events in der Ausgabe kann darauf hinweisen, dass Ressourcenbeschränkungen oder Probleme beim Abrufen von Images verhindern, dass der Pod ordnungsgemäß gestartet wird.

Dienstkonfiguration überprüfen

Prüfe, ob deine Dienste richtig eingerichtet sind, insbesondere der Dienst, der das Home-Modul mit einer externen IP-Adresse bereitstellt. Listen Sie die Dienste mit dem folgenden Befehl auf:

kubectl get services

Wenn Sie feststellen, dass das Modul „Service für Zuhause“ eine EXTERNAL-IP-Adresse hat, die als Pending aufgeführt ist, führen Sie den folgenden Befehl aus:

kubectl describe service SERVICE_NAME

Ersetzen Sie SERVICE_NAME durch den Namen des Home-Moduldienstes.

Dieser Befehl enthält weitere Details zur Dienstkonfiguration und hilft Ihnen, Verzögerungen bei der Zuweisung der externen IP-Adresse oder andere Konfigurationsprobleme zu erkennen.

Clusterereignisse prüfen

Sie können Clusterereignisse untersuchen, um festzustellen, ob ein Problem mehrere Komponenten Ihres Clusters betrifft:

kubectl get events

Mit diesem Befehl können Sie feststellen, ob sich umfassendere Ressourcen- oder Netzwerkprobleme auf Ihre Bereitstellung auswirken.

Ressourcen bereinigen

Für die Ausführung eines GKE-Cluster fallen Kosten an. Wenn Sie diese Anleitung abgeschlossen haben, bereinigen Sie Ihre Ressourcen, um zusätzliche Gebühren zu vermeiden. Gehen Sie so vor, um den Cluster und optional das gesamte Projekt zu entfernen.

GKE-Cluster löschen

Verwenden Sie den folgenden Befehl, um den GKE-Cluster zu löschen:

gcloud container clusters delete CLUSTER_NAME
    --zone=ZONE

Ersetzen Sie Folgendes:

  • CLUSTER_NAME: Der Name des von Ihnen erstellten Clusters, z. B. cymbal-cluster.

  • ZONE: die Zone, in der der Cluster erstellt wurde, z. B. us-central1-a.

Bestätigen Sie den Löschvorgang, wenn Sie dazu aufgefordert werden.

Prüfen, ob der Cluster gelöscht wurde

Führen Sie den folgenden Befehl aus, um zu prüfen, ob der Cluster gelöscht wurde:

gcloud container clusters list

Der Cluster sollte nicht mehr in der Ausgabe angezeigt werden. Warten Sie in diesem Fall einige Momente und versuchen Sie es noch einmal.

(Optional) Google Cloud Projekt löschen

Wenn Sie ein Google Cloud Projekt speziell für diese Anleitung erstellt haben und es nicht mehr benötigen, können Sie das gesamte Google Cloud Projekt löschen. Wenn Sie das Projekt löschen, werden alle Ressourcen entfernt und die Abrechnung für das Projekt wird beendet:

  1. Öffnen Sie in der Google Cloud Console die Seite Ressourcen verwalten.
  2. Wählen Sie das Projekt aus, das Sie löschen möchten.
  3. Klicken Sie auf Projekt löschen und folgen Sie der Anleitung, um den Vorgang zu bestätigen.

Zusammenfassung der Serie

Glückwunsch! Nach Abschluss dieses Lernpfads haben Sie die Grundlagen der Umwandlung einer monolithischen App in eine modulare, containerisierte App kennengelernt, die in einem Kubernetes-Cluster ausgeführt wird. Im Folgenden wird der Vorgang zusammengefasst:

  1. Monolith verstehen

    • Sie haben sich die Struktur der monolithischen Cymbal Books-App angesehen.
    • Richten Sie eine lokale Python-Umgebung ein, um den Monolithen auszuführen und seine Endpunkte zu testen.
    • Sie haben sich mit der Codebasis der App vertraut gemacht, um sie für die Modularisierung vorzubereiten.

  2. Monolith modularisieren

    • Sie haben gelernt, wie Sie monolithischen Code in separate Module aufteilen. Jedes Modul ist für ein bestimmtes Feature zuständig, z. B. für die Anzeige von Buchdetails oder Rezensionen.
    • Sie haben gesehen, wie diese Module als unabhängige Flask-Apps implementiert werden, die auf verschiedenen Ports ausgeführt werden.
    • Die modularisierte App wurde getestet.

  3. Modularen Code für die Containerisierung vorbereiten

    • Sie haben erfahren, dass Sie URLs in home.py aktualisieren müssen, um Dienstnamen anstelle von localhost zu verwenden.
    • Sie haben gelernt, wie das Kubernetes-Manifest Dienste definiert, die es den Modulen der App, die bereits miteinander kommunizieren, ermöglichen, sich im Kontext eines Kubernetes-Clusters zu finden.

  4. Modulare App containerisieren

    • Sie haben ein Google Cloud -Projekt eingerichtet und die App von GitHub in Cloud Shell geklont.
    • Container-Images für jedes Modul mit Docker erstellt und Container lokal getestet.
    • Container-Images per Push an Artifact Registry übertragen, um die App für die Bereitstellung in einem Cluster vorzubereiten
    • Das Kubernetes-Manifest wurde aktualisiert, um auf die Container-Image-Pfade in Artifact Registry zu verweisen.

  5. Stellen Sie die App in einem GKE-Cluster bereit (diese Anleitung):

    • Ein GKE-Cluster wurde erstellt.
    • Container-Images aus Artifact Registry im GKE-Cluster bereitgestellt.
    • Die endgültige Version der App wurde getestet. Sie ist jetzt skalierbar und kann in einer Kubernetes-Umgebung ausgeführt werden.

Nächste Schritte

Weitere praktische Informationen zum Erstellen von Clustern finden Sie in unserer Reihe Lernpfad: Skalierbare Anwendungen.