GSP021

Übersicht

Kubernetes ist ein auf kubernetes.io verfügbares Open-Source-Projekt, das in vielen verschiedenen Umgebungen ausgeführt werden kann: von Laptops bis hin zu hochverfügbaren Clustern mit mehreren Knoten, von öffentlichen Clouds bis hin zu lokalen Bereitstellungen, von virtuellen bis hin zu Bare-Metal-Maschinen.

Eine verwaltete Umgebung wie Kubernetes Engine bietet Ihnen in diesem Lab die Möglichkeit, sich vollständig auf Kubernetes zu konzentrieren, da Sie keine Zeit für die Einrichtung der zugrunde liegenden Infrastruktur aufwenden müssen. Die Kubernetes Engine ist eine verwaltete Umgebung zum Bereitstellen von Containeranwendungen. Sie vereint die neuesten Innovationen im Hinblick auf die Entwicklungsproduktivität, den effizienten Einsatz von Ressourcen, automatisierte Abläufe und Open-Source-Flexibilität, um die Produkteinführungszeit zu verkürzen.

Ziele

Aufgaben in diesem Lab:

• Vollständigen Kubernetes-Cluster mit der Kubernetes Engine bereitstellen
• Docker-Container mit „kubectl“ bereitstellen und verwalten
• Mithilfe von Kubernetes-Deployments und -Diensten eine Anwendung in Mikrodienste unterteilen

Einrichtung und Anforderungen

Vor dem Klick auf „Start Lab“ (Lab starten)

Lesen Sie diese Anleitung. Labs sind zeitlich begrenzt und können nicht pausiert werden. Der Timer beginnt zu laufen, wenn Sie auf Lab starten klicken, und zeigt Ihnen, wie lange Google Cloud-Ressourcen für das Lab verfügbar sind.

In diesem praxisorientierten Lab können Sie die Lab-Aktivitäten in einer echten Cloud-Umgebung durchführen – nicht in einer Simulations- oder Demo-Umgebung. Dazu erhalten Sie neue, temporäre Anmeldedaten, mit denen Sie für die Dauer des Labs auf Google Cloud zugreifen können.

Für dieses Lab benötigen Sie Folgendes:

• Einen Standardbrowser (empfohlen wird Chrome)

Hinweis: Nutzen Sie den privaten oder Inkognitomodus (empfohlen), um dieses Lab durchzuführen. So wird verhindert, dass es zu Konflikten zwischen Ihrem persönlichen Konto und dem Teilnehmerkonto kommt und zusätzliche Gebühren für Ihr persönliches Konto erhoben werden.

• Zeit für die Durchführung des Labs – denken Sie daran, dass Sie ein begonnenes Lab nicht unterbrechen können.

Hinweis: Verwenden Sie für dieses Lab nur das Teilnehmerkonto. Wenn Sie ein anderes Google Cloud-Konto verwenden, fallen dafür möglicherweise Kosten an.

Lab starten und bei der Google Cloud Console anmelden

1. Klicken Sie auf Lab starten. Wenn Sie für das Lab bezahlen müssen, wird ein Dialogfeld geöffnet, in dem Sie Ihre Zahlungsmethode auswählen können. Auf der linken Seite befindet sich der Bereich „Details zum Lab“ mit diesen Informationen:

   • Schaltfläche „Google Cloud Console öffnen“
   • Restzeit
   • Temporäre Anmeldedaten für das Lab
   • Ggf. weitere Informationen für dieses Lab

2. Klicken Sie auf Google Cloud Console öffnen (oder klicken Sie mit der rechten Maustaste und wählen Sie Link in Inkognitofenster öffnen aus, wenn Sie Chrome verwenden).

   Im Lab werden Ressourcen aktiviert. Anschließend wird ein weiterer Tab mit der Seite „Anmelden“ geöffnet.

   Tipp: Ordnen Sie die Tabs nebeneinander in separaten Fenstern an.

   Hinweis: Wird das Dialogfeld Konto auswählen angezeigt, klicken Sie auf Anderes Konto verwenden.

3. Kopieren Sie bei Bedarf den folgenden Nutzernamen und fügen Sie ihn in das Dialogfeld Anmelden ein.

   {{{user_0.username | "Username"}}}

   Sie finden den Nutzernamen auch im Bereich „Details zum Lab“.

