GSP005

Übersicht

Ziel dieses praxisorientierten Labs ist es, den von Ihnen entwickelten Code in eine in Kubernetes ausführbare, replizierte Anwendung umzuwandeln, die in Kubernetes Engine ausgeführt wird. In diesem Lab ist der Code eine einfache Hello World node.js-Anwendung.

Damit Sie besser verstehen, wie die einzelnen Teile zusammenpassen, werden im folgenden Diagramm die verschiedenen Abschnitte dieses Lab veranschaulicht. Verwenden Sie es als Referenz, während Sie das Lab absolvieren. Am Ende des Labs sollte alles schlüssig sein (fürs Erste können Sie es jedoch auch einfach ignorieren).

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 Maschinen bis hin zu Bare-Metal-Maschinen.

Durch eine verwaltete Umgebung wie Kubernetes Engine (eine von Google gehostete Version von Kubernetes auf Compute Engine) können Sie sich stärker auf die Verwendung von Kubernetes konzentrieren, anstatt sich mit dem Einrichten der zugrunde liegenden Infrastruktur zu beschäftigen.

Lerninhalte

• Node.js-Server erstellen
• Container-Image in Docker erstellen
• Container-Cluster erstellen
• Kubernetes-Pod erstellen
• Dienste skalieren

Vorbereitung

• Nach Möglichkeit Erfahrung mit standardmäßigen Linux-Texteditoren wie Vim, Emacs oder Nano.

Wir empfehlen den Teilnehmerinnen und Teilnehmern, die Befehle selbst einzugeben, damit sie die wichtigsten Konzepte schneller erlernen. In vielen Labs gibt es einen Codeblock, der die erforderlichen Befehle enthält. Sie können die Befehle einfach aus dem Codeblock herauskopieren und im Verlauf des Labs an den entsprechenden Stellen einfügen.

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 rechten Seite befindet sich der Bereich Lab-Einrichtung und ‑Zugriff:

   • Button Google Cloud Console öffnen
   • Die temporären Anmeldedaten (Nutzername und Passwort), die Sie für dieses Lab verwenden müssen
   • Gegebenenfalls weitere Informationen für dieses Lab

   Der Lab-Timer befindet sich oben auf der Seite und zeigt die verbleibende Zeit an.

2. Klicken Sie auf Google Cloud Console öffnen. Wenn Sie Chrome verwenden, können Sie auch rechtsklicken und Link in Inkognitofenster öffnen auswählen.

   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 Lab-Einrichtung und ‑Zugriff.

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 Lab-Einrichtung und ‑Zugriff.

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

Aufgabe 1: Node.js-Anwendung erstellen

1. Schreiben Sie mit der Cloud Shell einen einfachen Node.js-Server, den Sie in Kubernetes Engine bereitstellen:

vi server.js

2. Öffnen Sie den Editor:

i

3. Sie müssen die Datei um Folgendes ergänzen:

var http = require('http'); var handleRequest = function(request, response) { response.writeHead(200); response.end("Hello World!"); } var www = http.createServer(handleRequest); www.listen(8080); Hinweis: Hier wird vi verwendet, aber nano und emacs sind ebenfalls in der Cloud Shell verfügbar. Sie können auch den Webeditor der Cloud Shell verwenden, wie im Leitfaden zur Funktionsweise der Cloud Shell beschrieben.

4. Speichern Sie die Datei server.js. Drücken Sie Esc und geben Sie dann Folgendes ein:

:wq

5. Da in der Cloud Shell die ausführbare node-Datei bereits installiert ist, führen Sie den folgenden Befehl aus, um den Knotenserver zu starten (der Befehl erzeugt keine Ausgabe):

node server.js

6. Mit der integrierten Webvorschaufunktion von Cloud Shell können Sie einen neuen Tab im Browser öffnen und eine Anfrage an die Instanz senden, die Sie gerade auf Port 8080 gestartet haben.

Die Ergebnisse werden im Browser in einem neuen Tab angezeigt:

7. Ehe Sie fortfahren, gehen Sie zurück in Cloud Shell und geben Sie Strg+C ein, um den Knotenserver anzuhalten.

Als Nächstes verpacken Sie diese Anwendung in einem Docker-Container.

Aufgabe 2: Docker-Container-Image erstellen

