Lernpfad: Monolith in eine GKE-Anwendung umwandeln – Anwendung in einem GKE-Cluster bereitstellen

Dies ist die fünfte und letzte Anleitung eines Lernpfads, 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. Monolithische Anwendung modularisieren
  4. Modulare Anwendung für die Containerisierung vorbereiten
  5. Modulare Anwendung containerisieren
  6. Anwendung in einem GKE-Cluster bereitstellen (diese Anleitung)

In der vorherigen Anleitung Modulare Anwendung containerisieren haben Sie die modulare Cymbal Books-Anwendung für die Bereitstellung vorbereitet. Sie haben die Module der Anwendung containerisiert, die resultierenden Container getestet und die Container-Images per Push in Artifact Registryübertragen.

In dieser Anleitung stellen Sie die containerisierte Anwendung in einem Google Kubernetes Engine-Cluster bereit. Mit diesem Schritt wird die Umwandlung der Cymbal Books-Anwendung in ein modulares und skalierbares System abgeschlossen, das in 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 entstehen, wenn 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 durchgearbeitet 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 den einzelnen Anleitungen finden Sie unter Lernpfad: Monolithische Anwendung in eine GKE-Anwendung umwandeln – Übersicht.

Sie müssen insbesondere die Schritte in der vorherigen Anleitung Modulare Anwendung containerisieren ausgeführt haben.

GKE-Cluster einrichten

Bevor Sie die modulare Cymbal Books-Anwendung bereitstellen können, müssen Sie zuerst einen GKE-Cluster erstellen. Dieser Cluster stellt die Infrastruktur bereit, in der die Container Ihrer Anwendung 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 zum Erstellen und Verwalten von Google Cloud Ressourcen wie GKE-Clustern bietet.

GKE-Cluster erstellen und prüfen

Ein GKE-Cluster stellt die Rechenressourcen bereit, die zum Ausführen Ihrer Container in Kubernetes erforderlich sind. Führen Sie die folgenden Schritte aus, um einen Cluster mit der gcloud CLI zu erstellen.

  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 Google Cloud 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 alle Ihre 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 oder 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 die Kubernetes-Konfigurationsdatei aktualisiert, die standardmäßig unter ~/.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, ähnlich wie im folgenden Beispiel:

    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-Anwendung darin bereitstellen. Um eine Anwendung in einem Cluster bereitzustellen, wenden Sie das Kubernetes-Manifest auf den Cluster an.

Kubernetes-Manifest anwenden

Führen Sie in Cloud Shell die folgenden Befehle aus, um die Anwendung im GKE-Cluster bereitzustellen:

  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

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

Sie haben Dienste zum ersten Mal im Abschnitt Modularen Code ändern in der Anleitung Modulare Anwendung für die Containerisierung vorbereiten kennengelernt. In dieser Anleitung haben Sie den Code der Anwendung so aktualisiert, dass 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 jetzt das Manifest 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 ein Container-Image für jedes Modul der Cymbal Books-Anwendung erstellt. Sie haben beispielsweise Container-Images auf Grundlage der Module home_app und book_details_app erstellt.

Wenn Sie den Befehl kubectl apply verwenden, um das Kubernetes-Manifest bereitzustellen, ruft Kubernetes Ihre Container-Images aus 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.
  • 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 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 Anwendung erfolgreich im Cluster bereitgestellt wurde. Prüfen Sie dazu, ob die Pods und Dienste ordnungsgemäß ausgeführt werden.

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 aufgelistet. Suchen Sie nach der Spalte STATUS und prüfen Sie, ob alle Pods als Running gekennzeichnet sind. Das bedeutet, dass sie erfolgreich ausgeführt werden und bereit sind, Anfragen zu verarbeiten. 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 zunächst als Pending angezeigt, während er erstellt wird und seine Container gestartet werden. Wenn ein Pod längere Zeit den Status Pending hat, fehlen dem Cluster möglicherweise genügend Ressourcen, damit der Pod den Status Running erreichen kann. Wenn ein Pod den Status CrashLoopBackOff hat, liegt möglicherweise ein Problem mit dem Container vor. Schritte zur Fehlerbehebung werden später in dieser Anleitung beschrieben.

Dienste prüfen

Dienste ermöglichen die Kommunikation zwischen Pods und ermöglichen externen Clients (z. B. Nutzern, automatisierten Skripts oder Überwachungstools) den Zugriff auf die Anwendung. Führen Sie den folgenden Befehl aus, um die Dienste in Ihrem Cluster aufzurufen:

kubectl get services

Die Ausgabe dieses Befehls sieht 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

Wichtige 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 Anwendung.
  • EXTERNAL-IP: Für einen Dienst vom Typ LoadBalancer zeigt das Feld EXTERNAL-IP die öffentliche IP-Adresse an, die Nutzer in ihren Webbrowser eingeben können, um auf die Anwendung zuzugreifen. Für einen 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-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