4. Klicken Sie auf Weiter.

5. Kopieren Sie das folgende Passwort und fügen Sie es in das Dialogfeld Willkommen ein.

   {{{user_0.password | "Password"}}}

   Sie finden das Passwort auch im Bereich „Details zum Lab“.

6. Klicken Sie auf Weiter.

   Wichtig: Sie müssen die für das Lab bereitgestellten Anmeldedaten verwenden. Nutzen Sie nicht die Anmeldedaten Ihres Google Cloud-Kontos. Hinweis: Wenn Sie Ihr eigenes Google Cloud-Konto für dieses Lab nutzen, können zusätzliche Kosten anfallen.

7. Klicken Sie sich durch die nachfolgenden Seiten:

   • Akzeptieren Sie die Nutzungsbedingungen.
   • Fügen Sie keine Wiederherstellungsoptionen oder Zwei-Faktor-Authentifizierung hinzu (da dies nur ein temporäres Konto ist).
   • Melden Sie sich nicht für kostenlose Testversionen an.

Nach wenigen Augenblicken wird die Google Cloud Console in diesem Tab geöffnet.

Hinweis: Wenn Sie auf Google Cloud-Produkte und ‑Dienste zugreifen möchten, klicken Sie auf das Navigationsmenü oder geben Sie den Namen des Produkts oder Dienstes in das Feld Suchen ein.

Cloud Shell aktivieren

Cloud Shell ist eine virtuelle Maschine, auf der Entwicklertools installiert sind. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft auf Google Cloud. Mit Cloud Shell erhalten Sie Befehlszeilenzugriff auf Ihre Google Cloud-Ressourcen.

1. Klicken Sie oben in der Google Cloud Console auf Cloud Shell aktivieren .

2. Klicken Sie sich durch die folgenden Fenster:

   • Fahren Sie mit dem Informationsfenster zu Cloud Shell fort.
   • Autorisieren Sie Cloud Shell, Ihre Anmeldedaten für Google Cloud API-Aufrufe zu verwenden.

Wenn eine Verbindung besteht, sind Sie bereits authentifiziert und das Projekt ist auf Project_ID, eingestellt. Die Ausgabe enthält eine Zeile, in der die Project_ID für diese Sitzung angegeben ist:

Ihr Cloud-Projekt in dieser Sitzung ist festgelegt als {{{project_0.project_id | "PROJECT_ID"}}}

gcloud ist das Befehlszeilentool für Google Cloud. Das Tool ist in Cloud Shell vorinstalliert und unterstützt die Tab-Vervollständigung.

3. (Optional) Sie können den aktiven Kontonamen mit diesem Befehl auflisten:

gcloud auth list

4. Klicken Sie auf Autorisieren.

Ausgabe:

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} Um das aktive Konto festzulegen, führen Sie diesen Befehl aus: $ gcloud config set account `ACCOUNT`

5. (Optional) Sie können die Projekt-ID mit diesem Befehl auflisten:

gcloud config list project

Ausgabe:

[core] project = {{{project_0.project_id | "PROJECT_ID"}}} Hinweis: Die vollständige Dokumentation für gcloud finden Sie in Google Cloud in der Übersicht zur gcloud CLI.

Google Kubernetes Engine

1. Geben Sie in der Cloud Shell-Umgebung den folgenden Befehl ein, um die Zone einzurichten:

gcloud config set compute/zone {{{project_0.default_zone|Zone}}}

2. Starten Sie einen Cluster für dieses Lab:

gcloud container clusters create io --zone {{{project_0.default_zone|Zone}}} Sie werden bei der Erstellung automatisch bei dem Cluster authentifiziert. Falls aus irgendeinem Grund die Verbindung zu Cloud Shell unterbrochen wird, können Sie sich über den Befehl gcloud container clusters get-credentials io erneut authentifizieren. Hinweis: Das Erstellen eines Clusters kann einige Zeit in Anspruch nehmen. Die Kubernetes Engine stellt im Hintergrund einige virtuelle Maschinen bereit, mit denen Sie experimentieren können.

Aufgabe 1: Beispielcode abrufen

Dazu kopieren Sie den Beispielcode aus einem Google Cloud Storage-Bucket.

