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

In diesem Lab führen Sie die folgenden Aufgaben aus, um mehr über das Ausführen von Jenkins in Kubernetes zu erfahren:

• 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

Vorbereitung

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

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 Entwickler 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 / kontinuierliche Bereitstellung?

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 von sitzungsspezifischen Build-Ausführungsprogrammen 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 Backbone-Netzwerk von Google mit Ihrem Web-Frontend verbunden ist und über die Nutzer auf dem schnellstmöglichen Weg zu einer Anwendungsinstanz weitergeleitet werden.

Sie haben nun schon etwas über Kubernetes und Jenkins gelernt sowie darüber, wie die beiden in einer CD-Pipeline miteinander interagieren. Also ist es an der Zeit, 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 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.

Aufgabe 1: Quellcode herunterladen

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

1. Öffnen Sie eine neue Sitzung in 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:

gsutil 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 das GitHub-Repository und Google Container 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 das GitHub-Repository und Google Container Registry zuzugreifen.

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 auch, ob Sie mithilfe des folgenden Befehls 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.

In 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

Es kann einige Minuten dauern, bis dieser Befehl durchgeführt wird.

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, damit Sie im Cluster bereitstellen können:

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

In dieser Aufgabe stellen Sie die Beispielanwendung gceme in der Pipeline für kontinuierliche Bereitstellung 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.

• Back-End-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 Live-Website, auf die die 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 Live-Traffic zu testen, bevor Sie sie für alle Nutzer freigeben.

1. Öffnen Sie in 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.

Erstellen Sie die Produktions- und Canary-Deployments

Standardmäßig wird nur ein Replikat des Front-Ends bereitgestellt. Mit dem Befehl kubectl scale lässt sich jedoch testen, ob 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 verwenden. So betreffen Änderungen am Canary-Release nur jeden fünften Nutzer (20 %):

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 externe 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 angezeigte 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 Umgebungsvariable:

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

In dieser Aufgabe erstellen Sie die Jenkins-Pipeline. Dazu führen Sie folgende Schritte aus:

• Repository zum Hosten des Quellcodes erstellen
• Anmeldedaten hinzufügen, um Jenkins Zugriff auf das Code-Repository zu gewähren
• Jenkins-Cloud für Kubernetes konfigurieren
• Jenkins bei dem privaten GitHub-Repository authentifizieren
• Jenkins-Job erstellen

Repository zum Hosten des Quellcodes der Beispielanwendung erstellen

1. Erstellen Sie eine Kopie der Beispielanwendung gceme und übertragen Sie sie per Push an ein GitHub-Repository:

Führen Sie in Cloud Shell die folgenden Befehle aus, um Git und GitHub zu konfigurieren:

curl -sS https://webi.sh/gh | sh gh auth login gh api user -q ".login" GITHUB_USERNAME=$(gh api user -q ".login") git config --global user.name "${GITHUB_USERNAME}" git config --global user.email "${USER_EMAIL}" echo ${GITHUB_USERNAME} echo ${USER_EMAIL}

• Drücken Sie die Eingabetaste, um die Standardoptionen zu übernehmen.
• Folgen Sie den Anweisungen in der Befehlsausgabe, um sich über einen Webbrowser bei GitHub anzumelden.

Wenn Sie sich angemeldet haben, wird Ihr GitHub-Nutzername in der Ausgabe in Cloud Shell angezeigt.

gh repo create default --private

Sie können die Warnung ignorieren, da Ihnen dieses Repository nicht in Rechnung gestellt wird.

git init

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

git config credential.helper gcloud.sh

3. Führen Sie dazu diesen Befehl aus:

git remote add origin https://github.com/${GITHUB_USERNAME}/default

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

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

Anmeldedaten für das Dienstkonto hinzufügen

Konfigurieren Sie Ihre Anmeldedaten, damit Jenkins auf das Code-Repository zugreifen kann. Jenkins verwendet die Dienstkonto-Anmeldedaten Ihres Clusters, um Code aus dem GitHub-Repository herunterzuladen.

1. Klicken Sie in der Jenkins-Benutzeroberfläche im linken Navigationsbereich auf Manage Jenkins (Jenkins verwalten) und dann auf Security > Credentials (Sicherheit > Anmeldedaten).

