GSP051

Übersicht

In diesem Lab lernen Sie, wie Sie mit Jenkins in der Kubernetes Engine eine Continuous-Delivery-Pipeline einrichten. Jenkins ist ein verlässlicher Automatisierungsserver, den Entwicklerinnen und Entwickler verwenden, die ihren Code häufig in ein gemeinsames Repository einbinden. Die Lösung, die Sie in diesem Lab entwickeln, sieht in etwa so aus:

Weitere Informationen zum Ausführen von Jenkins in Kubernetes finden Sie im Cloud Architecture Center unter Moderne CI/CD mit der GKE: CI/CD-System erstellen.

Lerninhalte

Im Rahmen der folgenden Aufgaben erfahren Sie mehr über das Ausführen von Jenkins in Kubernetes:

• Eine Jenkins-Anwendung in einem Kubernetes Engine-Cluster bereitstellen
• Die Jenkins-Anwendung mithilfe des Helm-Paketmanagers einrichten
• Die Funktionen einer Jenkins-Anwendung kennenlernen
• Eine Jenkins-Pipeline erstellen und ausführen

Voraussetzungen

Dies ist ein Lab für Fortgeschrittene. Sie sollten dafür zumindest mit den Grundlagen der Shell-Programmierung, von Kubernetes sowie von Jenkins vertraut sein. In diesen Labs lernen Sie alles Nötige:

• Einführung in Docker
• Hello Node Kubernetes
• Deployments mit der Kubernetes Engine verwalten
• Jenkins in der Kubernetes Engine einrichten

Wenn Sie bereit sind, scrollen Sie nach unten, um mehr über Kubernetes, Jenkins und Continuous Delivery zu erfahren.

Was ist die Kubernetes Engine?

Die Kubernetes Engine ist die gehostete Kubernetes-Version von Google Cloud und ein leistungsfähiges Clusterverwaltungs- und Orchestrierungssystem für Container. Kubernetes ist ein Open-Source-Projekt, das sich in vielen verschiedenen Umgebungen ausführen lässt – von Laptops bis hin zu hochverfügbaren Clustern mit mehreren Knoten, von virtuellen Maschinen bis hin zu Bare-Metal-Maschinen. Wie bereits erwähnt, werden Kubernetes-Anwendungen auf Containern erstellt. Dabei handelt es sich um unkomplizierte Anwendungen, die mit allen für die Ausführung nötigen Abhängigkeiten und Bibliotheken ausgestattet sind. Dank dieser Grundstruktur sind Kubernetes-Anwendungen hochverfügbar, sicher und lassen sich schnell bereitstellen. Somit bieten sie ein ideales Framework für Cloud-Entwicklerinnen und -Entwickler.

Was ist Jenkins?

Jenkins ist ein Open-Source-Automatisierungsserver, mit dem Sie Build-, Test- und Deployment-Pipelines flexibel orchestrieren können. Mit Jenkins können Entwicklungsteams ihre Projekte schnell iterieren, ohne sich dabei Gedanken um den zusätzlichen Aufwand machen zu müssen, den Continuous Delivery mit sich bringen kann.

Was bedeutet Continuous Delivery / Continuous Deployment?

Wenn Sie eine Pipeline für Continuous Delivery (CD) einrichten müssen, bietet der Einsatz von Jenkins in der Kubernetes Engine wichtige Vorteile gegenüber einem standardmäßigen VM-basierten Deployment:

Wenn im Build-Prozess Container verwendet werden, kann ein virtueller Host Aufträge für verschiedene Betriebssysteme ausführen. Die Kubernetes Engine bietet sitzungsspezifische Build-Ausführungsprogramme. Diese werden nur genutzt, wenn die Builds aktiv ausgeführt werden. So stehen die restlichen Ressourcen für andere Aufgaben im Cluster zur Verfügung, etwa für Batchverarbeitung. Ein weiterer Vorteil sitzungsspezifischer Build-Ausführungsprogramme ist die Geschwindigkeit – sie starten innerhalb von Sekunden.

Die Kubernetes Engine ist außerdem mit dem globalen Load Balancer von Google ausgestattet, mit dem Sie die Weiterleitung von Webtraffic an Ihre Instanz(en) automatisieren können. Der Load Balancer steuert die SSL-Terminierung und verwendet eine globale IP-Adresse, die über das Backbonenetzwerk von Google mit Ihrem Web-Frontend verbunden ist und über die Nutzerinnen und Nutzer auf dem schnellstmöglichen Weg zu einer Anwendungsinstanz weitergeleitet werden.