1. Kopieren Sie in Cloud Shell den Quellcode aus der Cloud Shell-Befehlszeile:

gcloud storage cp -r gs://spls/gsp021/* .

2. Rufen Sie das Verzeichnis für dieses Lab auf:

cd orchestrate-with-kubernetes/kubernetes

3. Listen Sie die Dateien auf, mit denen Sie arbeiten werden:

ls

Das Beispiel hat das folgende Layout:

deployments/ /* Deployment manifests */ ... nginx/ /* nginx config files */ ... pods/ /* Pod manifests */ ... services/ /* Services manifests */ ... tls/ /* TLS certificates */ ... cleanup.sh /* Cleanup script */

Mit diesem Code können Sie Kubernetes endlich ausprobieren.

Aufgabe 2: Kurze Kubernetes-Demo

Der Befehl „kubectl create“ ist die einfachste Möglichkeit, Kubernetes zu starten.

1. Damit starten Sie eine einzelne Instanz des Containers „nginx“:

kubectl create deployment nginx --image=nginx:1.27.0

Kubernetes hat ein Deployment erstellt. Deployments werden im weiteren Verlauf des Labs ausführlicher erläutert. An dieser Stelle müssen Sie lediglich wissen, dass Deployments für eine unterbrechungsfreie Ausführung von Pods sorgen, selbst wenn die Knoten ausfallen, auf denen sie ausgeführt werden.

In Kubernetes werden alle Container in einem Pod ausgeführt.

2. Mit dem Befehl „kubectl get pods“ können Sie den ausgeführten nginx-Container abrufen:

kubectl get pods

3. Wenn der nginx-Container den Status „Wird ausgeführt“ hat, können Sie ihn außerhalb von Kubernetes über den Befehl „kubectl expose“ verfügbar machen:

kubectl expose deployment nginx --port 80 --type LoadBalancer

Was ist gerade geschehen? Kubernetes hat im Hintergrund einen externen Load Balancer erstellt, dem eine öffentliche IP-Adresse zugeordnet ist. Alle Clients, die diese öffentliche IP-Adresse ansteuern, werden an die Pods weitergeleitet, die hinter dem Dienst liegen. In diesem Fall wäre das der Pod „nginx“.

4. Listen Sie jetzt die Dienste mit dem Befehl „kubectl get services“ auf:

kubectl get services Hinweis: Es kann einige Sekunden dauern, bis das Feld ExternalIP für Ihren Dienst ausgefüllt ist. Das ist normal. Führen Sie den Befehl kubectl get services einfach in Abständen von wenigen Sekunden so lange noch einmal aus, bis das Feld ausgefüllt ist.

5. Fügen Sie diesem Befehl die externe IP-Adresse hinzu, damit der Container „nginx“ auch remote zu erreichen ist:

curl http://<External IP>:80

Das war schon alles. Kubernetes unterstützt einen einfachen, vorkonfigurierten Workflow mit den kubectl-Befehlen „run“ und „expose“.

Abgeschlossene Aufgabe testen

Klicken Sie unten auf Fortschritt prüfen. Wenn Sie erfolgreich einen Kubernetes-Cluster erstellt und einen nginx-Container bereitgestellt haben, wird ein Testergebnis angezeigt.

Kubernetes-Cluster erstellen und nginx-Container starten

Nach dieser kurzen Einführung in Kubernetes werden die Komponenten und Abstraktionen nun im Einzelnen vorgestellt.

Aufgabe 3: Pods

Das Kernstück von Kubernetes ist der Pod.

Pods repräsentieren eine Zusammenstellung von einem oder mehreren Containern. Im Allgemeinen werden Container mit starken gegenseitigen Abhängigkeiten in einem Pod gruppiert.

Das folgende Beispiel zeigt einen Pod, der die Container „monolith“ und „nginx“ enthält.

Pods haben auch Volumes. Volumes sind Datenträger, die dieselbe Lebensdauer haben wie der jeweilige Pod. Sie können von den Containern im Pod verwendet werden. Für die Inhalte im Pod wird ein gemeinsamer Namespace zur Verfügung gestellt, sodass die beiden Container in unserem Beispiel-Pod miteinander kommunizieren können. Sie nutzen auch die zugeordneten Volumes gemeinsam.

