Lernpfad: Monolith 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. Monolithische Anwendung 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 containerisiert, 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 Kosten zu vermeiden, sollten Sie GKE deaktivieren oder das Projekt löschen, nachdem Sie diese Anleitung abgeschlossen haben.

Hinweis

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 bestimmten Anleitungen finden Sie unter Lernpfad: Monolith in eine GKE-Anwendung 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 bietet die Infrastruktur, 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 den Button 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 Google Cloud -Projekt auswählen oder erstellen der vorherigen Anleitung erstellt oder ausgewählt haben. 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 \
    --location=CONTROL_PLANE_LOCATION \
    --num-nodes=2

    Ersetzen Sie Folgendes:

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

    • CONTROL_PLANE_LOCATION: der Compute Engine-Standort der Steuerungsebene Ihres Clusters. Geben Sie für regionale Cluster eine Region und für zonale Cluster eine Zone an, z. B. us-central1 oder europe-west1-b.

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

    gcloud container clusters get-credentials CLUSTER_NAME \
    --location=CONTROL_PLANE_LOCATION

    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. Listen Sie dazu die Clusterknoten auf:

    kubectl get nodes

    Wenn die Einrichtung erfolgreich war, 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 haben beide Knoten den 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. Rufen Sie das Stammverzeichnis der containerisierten Anwendung auf:

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

  2. Wenden Sie das Kubernetes-Manifest an:

    kubectl apply -f kubernetes_manifest.yaml

Mit dem vorherigen Befehl wird Kubernetes angewiesen, die in der Datei kubernetes-manifest.yaml angegebenen Ressourcen zu erstellen. Zu diesen Ressourcen gehören Services, ein Deployment und Pods.

Sie sind im Tutorial Modulare App für die Containerisierung vorbereiten im Abschnitt Modularen Code ändern zum ersten Mal auf Dienste gestoßen. In dieser Anleitung haben Sie den Code der App aktualisiert, damit Dienstnamen anstelle von localhost verwendet werden. Durch diese Aktualisierung 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?

In der vorherigen Anleitung haben Sie für jedes Modul der Cymbal Books-Anwendung ein Container-Image erstellt. Sie haben beispielsweise Container-Images basierend auf den Modulen home_app und book_details_app erstellt.

Wenn Sie das Kubernetes-Manifest mit dem Befehl kubectl apply bereitstellen, ruft Kubernetes Ihre Container-Images aus der Artifact Registry in den Cluster ab. Im Cluster werden die Container-Images zu Containern 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.
  • Netzwerkbereitstellung: 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. Diese Verteilung trägt dazu bei, dass der Cluster seine Rechen- und Arbeitsspeicherressourcen effizient nutzt.

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 das Deployment zu verifizieren.

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 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 während der Erstellung und des Startvorgangs seiner Container zuerst als Pending angezeigt. 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 in der Anleitung 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 bereitgestellt wird. Dienste vom Typ LoadBalancer ermöglichen den externen Zugriff auf die App.
  • EXTERNAL-IP: Bei einem Service 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 Service vom Typ ClusterIP ist dieses Feld leer, da ClusterIP-Services nur innerhalb des Clusters zugänglich sind.

Deployment testen

Nachdem Sie die Cymbal Books-Anwendung im GKE-Cluster bereitgestellt haben, prüfen Sie, ob die Anwendung 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 sich 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 prüfen

Die Container in der Cymbal Books App sind auf Dienste angewiesen, um Informationen auszutauschen. So stellen Sie sicher, dass die Container effektiv kommunizieren können:

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

  2. Verwenden Sie die Benutzeroberfläche der Anwendung, um Interaktionen zwischen Containern zu testen. Prüfen Sie dazu, ob die folgenden Funktionen funktionieren, indem Sie auf alle verfügbaren Links in der Benutzeroberfläche der App klicken:

    • Buchcoverbilder prüfen: Prüfen Sie, ob die Buchcoverbilder sowohl auf der Startseite als auch auf der Seite mit den Buchdetails korrekt geladen werden. Wenn das 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 Buch-Detailseite 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 App in ein modulares, containerisiertes System umwandeln, das in einem aktiven 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 ein großer Erfolg und spiegelt die realen Schritte wider, die Teams unternehmen, um Anwendungen für die Cloud zu modernisieren.

Fehlerbehebung

Wenn die Anwendung nicht reagiert oder die Container nicht 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 jeder Pod den Status Running hat. 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, sehen 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 beschreiben, um detaillierte Informationen zu erhalten

Wenn ein Pod länger als fünf Minuten in einem anderen Status als Running verbleibt, z. B. im Status Pending, ContainerCreating oder CrashLoopBackOff, können Sie mit dem folgenden Befehl detaillierte Informationen zum Status und zu den Ereignissen des Pods abrufen:

kubectl describe pod POD_NAME

Ersetzen Sie POD_NAME durch den Namen des Pods, zu dem 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 richtig 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 Service for the home-Modul 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-Modul-Dienstes.

Dieser Befehl liefert 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 lässt sich 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 durchgearbeitet haben, sollten Sie die Ressourcen bereinigen, um zusätzliche Kosten zu vermeiden. Folgen Sie dieser Anleitung, 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
    --location=CONTROL_PLANE_LOCATION

Ersetzen Sie Folgendes:

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

  • CONTROL_PLANE_LOCATION: der Compute Engine-Standort der Steuerungsebene Ihres Clusters. Geben Sie für regionale Cluster eine Region und für zonale Cluster eine Zone an.

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 einen Moment und versuchen Sie es dann 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 Reihe

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. Der Prozess wird in den folgenden Schritten zusammengefasst:

  1. Monolithische Anwendung verstehen

    • Struktur der monolithischen Cymbal Books-Anwendung kennengelernt
    • 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 verarbeitet ein bestimmtes Feature, z. B. 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 gelernt, dass Sie URLs in home.py aktualisieren müssen, um Dienstnamen anstelle von localhost zu verwenden.
    • Sie haben gelernt, wie im Kubernetes-Manifest Dienste definiert werden, mit denen die Module der App, die bereits miteinander kommunizieren, sich im Kontext eines Kubernetes-Clusters finden können.

  4. Modulare App containerisieren

    • Sie haben ein Google Cloud -Projekt eingerichtet und die App aus 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):

    • Sie haben einen GKE-Cluster 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.