Sie haben nun schon einiges über Kubernetes und Jenkins gelernt sowie darüber, wie die beiden in einer CD-Pipeline miteinander interagieren. Jetzt ist es an der Zeit, selbst eine zu erstellen.

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: Quellcode herunterladen

Im Rahmen dieser Aufgabe laden Sie den Quellcode für dieses Lab herunter.

1. Öffnen Sie eine neue Sitzung in der Cloud Shell und führen Sie den folgenden Befehl aus, um die Zone festzulegen:

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

2. Kopieren Sie im Anschluss den Lab-Beispielcode:

gcloud storage cp gs://spls/gsp051/continuous-deployment-on-kubernetes.zip . unzip continuous-deployment-on-kubernetes.zip

3. Wechseln Sie nun zum richtigen Verzeichnis:

cd continuous-deployment-on-kubernetes

Aufgabe 2: Jenkins bereitstellen

Sie erstellen einen Kubernetes-Cluster und ermöglichen Jenkins den Zugriff auf Google Cloud-Dienste und Google Artifact Registry.

Kubernetes-Cluster erstellen

1. Führen Sie nun den folgenden Befehl aus, um einen Kubernetes-Cluster bereitzustellen:

gcloud container clusters create jenkins-cd \ --num-nodes 2 \ --machine-type e2-standard-2 \ --scopes "https://www.googleapis.com/auth/source.read_write,cloud-platform"

Der Abschluss dieses Schritts kann mehrere Minuten dauern. Durch die zusätzlichen Bereiche kann Jenkins auf Google Cloud-Dienste und Google Artifact Registry zugreifen.

Klicken Sie auf Fortschritt prüfen. Wenn der Kubernetes-Cluster erstellt wurde, erhalten Sie ein Testergebnis.

Kubernetes-Cluster erstellen (Zone: )

2. Prüfen Sie vor dem Fortfahren mit dem folgenden Befehl, ob der Cluster ausgeführt wird:

gcloud container clusters list

Cluster mit Anmeldedaten versehen

1. Rufen Sie die Anmeldedaten für Ihren Cluster ab:

gcloud container clusters get-credentials jenkins-cd

2. Die Kubernetes Engine verwendet diese Anmeldeinformationen, um auf den neu bereitgestellten Cluster zuzugreifen. Prüfen Sie mithilfe des folgenden Befehls, ob Sie eine Verbindung herstellen können:

kubectl cluster-info

Aufgabe 3: Helm einrichten

Helm ist ein Paketmanager, mit dem sich Kubernetes-Anwendungen einfach konfigurieren und bereitstellen lassen. Nachdem Sie Jenkins installiert haben, können Sie Ihre CI/CD-Pipeline einrichten.

Im Rahmen dieser Aufgabe verwenden Sie Helm, um Jenkins aus dem Diagramm-Repository zu installieren.

1. Fügen Sie das stabile Helm-Diagramm-Repository hinzu:

helm repo add jenkins https://charts.jenkins.io

2. Prüfen Sie, ob das Repository auf dem neuesten Stand ist:

helm repo update

Aufgabe 4: Jenkins installieren und konfigurieren

Bei der Installation von Jenkins kann eine values-Datei als Vorlage verwendet werden, um Werte anzugeben, die für die Einrichtung erforderlich sind.

Sie verwenden eine benutzerdefinierte values-Datei, um die Kubernetes-Cloud automatisch zu konfigurieren und die folgenden erforderlichen Plug-ins hinzuzufügen:

• Kubernetes:latest
• Workflow-multibranch:latest
• Git:latest
• Configuration-as-code:latest
• Google-oauth-plugin:latest
• Google-source-plugin:latest
• Google-storage-plugin:latest

So kann Jenkins eine Verbindung zu Ihrem Cluster und Ihrem Google Cloud-Projekt herstellen.

1. Stellen Sie das Diagramm mit Ihren Konfigurationseinstellungen über die Helm-Befehlszeile bereit:

helm install cd jenkins/jenkins -f jenkins/values.yaml --wait

Das Ausführen dieses Befehls kann einige Minuten dauern.

