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.

Hinweis: App wird auf GitHub gehostet und stellt eine 12-Faktor-Anwendung als Beispiel bereit. In diesem Lab arbeiten Sie mit den folgenden Docker-Images:

kelseyhightower/monolith – Monolith umfasst die Dienste „auth“ und „hello“.

kelseyhightower/auth – „auth“-Mikrodienst. Generiert für authentifizierte Nutzer ein JWT-Token.

kelseyhightower/hello – „hello“-Mikrodienst. Gibt authentifizierten Nutzern eine Grußmeldung aus.

nginx – Frontend für die Dienste „auth“ und „hello“.

Lernziele

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 die Ressourcen für das Lab verfügbar sind.

In diesem praxisorientierten Lab können Sie die Lab-Aktivitäten in einer echten Cloud-Umgebung selbst 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, 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: Wenn Sie über ein persönliches Google Cloud-Konto oder -Projekt verfügen, verwenden Sie es nicht für dieses Lab. So werden zusätzliche Kosten für Ihr Konto vermieden.

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 Pop-up-Fenster 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 sich eine Liste der Google Cloud-Produkte und ‑Dienste ansehen möchten, klicken Sie oben links auf das Navigationsmenü.

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 .

Wenn Sie verbunden sind, sind Sie bereits authentifiziert und das Projekt ist auf Ihre 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.

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

gcloud auth list