2. Klicken Sie auf System.

3. Klicken Sie auf Global credentials (unrestricted) (Globale Anmeldedaten (unbeschränkt)).

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

5. Wählen Sie die Option Google Service Account from metadata (Google-Dienstkonto aus Metadaten) im Drop-down Kind (Art) aus.

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

Hinweis: Die Projekt-ID finden Sie im Abschnitt 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 > Nodes (Jenkins verwalten > Knoten).
2. Klicken Sie im linken Navigationsbereich auf Clouds.
3. Klicken Sie auf New cloud (Neue Cloud).
4. Geben Sie im Feld Cloud name (Cloud-Name) einen beliebigen Namen ein und wählen Sie dann unter Type (Typ) die Option Kubernetes aus.
5. Klicken Sie auf Create (Erstellen).
6. Geben Sie im Feld Jenkins URL (Jenkins-URL) den Wert http://cd-jenkins:8080 ein.
7. Geben Sie im Feld Jenkins tunnel (Jenkins-Tunnel) den Wert cd-jenkins-agent:50000 ein.
8. Klicken Sie auf Speichern.

Jenkins mit einem SSH-Schlüssel bei einem privaten GitHub-Repository authentifizieren

So authentifizieren Sie Jenkins mit einem SSH-Schlüssel bei einem privaten GitHub-Repository:

a. SSH-Schlüssel generieren

1. Erstellen Sie einen neuen GitHub-SSH-Schlüssel, wobei github-email Ihre GitHub-E-Mail-Adresse ist:

ssh-keygen -t rsa -b 4096 -N '' -f id_github -C [your-github-email]

2. Wenn Sie den privaten Schlüssel (id_github) und den öffentlichen Schlüssel (id_github.pub) von Ihrem lokalen Computer herunterladen möchten, klicken Sie in der Cloud Shell-Aktionsleiste auf das Dreipunkt-Menü () und wählen Sie den Ordner continuous-deployment-on-kubernetes/sample-app aus.

b. Öffentlichen Schlüssel zu GitHub hinzufügen

Nachdem Sie den SSH-Schlüssel generiert haben, müssen Sie GitHub den öffentlichen Schlüssel hinzufügen, damit Jenkins auf Ihre Repositories zugreifen kann.

1. Rufen Sie Ihr GitHub-Konto auf. Klicken Sie auf Ihr GitHub-Profil und gehen Sie zu Settings (Einstellungen).

2. Wählen Sie im seitlichen Menü SSH and GPG keys (SSH- und GPG-Schlüssel) aus.

3. Klicken Sie auf New SSH key (Neuer SSH-Schlüssel).

4. Geben Sie den Titel SSH_KEY_LAB ein.

5. Fügen Sie den Inhalt Ihres öffentlichen Schlüssels (id_github.pub), den Sie über den Pfad ~/continuous-deployment-on-kubernetes/sample-app/id_github.pub heruntergeladen haben, in das Feld „Key“ (Schlüssel) ein. Sie können auch einen aussagekräftigen Namen im Feld „Title“ (Titel) hinzufügen.

6. Klicken Sie auf Add SSH key (SSH-Schlüssel hinzufügen).

c. Jenkins für die Verwendung des SSH-Schlüssels konfigurieren

1. Rufen Sie Jenkins auf und wählen Sie im Hauptdashboard Manage Jenkins (Jenkins verwalten) aus.

2. Wählen Sie die Option Credentials (Anmeldedaten) aus.

3. Klicken Sie unter Stores scoped to Jenkins (Auf Jenkins beschränkte Speicher) auf System.

4. Klicken Sie auf Global credentials (unrestricted) (Globale Anmeldedaten (unbeschränkt)).

5. Klicken Sie auf Anmeldedaten hinzufügen.

6. Wählen Sie im Drop-down-Menü Kind (Art) die Option SSH Username with private key (SSH-Nutzername mit privatem Schlüssel) aus.

7. Geben Sie als ID _ssh_key ein.

8. Geben Sie unter Username (Nutzername) [Ihren GitHub-Nutzernamen] ein.

9. Wählen Sie für den privaten Schlüssel Enter directly (Direkt eingeben) aus und klicken Sie auf Add (Hinzufügen). Fügen Sie den Inhalt der Datei id_github ein, die Sie unter ~/continuous-deployment-on-kubernetes/sample-app/id_github heruntergeladen haben.