Klicken Sie auf Fortschritt prüfen. Wenn das Jenkins-Diagramm konfiguriert wurde, erhalten Sie ein Testergebnis.

Jenkins konfigurieren und installieren

2. Führen Sie den folgenden Befehl aus und prüfen Sie anschließend, ob sich der Status des Jenkins-Pods in Running und der des Containers in READY geändert hat:

kubectl get pods

Beispielausgabe:

NAME READY STATUS RESTARTS AGE cd-jenkins-7c786475dd-vbhg4 2/2 Running 0 1m

3. Konfigurieren Sie das Jenkins-Dienstkonto für die Bereitstellung im Cluster:

kubectl create clusterrolebinding jenkins-deploy --clusterrole=cluster-admin --serviceaccount=default:cd-jenkins

Sie sollten folgende Ausgabe erhalten:

clusterrolebinding.rbac.authorization.k8s.io/jenkins-deploy created

4. Führen Sie den folgenden Befehl aus, um die Portweiterleitung von der Cloud Shell zur Jenkins-Benutzeroberfläche einzurichten:

export POD_NAME=$(kubectl get pods --namespace default -l "app.kubernetes.io/component=jenkins-master" -l "app.kubernetes.io/instance=cd" -o jsonpath="{.items[0].metadata.name}") kubectl port-forward $POD_NAME 8080:8080 >> /dev/null &

5. Prüfen Sie nun, ob der Jenkins-Dienst richtig erstellt wurde:

kubectl get svc

Beispielausgabe:

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE cd-jenkins 10.35.249.67 8080/TCP 3h cd-jenkins-agent 10.35.248.1 50000/TCP 3h kubernetes 10.35.240.1 443/TCP 9h

Sie verwenden das Kubernetes-Plug-in, damit die Builder-Knoten automatisch gestartet werden, wenn der Jenkins-Master sie anfordert. Wenn die Knoten nicht mehr benötigt werden, werden sie automatisch deaktiviert und die dadurch freigewordenen Ressourcen sind wieder im Ressourcenpool des Clusters.

Dieser Dienst macht die Ports 8080 und 50000 für jeden Pod verfügbar, der dem Selector entspricht. Dadurch werden die Web-UI von Jenkins und die Registrierungsports für den Builder/Agent innerhalb des Kubernetes-Clusters freigegeben. Außerdem wird der Dienst jenkins-ui mithilfe einer ClusterIP verfügbar gemacht, sodass von außerhalb des Clusters nicht darauf zugegriffen werden kann.

Aufgabe 5: Verbindung zu Jenkins herstellen

Sie rufen das Administratorpasswort ab und melden sich in der Jenkins-Benutzeroberfläche an.

1. Das Jenkins-Diagramm erstellt automatisch ein Administratorpasswort für Sie, das sich so abrufen lässt:

printf $(kubectl get secret cd-jenkins -o jsonpath="{.data.jenkins-admin-password}" | base64 --decode);echo

2. Klicken Sie zum Aufrufen der Jenkins-Benutzeroberfläche in der Cloud Shell-Aktionsleiste auf Webvorschau () > Vorschau auf Port 8080:

3. Melden Sie sich bei Aufforderung mit dem Nutzernamen admin und dem automatisch generierten Passwort an.

Jetzt haben Sie Jenkins in Ihrem Kubernetes-Cluster eingerichtet und können damit die automatisierten CI/CD-Pipelines steuern.

Aufgabe 6: Informationen zur Anwendung

Im Rahmen dieser Aufgabe stellen Sie die Beispielanwendung gceme in der Continuous-Deployment-Pipeline bereit. Sie ist in der Sprache „Go“ geschrieben und befindet sich im Verzeichnis „sample-app“ des Repositorys. Wenn Sie die Binärdatei „gceme“ in einer Compute Engine-Instanz ausführen, zeigt die Anwendung die Metadaten der Instanz auf einer Informationskarte an.

Die Anwendung simuliert einen Mikrodienst durch Unterstützung von zwei Betriebsmodi.

• Backend-Modus: gceme überwacht Port 8080 und gibt Metadaten von Compute Engine-Instanzen im JSON-Format zurück.
• Frontend-Modus: gceme fragt den Backend-Dienst ab und rendert die resultierenden JSON-Daten in der Benutzeroberfläche.