1. Erstellen Sie als Nächstes ein Dockerfile, das das zu erstellende Image beschreibt. Docker-Container-Images können von anderen vorhandenen Images abgeleitet werden. Dieses Image leiten wir von einem vorhandenen Node-Image ab:

vi Dockerfile

2. Öffnen Sie den Editor:

i

3. Fügen Sie Folgendes hinzu:

FROM node:6.9.2 EXPOSE 8080 COPY server.js . CMD ["node", "server.js"]

Dieses „Schema“ für das Docker-Image wird:

• mit dem Knoten-Image auf dem Docker Hub beginnen.
• Port 8080 freigeben.
• die Datei server.js in das Image kopieren.
• den Knotenserver starten, den wir zuvor manuell gestartet haben.

4. Speichern Sie dieses Dockerfile mit der Esc-Taste und geben Sie dann Folgendes ein:

:wq

5. Erstellen Sie das Image mit dem folgenden Befehl:

docker build -t hello-node:v1 .

Es dauert einige Zeit, alles herunterzuladen und zu extrahieren. Sie können aber die Fortschrittsanzeige sehen, während das Image erstellt wird.

Anschließend testen Sie das Image lokal, indem Sie einen Docker-Container als Daemon von Ihrem neu erstellten Container-Image auf Port 8080 ausführen.

6. Führen Sie den Docker-Container mit diesem Befehl aus:

docker run -d -p 8080:8080 hello-node:v1

Die Ausgabe sollte in etwa so aussehen:

325301e6b2bffd1d0049c621866831316d653c0b25a496d04ce0ec6854cb7998

7. Verwenden Sie die Webvorschau der Cloud Shell, um die Ergebnisse zu sehen. Oder verwenden Sie curl in Ihrem Cloud Shell-Prompt:

curl http://localhost:8080

Dies ist die Ausgabe, die Sie sehen sollten:

Hello World! Hinweis: Die vollständige Dokumentation zum Befehl docker run finden Sie in der Docker-Referenz zu „run“.

Halten Sie als Nächstes den laufenden Container an.

1. Suchen Sie mit dem folgenden Befehl nach Ihrer Docker-Container-ID:

docker ps

Die Ausgabe sollte in etwa so aussehen:

CONTAINER ID IMAGE COMMAND 2c66d0efcbd4 hello-node:v1 "/bin/sh -c 'node

2. Halten Sie den Container an, indem Sie den folgenden Befehl ausführen und die [CONTAINER ID] durch den Wert aus dem vorherigen Schritt ersetzen:

docker stop [CONTAINER ID]

Die Konsolenausgabe sollte in etwa so aussehen (Ihre Container-ID):

2c66d0efcbd4

Wenn das Image wie gewünscht funktioniert, laden Sie es in Google Artifact Registry hoch. Dies ist ein privates Repository für Docker-Images, auf das von Ihren Google Cloud-Projekten aus zugegriffen werden kann.

1. Zuerst müssen Sie ein Repository in Artifact Registry erstellen. Nennen wir es my-docker-repo. Führen Sie dazu diesen Befehl aus:

gcloud artifacts repositories create my-docker-repo \ --repository-format=docker \ --location={{{ project_0.default_region | YOUR_REGION }}} \ --project={{{ project_0.project_id | YOUR_PROJECT_ID }}}

2. Führen Sie nun den folgenden Befehl aus, um die Docker-Authentifizierung zu konfigurieren.

gcloud auth configure-docker

Wenn Sie gefragt werden, ob Sie fortfahren möchten (Do you want to continue (Y/N)?), geben Sie Y ein.

3. Führen Sie diesen Befehl aus, um Ihr Image mit dem Repository-Namen zu taggen. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID, die Sie in der Console oder im Abschnitt Details zum Lab des Labs finden:

docker tag hello-node:v1 {{{ project_0.default_region | YOUR_REGION }}}-docker.pkg.dev/{{{ project_0.project_id | YOUR_PROJECT_ID }}}/my-docker-repo/hello-node:v1

4. Pushen Sie Ihr Container-Image in das Repository, indem Sie den folgenden Befehl ausführen:

docker push {{{ project_0.default_region | YOUR_REGION }}}-docker.pkg.dev/{{{ project_0.project_id | YOUR_PROJECT_ID }}}/my-docker-repo/hello-node:v1

Das erste Hochladen kann einige Minuten dauern. Dabei können Sie die Fortschrittsanzeige sehen.