10. Klicken Sie auf Erstellen.

d. Öffentlichen SSH-Schlüssel bekannten Hosts hinzufügen

Erstellen Sie in Cloud Shell eine Datei mit dem Namen known_hosts.github und fügen Sie der Datei den öffentlichen SSH-Schlüssel hinzu.

ssh-keyscan -t rsa github.com > known_hosts.github chmod +x known_hosts.github cat known_hosts.github Hinweis: Wenn in Cloud Shell Fehler angezeigt werden, drücken Sie Strg + C und führen Sie dann den obigen Befehl aus.

e. Schlüssel für bekannten Host konfigurieren

1. Klicken Sie im linken Bereich auf Dashboard > Manage Jenkins (Dashboard > Jenkins verwalten).

2. Klicken Sie unter Security (Sicherheit) auf Security.

3. Wählen Sie unter Git Host Key Verification Configuration (Konfiguration der Host-Schlüsselüberprüfung für Git) für Host Key Verification Strategy (Strategie für die Host-Schlüsselüberprüfung) im Drop-down-Menü die Option Manually provided keys (Manuell bereitgestellte Schlüssel) aus.

4. Fügen Sie den Inhalt der Datei known hosts.github in Approved Host Keys (Genehmigte Hostschlüssel) ein.

5. Klicken Sie auf Speichern.

Jenkins-Job erstellen

Gehen Sie zur Jenkins-Benutzeroberfläche und führen Sie die Schritte durch, um einen Pipeline-Job zu konfigurieren.

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

2. Geben Sie dem Projekt den Namen sample-app, 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 (Branch-Quellen) im Drop-down-Menü Add Source (Quelle hinzufügen) die Option Git aus.

4. Fügen Sie die HTTPS-Klon-URL Ihres Repositorys „sample-app“ in das Feld Project Repository (Projekt-Repository) ein. Ersetzen Sie ${GITHUB_USERNAME} durch Ihren GitHub-Nutzernamen:

git@github.com:${GITHUB_USERNAME}/default.git

5. Wählen Sie in den Menüoptionen unter Credentials (Anmeldedaten) den Namen github credentials aus.

6. Klicken Sie im Abschnitt Scan Multibranch Pipeline Triggers (Trigger von Multibranch-Pipelines scannen) auf das Kästchen Periodically if not otherwise run (Regelmäßig, wenn nicht anders ausgeführt) und legen Sie den Wert für Interval (Intervall) auf 1 minute (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 Branches in Ihrem Repository und garantiert, dass in vorhandenen Branches keine Änderungen vorgenommen wurden. Wenn Sie links oben 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

Entwicklungs-Branches sind Umgebungen, die von 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.

Entwicklungs-Branch erstellen

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

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

• Erstellen Sie einen Entwicklungs-Branch 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 leistungsstarke 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. Fügen Sie Ihre PROJEKT-ID dem Wert DURCH_IHRE_PROJEKT-ID_ERSETZEN hinzu. Die 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 die Datei Jenkinsfile. Drücken Sie die Esc-Taste und geben Sie dann Folgendes ein (für vi-Nutzer):

: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

In 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 Branch new-feature gestartet wurde. Es kann bis zu einer Minute dauern, bis die Änderungen übernommen werden.

2. Nachdem der Build ausgeführt wurde, 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 Branch „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. hat ihr Frontend-Endpunkt noch nichts 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 Branch „new-feature“ gestartet wurde, erhalten Sie ein Testergebnis.

Build für den Branch 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-Branch 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. Klicken Sie anschließend auf 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: Für die Produktion bereitstellen

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

1. Erstellen Sie einen Canary-Branch 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: Testen Sie Ihr Wissen

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 war’s!

Damit ist dieses praxisorientierte Lab abgeschlossen. Sie haben nun gelernt, wie Sie Jenkins bereitstellen und damit in der Kubernetes Engine eine Pipeline für Continuous Delivery / kontinuierliche Bereitstellung 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 Befehlszeilentool "kubectl" 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 10. Juni 2025 aktualisiert

Lab zuletzt am 10. Juni 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.