Aufgabe 7: Anwendung bereitstellen

Sie stellen die Anwendung in zwei verschiedenen Umgebungen bereit:

• Produktion: Die Livewebsite, auf die die Nutzerinnen und Nutzer zugreifen.
• Canary: Eine Website mit geringerer Kapazität, die nur einen Teil des Nutzertraffics empfängt. Verwenden Sie diese Umgebung, um die Software mit Livetraffic zu testen, bevor Sie sie für alle Nutzerinnen und Nutzer freigeben.

1. Öffnen Sie in der Google Cloud Shell das Beispielanwendungsverzeichnis:

cd sample-app

2. Erstellen Sie den Kubernetes-Namespace, um das Deployment logisch zu isolieren:

kubectl create ns production

3. Erstellen Sie die Produktions- und Canary-Deployments sowie die Dienste mithilfe der folgenden kubectl apply-Befehle:

kubectl apply -f k8s/production -n production kubectl apply -f k8s/canary -n production kubectl apply -f k8s/services -n production

Klicken Sie auf Fortschritt prüfen. Wenn Deployments erstellt wurden, erhalten Sie ein Testergebnis.

Produktions- und Canary-Deployments erstellen

Standardmäßig wird nur ein Replikat des Frontends bereitgestellt. Mit dem Befehl kubectl scale lässt sich jedoch sicherstellen, das zu jeder Zeit mindestens vier Replikate ausgeführt werden.

4. Skalieren Sie die Frontends der Produktionsumgebung mit dem folgenden Befehl hoch:

kubectl scale deployment gceme-frontend-production -n production --replicas 4

5. Prüfen Sie nun, ob Sie fünf Pods für das Frontend, vier für den Produktionstraffic und einen für Canary-Releases haben. So betreffen Änderungen am Canary-Release nur 20 % der Nutzerinnen und Nutzer:

kubectl get pods -n production -l app=gceme -l role=frontend

6. Achten Sie außerdem darauf, dass Sie zwei Pods für das Backend haben, einen für das Produktions- und einen für das Canary-Deployment:

kubectl get pods -n production -l app=gceme -l role=backend

7. Rufen Sie die externe IP-Adresse für die Produktionsdienste ab:

kubectl get service gceme-frontend -n production Hinweis: Es kann einige Minuten dauern, bis die IP-Adresse des Load Balancers angezeigt wird.

Beispielausgabe:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE gceme-frontend LoadBalancer 10.79.241.131 104.196.110.46 80/TCP 5h

Fügen Sie den Wert aus der Spalte External-IP (Externe IP-Adresse) in einen Browser ein, um die Infokarte anzuzeigen. Die Seite sollte in etwa so aussehen:

8. Speichern Sie nun die IP-Adresse des zum Frontend-Dienst gehörenden Load Balancers zur späteren Verwendung in einer Umgebungsvariablen:

export FRONTEND_SERVICE_IP=$(kubectl get -o jsonpath="{.status.loadBalancer.ingress[0].ip}" --namespace=production services gceme-frontend)

9. Sie können prüfen, ob beide Dienste ausgeführt werden, indem Sie die externe IP-Adresse des Frontends im Browser öffnen.

10. Prüfen Sie außerdem die Version des Dienstes, indem Sie den folgenden Befehl ausführen. Die Ausgabe sollte 1.0.0 lauten:

curl http://$FRONTEND_SERVICE_IP/version

Sie haben die Beispielanwendung erfolgreich bereitgestellt. Als Nächstes richten Sie eine Pipeline für die kontinuierliche und zuverlässige Bereitstellung von Änderungen ein.

Aufgabe 8: Jenkins-Pipeline erstellen

Im Rahmen dieser Aufgabe richten Sie ein Git-Repository auf Ihrem dedizierten Git-Server ein und erstellen die Jenkins-Pipeline:

• Quellcode der Beispielanwendung auf den Git-Server hochladen
• Dienstkonto-Anmeldedaten zu Jenkins hinzufügen
• Jenkins-Cloud für Kubernetes konfigurieren
• Jenkins-Job für mehrzweigige Pipelines erstellen

Quellcode der Beispielanwendung auf den Git-Server hochladen

1. Rufen Sie in der Cloud Shell die externe IP-Adresse Ihres Git-Servers ab:

export GIT_SERVER_IP=$(gcloud compute instances describe git-server --zone={{{project_0.default_zone}}} --format='get(networkInterfaces[0].accessConfigs[0].natIP)') echo "Git Server IP: ${GIT_SERVER_IP}"

2. Initialisieren Sie das Verzeichnis sample-app als ein Git-Repository:

cd ~/continuous-deployment-on-kubernetes/sample-app git init git config --global user.email "student@qwiklabs.net" git config --global user.name "Student" git branch -m master

3. Fügen Sie das Remote-Repository hinzu, das auf Ihren selbst gehosteten Git-Server verweist:

git remote add origin http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/sample-app.git

4. Fügen Sie die Dateien hinzu, führen Sie den Commit durch und laden Sie die Dateien auf den Branch master hoch:

git add . git commit -m "Initial commit" git push -u origin master

Anmeldedaten für das Dienstkonto hinzufügen

Konfigurieren Sie Ihre Anmeldedaten, damit Jenkins auf den Cluster zugreifen und Ressourcen bereitstellen kann.

1. Klicken Sie in der Jenkins-Benutzeroberfläche links auf Manage Jenkins (Jenkins verwalten) und dann auf Credentials (Anmeldedaten) (unter Security).

2. Klicken Sie unter Stores scoped to Jenkins auf System.

3. Klicken Sie auf Global credentials (unrestricted).

4. Klicken Sie auf Add Credentials (Anmeldedaten hinzufügen).

5. Wählen Sie unter Kind die Option Google Service Account from metadata aus und klicken Sie auf Next (Weiter).

6. Geben Sie im Feld ID Ihre Projekt-ID () ein und klicken Sie auf Create (Erstellen).

Hinweis: Ihre Projekt-ID finden Sie im Bereich Verbindungsdetails des Labs.

Die globalen Anmeldedaten wurden hinzugefügt.

Jenkins-Cloud für Kubernetes konfigurieren

1. Klicken Sie in der Jenkins-Benutzeroberfläche auf Manage Jenkins > Clouds (oder System > Clouds).
2. Klicken Sie auf New cloud (Neue Cloud).
3. Geben Sie im Feld Cloud name (Cloud-Name) kubernetes ein, wählen Sie unter Type (Typ) die Option Kubernetes aus und klicken Sie auf Create (Erstellen).
4. Geben Sie im Feld Jenkins URL (Jenkins-URL) den Wert http://cd-jenkins:8080 ein.
5. Geben Sie im Feld Jenkins tunnel (Jenkins-Tunnel) den Wert cd-jenkins-agent:50000 ein.
6. Klicken Sie auf Save (Speichern).

Jenkins-Job erstellen

Gehen Sie zur Jenkins-Benutzeroberfläche und führen Sie die folgenden Schritte aus, um einen Multibranch-Pipelinejob zu konfigurieren:

1. Klicken Sie im linken Bereich auf Jenkins > New Item (Neues Element).

2. Geben Sie den Elementnamen sample-app ein, wählen Sie die Option Multibranch Pipeline (Mehrzweigige Pipeline) aus und klicken Sie auf OK.

3. Wählen Sie auf der nächsten Seite im Abschnitt Branch Sources (Zweigquellen) im Drop-down-Menü Add source die Option Git aus.

4. Fügen Sie die Klon-URL Ihres Repositorys in das Feld Project Repository ein:

http://{{{project_0.startup_script.git_server_ip}}}:3000/giteaadmin/sample-app.git Hinweis: Falls die Variable nicht ausgefüllt ist, können Sie http://[GIT_SERVER_IP]:3000/giteaadmin/sample-app.git eingeben und [GIT_SERVER_IP] durch Ihre Git-Server-IP ersetzen.

5. Belassen Sie Credentials bei - none -.

6. Aktivieren Sie im Abschnitt Scan Multibranch Pipeline Triggers das Kontrollkästchen Periodically if not otherwise run und legen Sie den Wert für Interval auf 1 minute fest.

7. Behalten Sie für alle anderen Optionen die Standardwerte bei und klicken Sie auf Save (Speichern).

Nachdem Sie diese Schritte abgeschlossen haben, wird der Job Branch indexing ausgeführt. Dieser Metajob ermittelt die Zweige in Ihrem Repository und stellt sicher, dass in vorhandenen Zweigen keine Änderungen vorgenommen wurden. Wenn Sie in der Navigationsleiste auf sample-app klicken, sollte der master-Job angezeigt werden.