Pods teilen darüber hinaus einen Netzwerk-Namespace. Für jeden Pod gibt es also eine IP-Adresse.

In der nächsten Aufgabe werden Pods genauer behandelt.

Aufgabe 4: Pods erstellen

Pods können mithilfe von Pod-Konfigurationsdateien erstellt werden. Nehmen Sie sich kurz Zeit, sich die Konfigurationsdatei des Pods „fortune-app“ genauer anzusehen.

1. Wechseln Sie in das Verzeichnis:

cd ~/orchestrate-with-kubernetes/kubernetes

2. Führen Sie den folgenden Befehl aus, um die Konfigurationsdatei aufzurufen:

cat pods/fortune-app.yaml

Die Ausgabe zeigt die geöffnete Konfigurationsdatei:

apiVersion: v1 kind: Pod metadata: name: fortune-app labels: app: fortune-app spec: containers: - name: fortune-app image: "us-central1-docker.pkg.dev/qwiklabs-resources/gsp-021-lab-images/fortune-app:1.0.0" ports: - name: http containerPort: 8080 resources: limits: cpu: 0.2 memory: "20Mi"

Daran können Sie Folgendes ablesen:

• Der Pod besteht aus einem Container („fortune-app“).
• Sie öffnen Port 8080 für HTTP-Traffic.

3. Erstellen Sie den Pod „fortune-app“ mit kubectl:

kubectl create -f pods/fortune-app.yaml

4. Prüfen Sie Ihre Pods. Listen Sie mit dem Befehl „kubectl get pods“ alle Pods auf, die im Standard-Namespace ausgeführt werden:

kubectl get pods Hinweis: Es kann einige Sekunden dauern, bis der Pod „fortune-app“ gestartet und ausgeführt wird. Das Container-Image muss erst aus der Artifact Registry abgerufen werden, bevor es ausgeführt werden kann.

5. Sobald der Pod „fortune-app“ ausgeführt wird, können Sie mit dem Befehl „kubectl describe“ weitere Informationen zu ihm abrufen:

kubectl describe pods fortune-app

Es werden zahlreiche Informationen zum Pod „fortune-app” angezeigt, unter anderem seine IP-Adresse und das Ereignisprotokoll. Diese Informationen sind für eine eventuelle Fehlerbehebung nützlich.

In Kubernetes können Pods ganz einfach erstellt werden, indem sie in den Konfigurationsdateien beschrieben werden. Genauso einfach ist es, Informationen zu den ausgeführten Pods aufzurufen. Jetzt können Sie alle Pods erstellen, die in Ihrem Deployment benötigt werden.

Aufgabe 5: Mit Pods interagieren

Den Pods ist standardmäßig eine private IP-Adresse zugeordnet, sodass es nicht möglich ist, von außerhalb des Clusters auf sie zuzugreifen. Mit dem Befehl „kubectl port-forward“ können Sie einem Port innerhalb des Pods „fortune-app“ einen lokalen Port zuordnen.

Hinweis: Ab jetzt müssen Sie im Lab in mehreren Cloud Shell-Tabs arbeiten, um die Kommunikation der Pods untereinander einzurichten. Alle Befehle, die in einer zweiten oder dritten Befehlsshell ausgeführt werden, werden in den Anleitungen des Befehls angegeben.

1. Öffnen Sie ein zweites Cloud Shell-Terminal. Jetzt haben Sie zwei Terminals: eines zum Ausführen des Befehls „kubectl port-forward“ und das andere zum Ausgeben von curl-Befehlen.

2. Führen Sie im zweiten Terminal den folgenden Befehl aus, um die Portweiterleitung einzurichten:

kubectl port-forward fortune-app 10080:8080

3. Starten Sie nun im ersten Terminal mithilfe von curl die Kommunikation mit Ihrem Pod:

curl http://127.0.0.1:10080

Sie haben einen Glückskeks von Ihrem Container erhalten.

4. Prüfen Sie nun mit dem Befehl curl, was geschieht, wenn Sie einen sicheren Endpunkt ansteuern: Für diesen Endpunkt ist eine Authentifizierung erforderlich.

curl http://127.0.0.1:10080/secure