The push refers to a repository [pkg.dev/qwiklabs-gcp-6h281a111f098/hello-node] ba6ca48af64e: Pushed 381c97ba7dc3: Pushed 604c78617f34: Pushed fa18e5ffd316: Pushed 0a5e2b2ddeaa: Pushed 53c779688d06: Pushed 60a0858edcd5: Pushed b6ca02dfe5e6: Pushed v1: digest: sha256:8a9349a355c8e06a48a1e8906652b9259bba6d594097f115060acca8e3e941a2 size: 2002

3. Das Container-Image wird in der Console aufgelistet. Klicken Sie auf das Navigationsmenü > Alle Produkte ansehen. Wählen Sie dann unter CI/CD die Option Artifact Registry aus.

Nun steht Ihnen ein projektübergreifendes Docker-Image zur Verfügung, auf das Kubernetes zugreifen und das es orchestrieren kann.

Hinweis:Wir haben die empfohlene Vorgehensweise für die Arbeit mit Artifact Registry verwendet, bei der die zu verwendende Region angegeben wird. Weitere Informationen finden Sie unter Images in Artifact Registry hoch- und herunterladen.

Aufgabe 3: Cluster erstellen

Jetzt können Sie Ihren Kubernetes Engine-Cluster erstellen. Ein Cluster besteht aus einem von Google gehosteten Kubernetes-Master-API-Server und einer Reihe von Worker-Knoten. Bei den Worker-Knoten handelt es sich um virtuelle Compute Engine-Maschinen.

1. Achten Sie darauf, dass Sie Ihr Projekt mit gcloud festgelegt haben. Ersetzen Sie PROJECT_ID durch Ihre Projekt-ID, die Sie in der Console und im Abschnitt Details zum Lab des Labs finden:

gcloud config set project PROJECT_ID

2. Erstellen Sie einen Cluster mit zwei Knoten des Typs e2-medium. Das kann einige Minuten dauern:

gcloud container clusters create hello-world \ --num-nodes 2 \ --machine-type e2-medium \ --zone "{{{project_0.default_zone|ZONE}}}"

Warnungen, die beim Erstellen des Clusters angezeigt werden, können Sie ignorieren.

Die Console-Ausgabe sollte in etwa so aussehen:

Creating cluster hello-world...done. Created [https://container.googleapis.com/v1/projects/PROJECT_ID/zones/"{{{project_0.default_zone|ZONE}}}"/clusters/hello-world]. kubeconfig entry generated for hello-world. NAME ZONE MASTER_VERSION MASTER_IP MACHINE_TYPE STATUS hello-world "{{{project_0.default_zone|ZONE}}}" 1.5.7 146.148.46.124 e2-medium RUNNING

Alternativ können Sie diesen Cluster auch über die Console erstellen. Öffnen Sie dazu das Navigationsmenü und wählen Sie Kubernetes Engine > Cluster > Erstellen aus.

Hinweis:Es wird empfohlen, den Cluster in derselben Zone wie den von der Artifact Registry verwendeten Storage-Bucket zu erstellen (siehe vorheriger Schritt).

Wenn Sie Navigationsmenü > Kubernetes Engine > Cluster auswählen, sehen Sie, dass Sie einen voll funktionsfähigen Kubernetes-Cluster haben, der von Kubernetes Engine bereitgestellt wird.

Als Nächstes stellen Sie Ihre eigene containerisierte Anwendung für den Kubernetes-Cluster bereit. Ab jetzt verwenden Sie die Befehlszeile kubectl, die bereits in Ihrer Cloud Shell-Umgebung eingerichtet ist.

Klicken Sie unten auf Fortschritt prüfen.

Cluster erstellen

Aufgabe 4: Pod erstellen

Bei einem Kubernetes-Pod handelt es sich um eine Gruppe von Containern, die zu Administrations- und Netzwerkzwecken zusammengebunden sind. Er kann einen einzigen oder mehrere Container enthalten. Hier verwenden Sie einen Container, der mit Ihrem Node.js-Image erstellt wurde, das in Ihrer privaten Artifact Registry gespeichert ist. Er stellt Inhalte auf Port 8080 bereit.

1. Erstellen Sie eine Bereitstellung mit dem Befehl kubectl create deployment. Ersetzen Sie dabei PROJECT_ID durch Ihre Projekt-ID, die Sie in der Console und im Abschnitt Verbindungsinformationen des Labs finden:

kubectl create deployment hello-node \ --image={{{ project_0.default_region}}}-docker.pkg.dev/PROJECT_ID/my-docker-repo/hello-node:v1

Ausgabe:

deployment.apps/hello-node created

Wie Sie sehen, haben Sie ein Deployment-Objekt erstellt. Zum Erstellen und Skalieren von Pods werden Deployments empfohlen. Ein neues Deployment verwaltet hier ein einzelnes Pod-Replikat, auf dem das Image hello-node:v1 ausgeführt wird.

2. Mit dem folgenden Befehl können Sie sich die Bereitstellung ansehen:

kubectl get deployments

Ausgabe:

NAME READY UP-TO-DATE AVAILABLE AGE hello-node 1/1 1 1 1m36s

3. Führen Sie den folgenden Befehl aus, um sich den Pod anzeigen zu lassen, der durch das Deployment erstellt wurde:

kubectl get pods

Ausgabe:

NAME READY STATUS RESTARTS AGE hello-node-714049816-ztzrb 1/1 Running 0 6m

An dieser Stelle empfiehlt es sich, einige interessante kubectl-Befehle durchzugehen. Dadurch ändert sich der Status des Clusters nicht. Die vollständige Referenzdokumentation finden Sie unter Befehlszeilentool (kubectl):

kubectl cluster-info kubectl config view

Zur Fehlerbehebung:

kubectl get events kubectl logs <pod-name>

Sie müssen jetzt den Pod für die Außenwelt zugänglich machen.

Klicken Sie unten auf Fortschritt prüfen.

Pod erstellen

Aufgabe 5: Externen Traffic zulassen

Standardmäßig kann nur die interne IP innerhalb des Clusters auf den Pod zugreifen. Damit der hello-node-Container von außerhalb des virtuellen Kubernetes-Netzwerks zugänglich wird, muss der Pod als Kubernetes-Dienst zur Verfügung gestellt werden.

1. Von Cloud Shell aus können Sie den Pod mit dem Befehl kubectl expose und dem Flag --type="LoadBalancer" dem öffentlichen Internet zugänglich machen. Dieses Flag wird für die Erstellung einer extern zugänglichen IP-Adresse benötigt:

kubectl expose deployment hello-node --type="LoadBalancer" --port=8080

Ausgabe:

service/hello-node exposed

Das in diesem Befehl verwendete Flag gibt an, dass der Load Balancer genutzt wird, der von der zugrundeliegenden Infrastruktur bereitgestellt wird. Das ist in diesem Fall der Compute Engine-Load-Balancer. Sie machen das Deployment und nicht den Pod direkt verfügbar. Als Folge führt der resultierende Dienst das Load Balancing des Traffics für alle vom Deployment verwalteten Pods durch (in diesem Fall nur für einen Pod, später werden jedoch weitere Replikate hinzugefügt).

Der Kubernetes-Master erstellt den Load Balancer und die zugehörigen Compute Engine-Weiterleitungsregeln, Zielpools und Firewallregeln, um den Dienst von außerhalb der Google Cloud Platform vollständig zugänglich zu machen.

2. Um die öffentlich zugängliche IP-Adresse des Dienstes zu finden, fordern Sie von kubectl an, alle Clusterdienste aufzulisten:

kubectl get services

Dies ist die Ausgabe, die Sie sehen sollten:

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-node 10.3.250.149 104.154.90.147 8080/TCP 1m kubernetes 10.3.240.1 < none > 443/TCP 5m

Für Ihren hello-node-Dienst sind zwei IP-Adressen aufgelistet, die beide Port 8080 bedienen. Die CLUSTER-IP ist die interne IP, die nur in Ihrem virtuellen Cloudnetzwerk sichtbar ist. Die EXTERNAL-IP ist die externe Load-Balancer-IP.

Hinweis: Es kann einige Minuten dauern, bis die EXTERNAL-IP verfügbar und sichtbar ist. Wenn die EXTERNAL-IP fehlt, warten Sie einige Minuten und führen Sie den Befehl noch einmal aus.

3. Sie sollten den Dienst jetzt erreichen können. Verweisen Sie dazu Ihren Browser auf diese Adresse: http://<EXTERNAL_IP>:8080

Jetzt haben Sie schon einige zusätzliche Funktionen dadurch erhalten, dass Sie zu Containern und Kubernetes übergegangen sind. Sie müssen nicht festlegen, auf welchem Host die Arbeitslast ausgeführt werden soll, und profitieren außerdem von der Überwachung und dem Neustart von Diensten. Sehen Sie sich an, welche Vorteile Ihnen die neue Kubernetes-Infrastruktur noch bringt.

Klicken Sie unten auf Fortschritt prüfen.

Kubernetes-Dienst erstellen

Aufgabe 6: Dienst skalieren

Eine der leistungsstarken Funktionen von Kubernetes ist die einfache Skalierbarkeit Ihrer Anwendung. Falls Sie plötzlich mehr Kapazität benötigen, können Sie den Replikationscontroller anweisen, eine neue Anzahl von Replikaten für Ihren Pod zu verwalten.

1. Legen Sie die Anzahl der Replikate für Ihren Pod fest:

kubectl scale deployment hello-node --replicas=4

Ausgabe:

deployment.apps/hello-node scaled

2. Fordern Sie eine Beschreibung der aktualisierten Bereitstellung an:

kubectl get deployment

Ausgabe:

NAME READY UP-TO-DATE AVAILABLE AGE hello-node 4/4 4 4 16m

Führen Sie den obigen Befehl noch einmal aus, bis alle vier Replikate erstellt wurden.

3. Listen Sie alle Pods auf:

kubectl get pods

Dies ist die Ausgabe, die Sie sehen sollten:

NAME READY STATUS RESTARTS AGE hello-node-714049816-g4azy 1/1 Running 0 1m hello-node-714049816-rk0u6 1/1 Running 0 1m hello-node-714049816-sh812 1/1 Running 0 1m hello-node-714049816-ztzrb 1/1 Running 0 16m

Hier wird ein deklarativer Ansatz verwendet. Anstatt neue Instanzen zu starten oder anzuhalten, deklarieren Sie, wie viele Instanzen zu jeder Zeit ausgeführt werden sollen. Die Abstimmungsschleifen von Kubernetes sorgen dafür, dass dies tatsächlich passiert und bei Bedarf Maßnahmen ergriffen werden.

Im folgenden Diagramm ist der Zustand Ihres Kubernetes-Clusters zusammengefasst:

Klicken Sie unten auf Fortschritt prüfen.

Dienst vertikal skalieren

Aufgabe 7: Upgrade für Ihren Dienst bereitstellen

Früher oder später sind für die Anwendung, die Sie für die Produktion bereitgestellt haben, Fehlerbehebungen oder zusätzliche Funktionen erforderlich. Kubernetes unterstützt Sie bei der Bereitstellung einer neuen Version für die Produktion, ohne Ihre Nutzerinnen und Nutzer zu beeinträchtigen.

1. Ändern Sie zuerst die Anwendung, indem Sie server.js öffnen:

vi server.js i

2. Aktualisieren Sie dann die Antwortnachricht:

response.end("Hello Kubernetes World!");

3. Speichern Sie die Datei server.js. Drücken Sie Esc und geben Sie dann Folgendes ein:

:wq

Jetzt können Sie ein neues Container-Image mit einer heraufgesetzten Versionsnummer in der Registry erstellen und veröffentlichen (in diesem Fall v2).

4. Führen Sie die folgenden Befehle aus und ersetzen Sie PROJECT_ID durch Ihre Projekt-ID für das Lab:

docker build -t hello-node:v2 . docker tag hello-node:v2 {{{ project_0.default_region | YOUR_REGION }}}-docker.pkg.dev/{{{ project_0.project_id | YOUR_PROJECT_ID }}}/my-docker-repo/hello-node:v2 docker push {{{ project_0.default_region | YOUR_REGION }}}-docker.pkg.dev/{{{ project_0.project_id | YOUR_PROJECT_ID }}}/my-docker-repo/hello-node:v2 Hinweis: Das Erstellen und Hochladen dieses aktualisierten Images sollte dank Caching deutlich schneller gehen.

Kubernetes aktualisiert Ihren Replikationscontroller reibungslos auf die neue Version der Anwendung. Um das Image-Label Ihres Containers zu ändern, müssen Sie das bestehende hello-node-Deployment beenden und das Image von pkg.dev/PROJECT_ID/hello-node:v1 zu pkg.dev/PROJECT_ID/hello-node:v2 ändern.

1. Verwenden Sie dazu den Befehl kubectl edit:

kubectl edit deployment hello-node

Es öffnet sich ein Texteditor, der die vollständige Deployment-yaml-Konfiguration enthält. Sie müssen nicht auf Anhieb die gesamte yaml-Konfiguration verstehen. Es reicht, wenn Ihnen klar ist, dass Sie durch die Aktualisierung des Felds spec.template.spec.containers.image in der Konfiguration das Deployment anweisen, die Pods mit dem neuen Image zu aktualisieren.

2. Suchen Sie nach Spec > containers > image und ändern Sie die Versionsnummer von v1 in v2:

# Please edit the object below. Lines beginning with a '#' will be ignored, # and an empty file will abort the edit. If an error occurs while saving this file will be # reopened with the relevant failures. # apiVersion: apps/v1 kind: Deployment metadata: annotations: deployment.kubernetes.io/revision: "1" creationTimestamp: 2016-03-24T17:55:28Z generation: 3 labels: run: hello-node name: hello-node namespace: default resourceVersion: "151017" uid: 981fe302-f1e9-11e5-9a78-42010af00005 spec: replicas: 4 selector: matchLabels: run: hello-node strategy: rollingUpdate: maxSurge: 1 maxUnavailable: 1 type: RollingUpdate template: metadata: creationTimestamp: null labels: run: hello-node spec: containers: - image: pkg.dev/PROJECT_ID/hello-node:v1 ## Update this line ## imagePullPolicy: IfNotPresent name: hello-node ports: - containerPort: 8080 protocol: TCP resources: {} terminationMessagePath: /dev/termination-log dnsPolicy: ClusterFirst restartPolicy: Always securityContext: {} terminationGracePeriodSeconds: 30

3. Speichern Sie die Änderung und schließen Sie die Datei. Drücken Sie die Esc-Taste und geben Sie Folgendes ein:

:wq

Dies ist die Ausgabe, die Sie sehen sollten:

deployment.apps/hello-node edited

4. Führen Sie den folgenden Befehl aus, um das Deployment mit dem neuen Image zu aktualisieren.

kubectl get deployments

Neue Pods werden mit dem neuen Image erstellt und die alten Pods werden gelöscht.

Die Ausgabe sollte so aussehen (möglicherweise müssen Sie den obigen Befehl noch einmal ausführen, um die folgende Ausgabe zu sehen):

NAME READY UP-TO-DATE AVAILABLE AGE hello-node 4/4 4 4 1h

Während dies geschieht, sollten die Nutzerinnen und Nutzer Ihrer Dienste keine Unterbrechung wahrnehmen. Nach einer Weile können sie auf die neue Version Ihrer Anwendung zugreifen. Weitere Informationen zu Rolling Updates finden Sie in der Dokumentation zum Ausführen von Rolling Updates.

Wenn Sie nach der Einrichtung Ihres Kubernetes Engine-Clusters mit diesen Bereitstellungs-, Skalierungs- und Aktualisierungsfunktionen vertraut sind, werden Sie feststellen, dass Kubernetes Ihnen dabei hilft, sich auf die Anwendung anstatt auf die Infrastruktur zu konzentrieren.

Das wars! Sie haben das Lab erfolgreich abgeschlossen.

Damit ist dieses praxisorientierte Lab mit Kubernetes abgeschlossen. Wir haben uns bisher nur an der Oberfläche dieser Technologie bewegt. Experimentieren Sie mit eigenen Pods, Replikationscontrollern und Diensten. Informieren Sie sich außerdem über Aktivitätsprüfungen (Systemdiagnosen) und verwenden Sie eventuell die Kubernetes API.

Weitere Informationen

• Nachdem Sie dieses Lab absolviert haben, sollten Sie sich Minikube ansehen. Damit lässt sich ein Kubernetes-Cluster mit einem einzelnen Knoten zu Entwicklungs- und Testzwecken ganz einfach einrichten: http://kubernetes.io/docs/getting-started-guides/minikube/.
• Kubernetes ist ein Open-Source-Projekt ( http://kubernetes.io/), das auf GitHub gehostet wird. Wir freuen uns über Ihr Feedback und Ihre Beiträge.
• Neuigkeiten zu Kubernetes erhalten Sie auf Twitter und im Community Blog.

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 9. Juni 2026 aktualisiert

Lab zuletzt am 9. Juni 2026 getestet

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