Hinweis: Die erste Ausführung des Jobs schlägt eventuell fehl, bis Sie im nächsten Schritt einige Codeänderungen vornehmen.

Sie haben erfolgreich eine Jenkins-Pipeline erstellt. Als Nächstes erstellen Sie die Entwicklungsumgebung für die Continuous Integration (CI).

Aufgabe 9: Entwicklungsumgebung erstellen

Entwicklungszweige sind Umgebungen, die von Entwicklerinnen und Entwicklern zum Testen von Codeänderungen verwendet werden, bevor der Code in die Livewebsite eingebunden wird. Diese Umgebungen sind vereinfachte Versionen Ihrer Anwendung, werden aber mit denselben Mechanismen wie die Liveumgebung bereitgestellt.

Entwicklungszweig erstellen

Laden Sie den Zweig auf den Git-Server hoch und lassen Sie die Umgebung dann mit Jenkins bereitstellen, um eine Entwicklungsumgebung über einen Funktionszweig zu erstellen.

Hinweis: Wenn in der Cloud Shell Fehler angezeigt werden, drücken Sie Strg + C und führen Sie dann den folgenden Befehl aus:

• Erstellen Sie einen Entwicklungszweig und laden Sie ihn auf den Git-Server hoch:

git checkout -b new-feature

Pipelinedefinition ändern

Das Jenkinsfile, durch das diese Pipeline definiert ist, wird in der Groovy-Syntax für Jenkins-Pipelines geschrieben. Mit einem Jenkinsfile kann eine vollständige Build-Pipeline in einer einzigen Datei ausgedrückt werden, die neben dem Quellcode besteht. Pipelines unterstützen hilfreiche Funktionen wie Parallelisierung und erfordern eine manuelle Nutzergenehmigung.

Damit die Pipeline wie erwartet funktioniert, müssen Sie das Jenkinsfile ändern, um Ihre Projekt-ID festzulegen.

1. Öffnen Sie das Jenkinsfile im Terminaleditor, zum Beispiel vi:

vi Jenkinsfile

2. Öffnen Sie den Editor:

i

3. Ersetzen Sie PROJECT_ID in REPLACE_WITH_YOUR_PROJECT_ID durch Ihre Projekt-ID. PROJECT_ID ist Ihre Projekt-ID, die Sie im Abschnitt Verbindungsdetails des Labs finden. Sie können auch gcloud config get-value project ausführen, um sie zu finden.

4. Ändern Sie den Wert von CLUSTER_ZONE in . Sie können diesen Wert mit gcloud config get compute/zone abrufen.

PROJECT = "REPLACE_WITH_YOUR_PROJECT_ID" APP_NAME = "gceme" FE_SVC_NAME = "${APP_NAME}-frontend" CLUSTER = "jenkins-cd" CLUSTER_ZONE = "{{{project_0.default_zone}}}" IMAGE_TAG = "gcr.io/${PROJECT}/${APP_NAME}:${env.BRANCH_NAME}.${env.BUILD_NUMBER}" JENKINS_CRED = "${PROJECT}"

5. Speichern Sie das Jenkinsfile. Drücken Sie die Esc-Taste und geben Sie dann (in vi) Folgendes ein:

:wq

Website verändern

Nun erfahren Sie, wie die Anwendung modifiziert werden kann. Dazu ändern Sie die gceme-Karten von blau in orange.

1. Öffnen Sie html.go:

vi html.go

2. Öffnen Sie den Editor:

i

3. Ändern Sie die zwei Instanzen von <div class="card blue"> so:

<div class="card orange">

4. Speichern Sie die Datei html.go. Drücken Sie die Esc-Taste und geben Sie dann Folgendes ein:

:wq

5. Öffnen Sie die Datei main.go:

vi main.go

6. Öffnen Sie den Editor:

i

7. Die Version wird in dieser Zeile definiert:

const version string = "1.0.0"

Aktualisieren Sie die Version auf die folgende:

const version string = "2.0.0"

8. Speichern Sie die Datei „main.go“ noch einmal. Drücken Sie die Esc-Taste und geben Sie Folgendes ein:

:wq

Aufgabe 10: Bereitstellung starten

Im Rahmen dieser Aufgabe stellen Sie Ihre Entwicklungsumgebung bereit.