Sie erhalten den Fehler „Unauthorized“, was erwartet wird.

5. Melden Sie sich an, um ein „auth“-Token von der App zu erhalten:

curl -u user http://127.0.0.1:10080/login

6. Geben Sie das Passwort password ein, wenn die Anmeldeaufforderung angezeigt wird.

Bei der Anmeldung wird ein JWT-Token zurückgegeben.

7. Da das Kopieren langer Strings in Cloud Shell mühsam ist, erstellen Sie eine Umgebungsvariable für das Token.

TOKEN=$(curl -u user http://127.0.0.1:10080/login | jq -r '.token')

8. Geben Sie das Passwort password noch einmal ein, wenn Sie nach dem Hostpasswort gefragt werden.

9. Mit dem folgenden Befehl wird das Token kopiert und in den Befehl curl aufgenommen, um den sicheren Endpunkt anzusteuern:

curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:10080/secure

An dieser Stelle sollten Sie eine Antwort von der Anwendung erhalten, die Sie wissen lässt, dass alles wieder in Ordnung ist.

You have accessed the secure fortune!

10. Mit dem Befehl „kubectl logs“ können Sie die Logs für den Pod „fortune-app“ aufrufen.

kubectl logs fortune-app

11. Öffnen Sie ein drittes Terminal und lassen Sie sich mit dem Flag -f die Logs in einem Echtzeitstream anzeigen:

kubectl logs -f fortune-app

12. Sie sehen, dass die Logs im dritten Terminal aktualisiert werden, wenn Sie im ersten Terminal mit curl eine Interaktion mit „fortune-app“ starten:

curl http://127.0.0.1:10080

13. Verwenden Sie den Befehl „kubectl exec“, um eine interaktive Shell im Pod „fortune-app“ auszuführen. Das ist nützlich, wenn Sie innerhalb eines Containers Fehler beheben möchten:

kubectl exec fortune-app --stdin --tty -c fortune-app -- /bin/sh

14. So können Sie beispielsweise die externe Konnektivität mit dem Befehl „ping“ testen, sobald im Container „fortune-app“ eine Shell ausgeführt wird:

ping -c 3 google.com

15. Vergessen Sie nicht, sich abzumelden, wenn Sie die interaktive Shell nicht mehr benötigen.

exit

Wie Sie sehen, ist die Interaktion mit Pods genauso einfach wie die Verwendung des Befehls „kubectl“. Ganz gleich, ob Sie einen Container remote ansteuern müssen oder eine Shell für die Anmeldung benötigen – Kubernetes bietet alles für einen schnellen Einstieg.

Aufgabe 6: Dienste

Pods sind nicht als nichtflüchtiger Speicher konzipiert. Sie können aus vielen Gründen gestoppt oder gestartet werden, beispielsweise nach fehlgeschlagenen Aktivitäts- oder Bereitschaftsprüfungen. Dies führt zu einem Problem:

Was passiert, wenn Sie mit einer Gruppe von Pods kommunizieren möchten, die Pods aber nach einem Neustart eine andere IP-Adresse haben?

An dieser Stelle kommen Dienste ins Spiel. Dienste stellen stabile Endpunkte für Pods zur Verfügung.

Dienste orientieren sich bei der Ermittlung der für sie bestimmten Pods an Labels. Die Pods mit den korrekten Labels werden von den Diensten automatisch ausgewählt und verfügbar gemacht.

Welche Zugriffsebene für eine Gruppe von Pods jeweils gültig ist, hängt von der Art des Dienstes ab. Derzeit gibt es drei Arten:

• ClusterIP (intern): Dies ist der Standardtyp. Dieser Dienst ist nur im Cluster sichtbar.
• NodePort gibt jedem Knoten im Cluster eine extern zugängliche IP-Adresse.
• LoadBalancer: Ein Load Balancer des Cloud-Anbieters leitet den Traffic vom Dienst an die enthaltenen Knoten weiter.

Weitere Aufgaben:

• Dienst erstellen
• Mit der Labelauswahl eine begrenzte Gruppe von Pods extern verfügbar machen

Aufgabe 7: Dienst erstellen

Bevor Sie Dienste erstellen können, benötigen Sie einen sicheren Pod, der HTTPS-Traffic bewältigen kann.

1. Falls Sie das Verzeichnis gewechselt haben, kehren Sie in das Verzeichnis ~/orchestrate-with-kubernetes/kubernetes zurück:

cd ~/orchestrate-with-kubernetes/kubernetes

2. Sehen Sie sich die Konfigurationsdatei für den Dienst „secure-fortune-app“ an:

cat pods/secure-fortune.yaml

3. Erstellen Sie die „secure-fortune“-Pods und ihre Konfigurationsdaten:

kubectl create secret generic tls-certs --from-file tls/ kubectl create configmap nginx-proxy-conf --from-file nginx/proxy.conf kubectl create -f pods/secure-fortune.yaml

Jetzt haben Sie einen sicheren Pod und können ihn extern verfügbar machen. Zu diesem Zweck erstellen Sie einen Kubernetes-Dienst.

4. Sehen Sie sich die Konfigurationsdatei für den Dienst „fortune-app“ an:

cat services/fortune-app.yaml (Ausgabe): kind: Service apiVersion: v1 metadata: name: "fortune-app" spec: selector: app: "fortune-app" secure: "enabled" ports: - protocol: "TCP" port: 443 targetPort: 443 nodePort: 31000 type: NodePort </ql-code-block output> Hinweis:

Mithilfe einer Auswahl werden automatisch alle Pods mit den Labels „app: fortune app“ und „secure: enabled“ gefunden und verfügbar gemacht.

Sie müssen den Knotenport angeben, denn darüber wird der externe Traffic von Port 31000 zu „nginx“ (auf Port 443) geleitet. 5. Erstellen Sie mit dem Befehl „kubectl create“ den Dienst „fortune-app“ aus der Konfigurationsdatei: kubectl create -f services/fortune-app.yaml (Ausgabe): service/fortune-app created

Abgeschlossene Aufgabe testen

Klicken Sie unten auf Fortschritt prüfen. Wenn Sie die „fortune-app“-Pods und den Dienst erfolgreich erstellt haben, wird ein Testergebnis angezeigt.

„fortune-app“-Pods und -Dienst erstellen

Sie machen den Dienst über einen Port verfügbar. Es kann also zu Kollisionen kommen, wenn andere Anwendungen versuchen, eine Bindung zu Port 31000 herzustellen.

Normalerweise erledigt Kubernetes die Port-Zuweisung. In diesem Lab wählen Sie einen Port aus, damit sich Systemdiagnosen später einfacher konfigurieren lassen.

6. Leiten Sie mit dem Befehl „gcloud compute firewall-rules“ den Traffic an den Dienst „fortune-app“ am angegebenen Knotenport:

gcloud compute firewall-rules create allow-fortune-nodeport --allow tcp:31000

Abgeschlossene Aufgabe testen

Klicken Sie unten auf Fortschritt prüfen. Wenn Sie erfolgreich eine Firewallregel erstellt haben, die TCP-Traffic auf dem Port 31000 zulässt, wird ein Testergebnis angezeigt.

Traffic an den Dienst „fortune-app“ an dem angegebenen Knotenport leiten

Nun ist alles eingerichtet und Sie können den Dienst „secure-fortune“ ohne Portweiterleitung von außerhalb des Clusters ansteuern.

7. Rufen Sie zuerst eine externe IP-Adresse für einen der Knoten ab.

gcloud compute instances list

8. Versuchen Sie, den Dienst „secure-fortune“ mit curl anzusteuern:

curl -k https://<EXTERNAL_IP>:31000

Hoppla, das Zeitlimit ist abgelaufen. Woran liegt das?

Hinweis: Es ist Zeit für einen kurzen Wissenstest.

Beantworten Sie die unten aufgeführten Fragen. Verwenden Sie dafür die folgenden Befehle:

kubectl get services fortune-app

kubectl describe services fortune-app

Fragen:

Warum erhalten Sie keine Antwort vom Dienst „fortune-app“?

Wie viele Endpunkte hat der Dienst „fortune-app“?

Welche Labels muss ein Pod haben, damit er vom Dienst „fortune-app“ ausgewählt wird?

Tipp: Es hat mit Labels zu tun. Sie beheben das Problem im nächsten Abschnitt.

Aufgabe 8: Labels zu Pods hinzufügen

Der Dienst „fortune-app“ hat aktuell noch keine Endpunkte. Eine Möglichkeit, Probleme dieser Art zu beheben, ist eine Label-Abfrage mit dem Befehl „kubectl get pods“.

1. Wie Sie sehen, wird ein Pod mit dem Label „fortune-app“ ausgeführt:

kubectl get pods -l "app=fortune-app"

2. Für wie viele Pods gilt jedoch „app=fortune-app“ und „secure=enabled“?

kubectl get pods -l "app=fortune-app,secure=enabled"

Diese Label-Abfrage druckt keine Ergebnisse aus. Sie müssen das Label secure=enabled hinzufügen.

3. Fügen Sie dem „secure-fortune“-Pod mit dem Befehl „kubectl label“ das fehlende Label „secure=enabled“ hinzu. Prüfen Sie anschließend, ob die Labels aktualisiert wurden.

kubectl label pods secure-fortune 'secure=enabled' kubectl get pods secure-fortune --show-labels

4. Nun sind die Pods mit dem korrekten Label versehen. Sehen Sie sich jetzt eine Liste der Endpunkte des Dienstes „fortune-app“ an:

kubectl describe services fortune-app | grep Endpoints

Hier ist einer.

5. Rufen Sie eine externe IP-Adresse für einen der Knoten ab.

gcloud compute instances list

6. Versuchen Sie, den Dienst „secure-fortune“ mit curl anzusteuern:

curl -k https://<EXTERNAL_IP>:31000

Zack! Houston, wir haben Kontakt.

Abgeschlossene Aufgabe testen

Klicken Sie unten auf Fortschritt prüfen. Wenn Sie den Pods erfolgreich Labels hinzugefügt haben, wird ein Testergebnis angezeigt.

Labels zu Pods hinzufügen

Aufgabe 9: Deployments

Das Ziel dieses Labs ist es, Sie auf die Skalierung und Verwaltung von Containern in der Produktion vorzubereiten. Hier kommen Deployments ins Spiel. Sie können dafür sorgen, dass die Anzahl der ausgeführten Pods mit der vom Nutzer angegebenen Pod-Anzahl übereinstimmt.

Deployments haben vor allem den Vorteil, dass sie die Low-Level-Details der Verwaltung von Pods abstrahieren. In Deployments hinter den Kulissen werden Replikatsets für das Starten und Stoppen von Pods verwendet. Wenn Pods aktualisiert oder skaliert werden müssen, wird das vom Deployment gehandhabt. Es führt auch den Neustart von Pods durch, falls diese aus irgendeinem Grund ausfallen.

Hier ein kurzes Beispiel:

Pods sind an die Lebensdauer des Knotens gebunden, auf dem sie erstellt werden. Bei obigem Beispiel ist Knoten 3 und damit auch ein Pod ausgefallen. Das Deployment hat automatisch einen neuen Pod erstellt und diesen auf Knoten 2 gestartet. Damit entfällt für Sie die Aufgabe, manuell einen neuen Pod zu erstellen und einem Knoten zuzuordnen.

Das ist beeindruckend.

Jetzt bündeln wir alles, was Sie über Pods und Dienste gelernt haben, und teilen die Anwendung „fortune-app“ mithilfe von Deployments in kleinere Dienste auf.

Aufgabe 10: Deployments erstellen

Sie teilen die App „fortune-app“ jetzt in drei unabhängige Teile:

• auth – Generiert JWT-Token für authentifizierte Nutzer
• fortune – Gibt authentifizierten Nutzern Glückskeksnachrichten aus.
• frontend – Leitet den Traffic zu den Diensten „auth“ und „fortune“

Sie sind nun bereit, Deployments zu erstellen, und zwar eines pro Dienst. Anschließend definieren Sie interne Dienste für die Deployments „auth“ und „fortune“ sowie einen externen Dienst für das Deployment „frontend“. Damit können Sie danach mit Mikrodiensten genau wie mit „monolith“ interagieren, nur dass jedes Teil nun getrennt skaliert und bereitgestellt werden kann.

1. Beginnen Sie mit der Prüfung der Konfigurationsdatei des Deployments „auth“:

cat deployments/auth.yaml (Output) apiVersion: apps/v1 kind: Deployment metadata: name: auth spec: selector: matchLabels: app: auth replicas: 1 template: metadata: labels: app: auth spec: containers: - name: auth image: "us-central1-docker.pkg.dev/qwiklabs-resources/gsp-021-lab-images/auth-service:1.0.0" ports: - name: http containerPort: 8080

Das Deployment erstellt ein Replikat des Containers „auth“.

Wenn Sie den Befehl „kubectl create“ ausführen, um das Deployment „auth“ zu erstellen, wird ein Pod erstellt, der den Daten im Deployment-Manifest entspricht. Dies bedeutet, dass Sie die Anzahl der Pods skalieren können, indem Sie die im Feld „Replikate“ angegebene Zahl ändern.

2. Erstellen Sie nun das Deployment-Objekt:

kubectl create ‑f deployments/auth.yaml

3. Als Nächstes wird der Dienst für das Deployment „auth“ erstellt. Verwenden Sie dazu den Befehl „kubectl create“:

kubectl create ‑f services/auth.yaml

4. Wiederholen Sie diesen Schritt zur Erstellung und Freigabe des Deployments „fortune“:

kubectl create -f deployments/fortune-service.yaml kubectl create -f services/fortune-service.yaml

5. Und noch einmal, um das Deployment von „frontend“ zu erstellen und zur Verfügung zu stellen.

kubectl create configmap nginx-frontend-conf --from-file=nginx/frontend.conf kubectl create -f deployments/frontend.yaml kubectl create -f services/frontend.yaml Hinweis: Zum Erstellen von „frontend“ ist ein weiterer Schritt erforderlich, weil Sie einige Konfigurationsdaten im Container speichern müssen.

6. Rufen Sie die externe IP-Adresse aus „frontend“ ab und senden Sie den folgenden curl-Befehl an die Adresse:

kubectl get services frontend Hinweis: Es kann etwas dauern, bis die externe IP-Adresse generiert wird. Führen Sie den Befehl oben noch einmal aus, falls die Spalte EXTERNAL-IP den Status „Ausstehend“ aufweist. curl -k https://<EXTERNAL-IP>

Und Sie erhalten eine Antwort.

Abgeschlossene Aufgabe testen

Klicken Sie unten auf Fortschritt prüfen. Wenn Sie „auth”, „fortune” und „frontend” erfolgreich bereitgestellt haben, wird ein Testergebnis angezeigt.

Deployments erstellen

Das wars!

Sie haben das Lab erfolgreich abgeschlossen. Sie haben mit Kubernetes eine Anwendung entwickelt, die mehrere Dienste umfasst. Mit den hier erworbenen Kenntnissen können Sie komplexe Anwendungen in Kubernetes bereitstellen, indem Sie mehrere Deployments und Dienste zusammenstellen.

Weitere Informationen

• Neuigkeiten zu Kubernetes finden Sie beim Kurznachrichtendienst X und im Community-Blog.
• Kubernetes ist ein Open-Source-Projekt (http://kubernetes.io/), das auf GitHub gehostet wird. Wir freuen uns also über Ihr Feedback und Ihre Beiträge.

Google Cloud-Schulungen und -Zertifizierungen

In unseren Schulungen erfahren Sie alles zum optimalen Einsatz unserer Google Cloud-Technologien und können sich entsprechend zertifizieren lassen. Unsere Kurse vermitteln technische Fähigkeiten und Best Practices, damit Sie möglichst schnell mit Google Cloud loslegen und Ihr Wissen fortlaufend erweitern können. Wir bieten On-Demand-, Präsenz- und virtuelle Schulungen für Anfänger wie Fortgeschrittene an, die Sie individuell in Ihrem eigenen Zeitplan absolvieren können. Mit unseren Zertifizierungen weisen Sie nach, dass Sie Experte im Bereich Google Cloud-Technologien sind.

Anleitung zuletzt am 11. August 2025 aktualisiert

Lab zuletzt am 11. August 2025 getestet

© 2025 Google LLC. Alle Rechte vorbehalten. Google und das Google-Logo sind Marken von Google LLC. Alle anderen Unternehmens- und Produktnamen können Marken der jeweils mit ihnen verbundenen Unternehmen sein.