3. 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`

4. (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

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

gsutil 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: Kurzdemo zu Kubernetes

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.10.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 die unterbrechungsfreie Ausführung von Pods gewährleisten, 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.

Einen 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.

In unserem Beispiel gibt es 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 „monolith“ genauer anzusehen.

1. Rufen Sie das Verzeichnis auf:

cd ~/orchestrate-with-kubernetes/kubernetes

2. Führen Sie den folgenden Befehl aus:

cat pods/monolith.yaml

Die Ausgabe zeigt die geöffnete Konfigurationsdatei:

apiVersion: v1 kind: Pod metadata: name: monolith labels: app: monolith spec: containers: - name: monolith image: kelseyhightower/monolith:1.0.0 args: - "-http=0.0.0.0:80" - "-health=0.0.0.0:81" - "-secret=secret" ports: - name: http containerPort: 80 - name: health containerPort: 81 resources: limits: cpu: 0.2 memory: "10Mi"

Folgende Punkte sind besonders zu beachten:

• Der Pod besteht aus einem Container („monolith“).
• Beim Start werden dem Container einige Argumente übergeben.
• Sie öffnen Port 80 für HTTP-Traffic.

3. Erstellen Sie den Pod „monolith“ mit kubectl:

kubectl create -f pods/monolith.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 „monolith“ gestartet und ausgeführt wird. Das Image des „monolith“-Containers muss erst vom Docker Hub abgerufen werden, bevor es ausgeführt werden kann.

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

kubectl describe pods monolith

Es werden zahlreiche Informationen zum Pod „monolith“ 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 „monolith“ einen lokalen Port zuordnen.

Hinweis: An dieser Stelle des Labs werden Sie aufgefordert, in mehreren Cloud Shell-Tabs zu 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 monolith 10080:80

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

curl http://127.0.0.1:10080

Sehr gut. Sie haben ein freundliches „hello“ von Ihrem Container erhalten.

4. Prüfen Sie nun mit dem Befehl curl was geschieht, wenn Sie einen sicheren Endpunkt ansteuern:

curl http://127.0.0.1:10080/secure

Huch!

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

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

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

Nach der Anmeldung wurde ein JWT-Token ausgegeben.

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

TOKEN=$(curl http://127.0.0.1:10080/login -u user|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 uns wissen lässt, dass alles wieder in Ordnung ist.

10. Mit dem Befehl kubectl logs können Sie sich die Logs für den Pod monolith anzeigen lassen.

kubectl logs monolith

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

kubectl logs -f monolith

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

curl http://127.0.0.1:10080

13. Verwenden Sie den Befehl kubectl exec, um eine interaktive Shell im Pod „monolith“ auszuführen. Sie kann nützlich sein, wenn Sie innerhalb eines Containers eine Fehlerbehebung machen möchten:

kubectl exec monolith --stdin --tty -c monolith -- /bin/sh

14. So können Sie beispielsweise die externe Konnektivität mit dem Befehl ping testen, sobald im Container „monolith“ 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): Der Dienst ist nur im Cluster sichtbar. Dies ist die Standardzugriffsebene.
• NodePort: Jeder Knoten im Cluster erhält eine extern zugängliche IP-Adresse.
• LoadBalancer: Ein Load Balancer des Cloudanbieters leitet den Traffic vom Dienst an die enthaltenen Knoten weiter.

Weitere Aufgaben:

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

Aufgabe 7: Dienste 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. Prüfen Sie die Konfigurationsdatei für den Dienst „monolith“:

cat pods/secure-monolith.yaml

3. Erstellen Sie die „secure-monolith“-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-monolith.yaml

Jetzt haben Sie einen sicheren Pod und können den Pod „secure-monolith“ extern verfügbar machen. Erstellen Sie dazu einen Kubernetes-Dienst.

4. Prüfen Sie die Konfigurationsdatei für den Dienst „monolith“:

cat services/monolith.yaml

(Ausgabe):

kind: Service apiVersion: v1 metadata: name: "monolith" spec: selector: app: "monolith" secure: "enabled" ports: - protocol: "TCP" port: 443 targetPort: 443 nodePort: 31000 type: NodePort Hinweise:

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

* Sie müssen nun 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 „monolith“ aus der Konfigurationsdatei:

kubectl create -f services/monolith.yaml

(Ausgabe):

service/monolith created

Abgeschlossene Aufgabe testen

Klicken Sie unten auf Fortschritt prüfen. Wenn Sie den Pod „monolith“ erfolgreich erstellt haben, wird ein Testergebnis angezeigt.

„Monolith“-Pods und Dienste 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. Für dieses Lab wählen Sie jedoch einen Port aus, damit die Konfiguration der Systemdiagnosen später einfacher ist.

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

gcloud compute firewall-rules create allow-monolith-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 „monolith“ an angegebenen Knotenport leiten

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

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

gcloud compute instances list

2. Versuchen Sie nun, den Dienst „secure-monolith“ 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 monolith

kubectl describe services monolith

Fragen:

Warum erhalten Sie keine Antwort vom Dienst „monolith“?

Wie viele Endpunkte hat der Dienst „monolith“?

Welche Labels muss ein Pod haben, damit er vom Dienst „monolith“ 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 „monolith“ 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, werden einige Pods mit dem Label „monolith“ ausgeführt.

kubectl get pods -l "app=monolith"

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

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

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

3. Fügen Sie dem „secure-monolith“-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-monolith 'secure=enabled' kubectl get pods secure-monolith --show-labels

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

kubectl describe services monolith | grep Endpoints

Hier ist einer!

5. Testen Sie ihn, indem Sie noch einmal einen der Knoten ansteuern.

gcloud compute instances list curl -k https://<EXTERNAL_IP>:31000

Zack! Houston, wir haben Kontakt.

Abgeschlossene Aufgabe testen

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

Labels zu Pods hinzufügen

Aufgabe 9: Anwendungen mit Kubernetes bereitstellen

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 „monolith“ mithilfe von Deployments in kleinere Dienste auf.

Aufgabe 10: Deployments erstellen

Sie teilen die Anwendung „monolith“ jetzt in drei unabhängige Teile:

• auth – Generiert JWT-Token für authentifizierte Nutzer
• hello – Grüßt authentifizierte Nutzer
• frontend – Leitet den Traffic zu den Diensten „auth“ und „hello“

Sie sind nun bereit, Deployments zu erstellen, und zwar eines pro Dienst. Anschließend definieren Sie interne Dienste für die Deployments „auth“ und „hello“ 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

(Ausgabe)

apiVersion: apps/v1 kind: Deployment metadata: name: auth spec: selector: matchlabels: app: auth replicas: 1 template: metadata: labels: app: auth track: stable spec: containers: - name: auth image: "kelseyhightower/auth:2.0.0" ports: - name: http containerPort: 80 - name: health containerPort: 81 ...

Das Deployment erstellt ein Replikat und Sie verwenden Version 2.0.0 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. Unabhängig davon erstellen wir 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 „hello“:

kubectl create -f deployments/hello.yaml kubectl create -f services/hello.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>

Die Antwort „hello“ wird zurückgegeben.

Abgeschlossene Aufgabe testen

Klicken Sie unten auf Fortschritt prüfen. Wenn Sie Auth, Hello und Frontend erfolgreich bereitgestellt haben, wird ein Testergebnis angezeigt.

Deployments (Auth, Hello und Frontend) erstellen

Glückwunsch!

Glückwunsch! 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 bei dem 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 29. April 2024 aktualisiert

Lab zuletzt am 29. April 2024 getestet

© 2024 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.