1. Führen Sie einen Commit durch und übertragen Sie die Änderungen:

git add Jenkinsfile html.go main.go git commit -m "Version 2.0.0" git push origin new-feature

Dadurch wird die Entwicklungsumgebung erstellt.

Wechseln Sie nach dem Hochladen der Änderung in das Git-Repository zur Jenkins-Benutzeroberfläche. Dort können Sie sehen, dass der Build für den Zweig new-feature gestartet wurde. Es kann bis zu einer Minute dauern, bis die Änderungen übernommen werden.

2. Wenn der Build ausgeführt wird, klicken Sie im linken Navigationsbereich auf den Pfeil nach unten neben dem Build und wählen Sie Console Output (Konsolenausgabe) aus.

3. Verfolgen Sie die Ausgabe des Builds einige Minuten lang und achten Sie darauf, dass Meldungen des Typs kubectl --namespace=production apply... angezeigt werden. Der Zweig „new-feature“ wird jetzt im Cluster bereitgestellt.

Hinweis: In einem Entwicklungsszenario würden Sie keinen öffentlichen Load Balancer verwenden. Zum Schützen Ihrer Anwendung können Sie den kubectl-Proxy verwenden. Der Proxy authentifiziert sich bei der Kubernetes API und leitet Anfragen von Ihrem lokalen Rechner an den Dienst im Cluster weiter, ohne Ihren Dienst im Internet verfügbar zu machen.

Wenn Sie in Build Executor nichts gesehen haben, machen Sie sich keine Sorgen. Gehen Sie einfach auf der Jenkins-Homepage zur Beispielanwendung und prüfen Sie, ob die Pipeline new-feature erstellt wurde.

4. Sobald alles erledigt ist, starten Sie den Proxy im Hintergrund:

kubectl proxy &

5. Wenn er nicht reagiert, drücken Sie Strg + C, um ihn zu beenden. Prüfen Sie, ob Zugriff auf die Anwendung besteht. Senden Sie dazu eine Anfrage an localhost und lassen Sie sie über den kubectl-Proxy zu Ihrem Dienst weiterleiten:

curl \ http://localhost:8001/api/v1/namespaces/new-feature/services/gceme-frontend:80/proxy/version

Die Antwort sollte „2.0.0“ lauten. Das ist die Version, die derzeit ausgeführt wird.

Wenn Sie einen ähnlichen Fehler erhalten:

{ "kind": "Status", "apiVersion": "v1", "metadata": { }, "status": "Failure", "message": "no endpoints available for service \"gceme-frontend:80\"", "reason": "ServiceUnavailable", "code": 503

6. wurde Ihr Frontend-Endpunkt noch nicht propagiert. Versuchen Sie es nach einiger Zeit noch einmal mit dem curl-Befehl. Fahren Sie fort, wenn Sie folgende Ausgabe erhalten:

2.0.0

Sie haben die Entwicklungsumgebung eingerichtet. Als Nächstes werden Sie das Gelernte aus dem vorherigen Modul nutzen und ein Canary-Release bereitstellen, um eine neue Funktion zu testen.

Klicken Sie auf Fortschritt prüfen. Wenn der Build für den Zweig „new-feature“ gestartet wurde, erhalten Sie ein Testergebnis.

Build für den Zweig new-feature

Aufgabe 11: Canary-Release bereitstellen

Sie haben geprüft, ob in Ihrer Anwendung der neueste Code in der Entwicklungsumgebung ausgeführt wird. Nun stellen wir diesen Code also in der Canary-Umgebung bereit.

1. Erstellen Sie einen Canary-Zweig und laden Sie ihn auf den Git-Server hoch:

git checkout -b canary git push origin canary

2. In Jenkins sollte angezeigt werden, dass die Canary-Pipeline gestartet wurde. Nach Abschluss können Sie die Dienst-URL prüfen, um sicherzustellen, ob ein Teil des Traffics von der neuen Version bereitgestellt wird. Bei etwa jeder fünften Anfrage (in beliebiger Reihenfolge) sollte die Version 2.0.0 zurückgegeben werden.

export FRONTEND_SERVICE_IP=$(kubectl get -o \ jsonpath="{.status.loadBalancer.ingress[0].ip}" --namespace=production services gceme-frontend) while true; do curl http://$FRONTEND_SERVICE_IP/version; sleep 1; done

3. Wenn ausschließlich 1.0.0 angezeigt wird, führen Sie die obigen Befehle noch einmal aus. Drücken Sie anschließend Strg + C.

Geschafft! Sie haben ein Canary-Release bereitgestellt. Als Nächstes stellen Sie die neue Version in der Produktion bereit.

Klicken Sie auf Fortschritt prüfen. Wenn das Canary-Release bereitgestellt wurde, erhalten Sie ein Testergebnis.

Canary-Release bereitstellen

Aufgabe 12: In der Produktion bereitstellen

Nachdem wir ein erfolgreiches Canary-Release durchgeführt haben und es keine Kundenbeschwerden gab, stellen wir es nun in der restlichen Produktionsflotte bereit.

1. Erstellen Sie einen Canary-Zweig und laden Sie ihn auf den Git-Server hoch:

git checkout master git merge canary git push origin master

In Jenkins sollte angezeigt werden, dass die Master-Pipeline gestartet wurde.

Klicken Sie auf Fortschritt prüfen. Wenn die Master-Pipeline gestartet wurde, erhalten Sie ein Testergebnis.

In der Produktion bereitstellen

2. Nach Abschluss (das kann einige Minuten dauern) können Sie die Dienst-URL prüfen, um sicherzustellen, dass sämtlicher Traffic von der neuen Version (2.0.0) bereitgestellt wird.

export FRONTEND_SERVICE_IP=$(kubectl get -o \ jsonpath="{.status.loadBalancer.ingress[0].ip}" --namespace=production services gceme-frontend) while true; do curl http://$FRONTEND_SERVICE_IP/version; sleep 1; done

3. Auch hier gilt: Werden Instanzen der Version 1.0.0 zurückgegeben, führen Sie die obigen Befehle noch einmal aus. Drücken Sie Strg + C, um diesen Befehl zu beenden.

Beispielausgabe:

gcpstaging9854_student@qwiklabs-gcp-df93aba9e6ea114a:~/continuous-deployment-on-kubernetes/sample-app$ while true; do curl http://$FRONTEND_SERVICE_IP/version; sleep 1; done 2.0.0 2.0.0 2.0.0 2.0.0 2.0.0 2.0.0 ^C

Sie können auch zu der Seite gehen, auf der in der gceme-Anwendung die Infokarten angezeigt werden. Die Kartenfarbe hat sich von blau zu orange geändert.

4. Mit dem folgenden Befehl rufen Sie die externe IP-Adresse ab. Fügen Sie die externe IP-Adresse in einen neuen Tab ein, um die Infokarte aufzurufen:

kubectl get service gceme-frontend -n production

Beispielausgabe:

Aufgabe 13: Wissen testen

Im Folgenden stellen wir Ihnen einige Multiple-Choice-Fragen, um Ihr bisher erworbenes Wissen zu testen und zu festigen. Beantworten Sie sie nach bestem Wissen.

Fertig!

Gute Arbeit! Sie haben die Anwendung erfolgreich in Ihrer Produktionsumgebung bereitgestellt.

Das wars! Sie haben das Lab erfolgreich abgeschlossen.

Darin haben Sie gelernt, wie Sie Jenkins bereitstellen und damit in der Kubernetes Engine eine Pipeline für Continuous Delivery / Continuous Deployment einrichten. Sie haben ein wichtiges DevOps-Tool in der Kubernetes Engine bereitgestellt und es für die Verwendung in der Produktion konfiguriert. Außerdem haben Sie mit dem kubectl-Befehlszeilentool sowie mit Deployment-Konfigurationen in YAML-Dateien gearbeitet und etwas über die Einrichtung von Jenkins-Pipelines für einen Entwicklungs-/Deployment-Prozess gelernt. Dank dieser praktischen Erfahrungen sollten Sie nun sicher mit diesen Tools umgehen und sie für Ihre eigenen DevOps-Anforderungen anwenden können.

Weitere Informationen

• Erfahren Sie mehr über Jenkins in der Kubernetes Engine.
• Moderne CI/CD mit der GKE: CI/CD-System erstellen
• DevOps (Google Cloud-Dokumentation)
• Werden Sie Teil der Jenkins-Community!

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 20. Mai 2026 aktualisiert

Lab zuletzt am 26. Februar 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.