Prüfen Sie so, ob die Anwendung zugänglich ist:

  1. Rufen Sie die externe IP-Adresse für den 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 gefunden haben.

  3. Prüfen Sie, ob die Startseite der Cymbal Books-Anwendung korrekt geladen wird.

Kommunikation zwischen Diensten prüfen

Die Container in der Cymbal Books-Anwendung verwenden Dienste, um Informationen auszutauschen. Führen Sie die folgenden Schritte aus, um sicherzustellen, dass die Container effektiv kommunizieren können:

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

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

    • Buchcover prüfen: Prüfen Sie, ob die Buchcover sowohl auf der Startseite als auch auf der Buch-Detailseite 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: Navigieren Sie von der Startseite aus zu einer Buchdetailseite. Wenn Sie die Details eines Buchs sehen, kommuniziert der Container home_app korrekt mit dem Container 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 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 Anwendung aus der Registry in GKE bereitstellen. Das ist eine große Leistung und spiegelt die Schritte wider, die Teams in der Praxis unternehmen, um Anwendungen für die Cloud zu modernisieren.

Fehlerbehebung

Wenn die Anwendung 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 zu prüfen, ob sie wie erwartet ausgeführt werden:

kubectl get pods

Prüfen Sie in der Ausgabe, ob sich jeder Pod im Status Running befindet. Wenn ein Pod nicht ausgeführt wird, notieren Sie seinen Namen für eine weitere Prüfung.

Pod-Logs prüfen

Wenn ein Pod Anfragen nicht ordnungsgemäß 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.

Detaillierte Informationen zu einem Pod abrufen

Wenn ein Pod länger als fünf Minuten nicht den Status Running hat, z. B. den 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 wünschen.

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

Dienstkonfiguration prüfen

Prüfen Sie, ob Ihre Dienste richtig eingerichtet sind, insbesondere der Dienst, der das Startmodul mit einer externen IP-Adresse verfügbar macht. Listen Sie die Dienste mit dem folgenden Befehl auf:

kubectl get services

Wenn Sie feststellen, dass der Dienst für das Startmodul 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 Dienstes für das Startmodul.

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

Clusterereignisse prüfen

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

kubectl get events

Mit diesem Befehl können Sie feststellen, ob größere Ressourcen- oder Netzwerkprobleme Ihr Deployment beeinträchtigen.

Ressourcen bereinigen

Die Ausführung eines GKE-Cluster verursacht Kosten. Nachdem Sie diese Anleitung durchgearbeitet haben, bereinigen Sie Ihre Ressourcen, um zusätzliche Kosten zu vermeiden. Führen Sie die folgenden Schritte aus, 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 oder 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. Wenn er angezeigt wird, warten Sie einige Minuten und versuchen Sie es noch einmal.

(Optional) Projekt löschen Google Cloud

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. Beim Löschen des Projekts 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! Mit diesem Lernpfad haben Sie die Grundlagen für die Umwandlung einer monolithischen Anwendung in eine modulare, containerisierte Anwendung kennengelernt, die in einem Kubernetes-Cluster ausgeführt wird. Die folgenden Schritte fassen den Vorgang zusammen:

  1. Monolithische Anwendung verstehen

    • Sie haben die Struktur der monolithischen Cymbal Books-Anwendung kennengelernt.
    • Sie haben eine lokale Python-Umgebung eingerichtet, um die monolithische Anwendung auszuführen, und ihre Endpunkte getestet.
    • Sie haben sich mit der Codebasis der Anwendung vertraut gemacht, um sie für die Modularisierung vorzubereiten.

  2. Monolithische Anwendung modularisieren

    • Sie haben gelernt, wie Sie monolithischen Code in separate Module aufteilen. Jedes Modul verarbeitet eine bestimmte Funktion, z. B. die Anzeige von Buchdetails oder Rezensionen.
    • Sie haben gesehen, wie diese Module als unabhängige Flask-Anwendungen implementiert werden, die auf verschiedenen Ports ausgeführt werden.
    • Sie haben die modularisierte Anwendung 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 erfahren, wie das Kubernetes-Manifest Dienste definiert, mit denen die Module der Anwendung, die bereits miteinander kommunizieren, sich im Kontext eines Kubernetes-Clusters finden können.

  4. Modulare Anwendung containerisieren

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

  5. Anwendung in einem GKE-Cluster bereitstellen (diese Anleitung):

    • Sie haben einen GKE-Cluster erstellt.
    • Sie haben die Container-Images aus Artifact Registry im GKE-Cluster bereitgestellt.
    • Sie haben die endgültige Version der Anwendung getestet, die jetzt skalierbar ist und in einer Kubernetes-Umgebung ausgeführt wird.

Nächste Schritte

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