GSP1077

Übersicht

Cloud Build ist ein Dienst zum Ausführen von Builds in Google Cloud. Sie können Quellcode importieren, Builds ausführen und vieles mehr.

In diesem Lab erstellen Sie eine CI/CD-Pipeline (Continuous Integration/Continuous Deployment), die automatisch ein Container-Image aus gespeichertem Code erstellt, das Image in Artifact Registry speichert, ein Kubernetes-Manifest in einem Git-Repository aktualisiert und die Anwendung mithilfe dieses Manifests in Google Kubernetes Engine bereitstellt.

Für dieses Lab erstellen Sie zwei Git-Repositories:

• app: enthält den Quellcode der Anwendung
• env: enthält die Kubernetes-Deployment-Manifeste

Wenn Sie eine Änderung am Repository app per Push machen, führt die Cloud Build-Pipeline Tests aus, erstellt ein Container-Image und überträgt dieses per Push in Artifact Registry. Nachdem das Image per Push übertragen wurde, aktualisiert Cloud Build das Deployment-Manifest und überträgt es per Push in das Repository env. Dies löst eine weitere Cloud Build-Pipeline aus, die das Manifest auf den GKE-Cluster anwendet und es bei Erfolg in einem anderen Zweig des Repository env speichert.

Die Repositories app und env bleiben getrennt, weil sie unterschiedliche Lebenszyklen und Verwendungszwecke haben. Das Repository app ist für eine bestimmte Anwendung vorgesehen und wird primär von Menschen genutzt. Das Repository env kann von mehreren Anwendungen gemeinsam verwendet werden und wird von automatisierten Systemen (z. B. Cloud Build) genutzt. Das Repository env kann mehrere Zweige haben, die jeweils einer bestimmten Umgebung zugeordnet sind und auf ein bestimmtes Container-Image verweisen, das Repository app jedoch nicht.

Nach Abschluss dieses Labs haben Sie ein System, mit dem Sie Folgendes tun können:

• Fehlgeschlagene und erfolgreiche Deployments durch einen Blick in den Cloud Build-Verlauf voneinander unterscheiden
• Über den Zweig „production“ des Repositorys env auf das derzeit verwendete Manifest zugreifen
• Rollback zu einer vorherigen Version durch erneutes Ausführen des jeweiligen Cloud Build-Builds

Lernziele

Aufgaben in diesem Lab:

• Kubernetes Engine-Cluster erstellen
• GitHub-Repositories erstellen
• Cloud Build über GitHub-Repositories auslösen
• Tests automatisieren und ein bereitstellbares Container-Image über Cloud Build veröffentlichen
• Ressourcen verwalten, die in einem Kubernetes Engine-Cluster über Cloud Build bereitgestellt werden

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: Lab initialisieren

In dieser Aufgabe richten Sie Ihre Umgebung ein:

• Projekt-ID und Projektnummer als Variablen importieren
• APIs für GKE, Cloud Build, Secret Manager und Artefaktanalyse aktivieren
• Artifact Registry-Docker-Repository erstellen
• GKE-Cluster erstellen, um die Beispielanwendung dieses Labs bereitzustellen

1. Führen Sie in Cloud Shell den folgenden Befehl aus, um Ihre Projekt-ID und Projektnummer festzulegen. Speichern Sie diese als die Variablen PROJECT_ID und PROJECT_NUMBER:

export PROJECT_ID=$(gcloud config get-value project) export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)') export REGION={{{ project_0.default_region }}} gcloud config set compute/region $REGION

Als Nächstes bereiten Sie Ihr Google Cloud-Projekt für die Verwendung vor. Dazu aktivieren Sie die erforderlichen APIs, initialisieren die Git-Konfiguration in Cloud Shell und laden den später in der Übung verwendeten Beispielcode herunter.

2. Führen Sie den folgenden Befehl aus, um die APIs für GKE, Cloud Build, Secret Manager und Artefaktanalyse zu aktivieren:

gcloud services enable container.googleapis.com \ cloudbuild.googleapis.com \ sourcerepo.googleapis.com \ containeranalysis.googleapis.com

3. Erstellen Sie ein Docker-Repository in Artifact Registry mit dem Namen my-repository in der Region . Dort werden die Container-Images gespeichert.

gcloud artifacts repositories create my-repository \ --repository-format=docker \ --location=$REGION

4. Erstellen Sie einen GKE-Cluster, um die Beispielanwendung dieses Labs bereitzustellen:

gcloud container clusters create hello-cloudbuild --num-nodes 1 --region $REGION

5. Führen Sie den folgenden Befehl aus, um Git und GitHub in Cloud Shell 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 im CLI-Tool, um sich über einen Webbrowser bei GitHub anzumelden. Wenn Sie sich erfolgreich angemeldet haben, wird Ihr GitHub-Nutzername angezeigt.

Klicken Sie auf Fortschritt prüfen. Dienste aktivieren, Artifact Registry und GKE-Cluster erstellen

Aufgabe 2: Git-Repositories in GitHub-Repositories erstellen

GitHub ist eine Plattform, auf der Sie Code speichern, teilen und gemeinsam mit anderen schreiben können. Git ist ein Versionsverwaltungssystem. Wenn Sie Dateien in GitHub hochladen, speichern Sie sie in einem Git-Repository. Das bedeutet, dass Git automatisch mit dem Tracking und der Verwaltung Ihrer Änderungen beginnt, wenn Sie Änderungen (oder „Commits“) an Ihren Dateien in GitHub vornehmen. Weitere Informationen finden Sie unter Informationen zu GitHub und Git.

In dieser Aufgabe erstellen Sie die beiden Git-Repositories (hello-cloudbuild-app und hello-cloudbuild-env) und initialisieren hello-cloudbuild-app mit Beispielcode.

1. Führen Sie diese Befehle in Cloud Shell aus, um die beiden Git-Repositories zu erstellen:

gh repo create hello-cloudbuild-app --private gh repo create hello-cloudbuild-env --private

2. Laden Sie den Beispielcode aus Cloud Storage herunter:

cd ~ mkdir hello-cloudbuild-app gcloud storage cp -r gs://spls/gsp1077/gke-gitops-tutorial-cloudbuild/* hello-cloudbuild-app

3. Konfigurieren Sie das GitHub-Repository als Remote-Repository:

cd ~/hello-cloudbuild-app export REGION={{{project_0.default_region | "REGION"}}} sed -i "s/us-central1/$REGION/g" cloudbuild.yaml sed -i "s/us-central1/$REGION/g" cloudbuild-delivery.yaml sed -i "s/us-central1/$REGION/g" cloudbuild-trigger-cd.yaml sed -i "s/us-central1/$REGION/g" kubernetes.yaml.tpl PROJECT_ID=$(gcloud config get-value project) git init git config credential.helper gcloud.sh git remote add google https://github.com/${GITHUB_USERNAME}/hello-cloudbuild-app git branch -m master git add . && git commit -m "initial commit"

Der soeben geklonte Code enthält eine einfache „Hello World“-Anwendung.

from flask import Flask app = Flask('hello-cloudbuild') @app.route('/') def hello(): return "Hello World!\n" if __name__ == '__main__': app.run(host = '0.0.0.0', port = 8080)

Aufgabe 3: Container-Image mit Cloud Build erstellen

Bei dieser Aufgabe verwenden Sie ein vorhandenes Dockerfile, um mit Cloud Build ein Container-Image zu erstellen und zu speichern.

Der zuvor geklonte Code enthält die Docker-Datei:

FROM python:3.7-slim RUN pip install flask WORKDIR /app COPY app.py /app/app.py ENTRYPOINT ["python"] CMD ["/app/app.py"]

Mit diesem Dockerfile können Sie mit Cloud Build ein Container-Image erstellen und dieses in Artifact Registry speichern.

1. Erstellen Sie in Cloud Shell mit dem folgenden Befehl auf Grundlage des neuesten Commits einen Cloud Build-Build:

cd ~/hello-cloudbuild-app COMMIT_ID="$(git rev-parse --short=7 HEAD)" gcloud builds submit --tag="${REGION}-docker.pkg.dev/${PROJECT_ID}/my-repository/hello-cloudbuild:${COMMIT_ID}" .

Wenn Sie diesen Befehl ausführen, streamt Cloud Build die durch die Erstellung des Container-Images generierten Logs an Ihr Terminal.

2. Nachdem der Build abgeschlossen ist, geben Sie in der Titelleiste der Google Cloud Console Artifact Registry in das Suchfeld ein und klicken Sie in den Suchergebnissen auf Artifact Registry. Prüfen Sie, ob das neue Container-Image tatsächlich in Artifact Registry verfügbar ist. Klicken Sie auf my-repository, um das Image hello-cloudbuild in der Liste Image aufzurufen.

Klicken Sie auf Fortschritt prüfen. Container-Image mit Cloud Build erstellen

Aufgabe 4: CI-Pipeline erstellen

In dieser Aufgabe konfigurieren Sie Cloud Build so, dass automatisch ein kleiner Unittest ausgeführt, das Container-Image erstellt und anschließend mithilfe von Push in Artifact Registry übertragen wird. Wenn ein neuer Commit per Push in GitHub-Repositories übertragen wird, wird jene Pipeline automatisch ausgelöst.

Die bereits im Code enthaltene Datei cloudbuild.yaml enthält die Konfiguration der Pipeline.

1. Geben Sie in der Titelleiste der Console Cloud Build-Trigger in das Suchfeld ein und klicken Sie in den Suchergebnissen auf Trigger, Cloud Build.

2. Klicken Sie auf Trigger erstellen.

3. Geben Sie unter Name die Bezeichnung hello-cloudbuild ein. Legen Sie Region auf fest.

4. Setzen Sie Ereignis auf Push zu Zweig.

5. Klicken Sie unter Quelle für Repository auf Neues Repository verbinden.

   a. Wählen Sie GitHub (Cloud Build-GitHub-App) aus. Klicken Sie auf Weiter.

   b. Authentifizieren Sie sich mit Ihrem Nutzernamen und Passwort in Ihrem Quell-Repository.

   c. Wenn das Pop-up „Die GitHub-App ist in keinem Ihrer Repositories installiert“ angezeigt wird, gehen Sie so vor:

   i. Klicken Sie auf **Google Cloud Build installieren**. Installieren Sie die Cloud Build GitHub App in Ihrem persönlichen Konto. Lassen Sie die Installation über Ihr GitHub-Konto zu. ii. Unter **Repository-Zugriff**. Wählen Sie **Nur Repositories auswählen** aus. Klicken Sie auf das Menü **Repositorys auswählen** und wählen Sie `${GITHUB_USERNAME}/hello-cloudbuild-app` und `${GITHUB_USERNAME}/hello-cloudbuild-env` aus. iii. Klicken Sie auf **Installieren**.

   d. Wählen Sie ${GITHUB_USERNAME}/hello-cloudbuild-app für Repository aus. Klicken Sie auf OK.

   e. Akzeptieren Sie Mir ist bewusst, dass GitHub-Inhalte für die ausgewählten Repositories....

   f. Klicken Sie auf Verbinden.

6. Wenn die Cloud Build GitHub App bereits in Ihrem Konto installiert ist, können Sie in GitHub Repositories bearbeiten.

   a. Wählen Sie unter Repository access die Option Only select repositories aus. Klicken Sie auf das Menü Select repositories und wählen Sie die Repositorys **$${GITHUB_USERNAME}/hello-cloudbuild-app** und **$${GITHUB_USERNAME}/hello-cloudbuild-env** aus.

   b. Klicken Sie auf Save.

7. Klicken Sie auf der Seite „Trigger“ in der Repository-Liste auf ${GITHUB_USERNAME}/hello-cloudbuild-app.

8. Geben Sie für Zweig den Wert .* (beliebiger Zweig) ein.

9. Legen Sie im Abschnitt Konfiguration für Typ die Option Cloud Build-Konfigurationsdatei fest.

10. Geben Sie im Feld Speicherort nach dem / cloudbuild.yaml ein.

11. Setzen Sie Dienstkonto auf das Compute Engine-Standarddienstkonto.

12. Klicken Sie auf Erstellen.

Nachdem der Trigger erstellt wurde, kehren Sie zur Cloud Shell zurück. Sie müssen den Anwendungscode per Push in GitHub-Repositories übertragen, um die CI-Pipeline in Cloud Build auszulösen.

13. Führen Sie den folgenden Befehl aus, um den Trigger zu starten:

cd ~/hello-cloudbuild-app git add . git commit -m "Type Any Commit Message here" git push google master

14. Klicken Sie im linken Bereich auf Dashboard.

15. Sie sollten einen Build sehen, der gerade ausgeführt wird oder kürzlich abgeschlossen wurde. Sie können auf den Build klicken, um dessen Ausführung zu verfolgen und die Logs zu überprüfen.

Klicken Sie auf Fortschritt prüfen. CI-Pipeline erstellen

Aufgabe 5: Von einem Build über SSH-Schlüssel auf GitHub zugreifen

In diesem Schritt verwenden Sie Secret Manager mit Cloud Build, um auf private GitHub-Repositories zuzugreifen.

SSH-Schlüssel erstellen

1. Wechseln Sie in Cloud Shell zum Basisverzeichnis.

   cd ~

2. Erstellen Sie ein neues Verzeichnis mit dem Namen workingdir und rufen Sie dieses Verzeichnis auf:

   mkdir workingdir cd workingdir

3. Erstellen Sie einen neuen GitHub-SSH-Schlüssel und ersetzen Sie [your-github-email] durch Ihre persönliche GitHub-E-Mail-Adresse:

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

Dadurch werden zwei Dateien erstellt: id_github und id_github.pub.

4. Klicken Sie in der Cloud Shell-Aktionsleiste auf das Dreipunkt-Menü () und dann auf Herunterladen > Dateibrowser ein/aus. Wählen Sie das Dropdown-Menü und den Ordner workingdir aus, um die Datei id_github auf Ihren lokalen Computer herunterzuladen.

Privaten SSH-Schlüssel in Secret Manager speichern

1. Geben Sie in der Titelleiste der Console Secret Manager ein und klicken Sie in den Suchergebnissen auf Secret Manager.

2. Klicken Sie auf Secret erstellen.

3. Setzen Sie Name auf ssh_key_secret.

4. Setzen Sie Secret-Wert auf Hochladen und laden Sie die Datei id_github hoch.

5. Behalten Sie bei allen anderen Attributen die Standardeinstellung bei.

6. Klicken Sie auf Secret erstellen.

Dadurch wird Ihre Datei id_github in Secret Manager hochgeladen.

Öffentlichen SSH-Schlüssel zu Bereitstellungsschlüsseln eines privaten Repository hinzufügen

1. Melden Sie sich in Ihrem persönlichen GitHub-Konto an.

2. Klicken Sie rechts oben auf Ihr Profilbild und dann auf Mein Profil.

3. Klicken Sie auf Ihrer Profilseite auf Repositories und dann auf das Repository hello-cloudbuild-env.

4. Klicken Sie im Repository auf Einstellungen.

5. Klicken Sie im linken Bereich auf Schlüssel bereitstellen und dann auf Bereitstellungsschlüssel hinzufügen.

6. Geben Sie den Titel SSH_KEY ein und fügen Sie Ihren öffentlichen SSH-Schlüssel aus workingdir/id_github.pub in Cloud Shell ein.

7. Wählen Sie Schreibzugriff zulassen aus, damit dieser Schlüssel Schreibzugriff auf das Repository hat. Mit einem Bereitstellungsschlüssel mit Schreibzugriff kann eine Bereitstellung an das Repository übertragen werden.

8. Klicken Sie auf Schlüssel hinzufügen.

9. Löschen Sie den SSH-Schlüssel von Ihrem Laufwerk:

   rm id_github*

Dem Dienstkonto die Berechtigung für den Zugriff auf Secret Manager gewähren

Geben Sie den folgenden Befehl ein, um dem Dienstkonto Zugriff auf Secret Manager zu gewähren:

gcloud projects add-iam-policy-binding ${PROJECT_NUMBER} \ --member=serviceAccount:${PROJECT_NUMBER}-compute@developer.gserviceaccount.com \ --role=roles/secretmanager.secretAccessor

Klicken Sie auf Fortschritt prüfen. Von einem Build über SSH-Schlüssel auf GitHub zugreifen

Aufgabe 6: Testumgebung und CD-Pipeline erstellen

Sie können Cloud Build auch für die CD-Pipeline (Continuous Delivery) verwenden. Die Pipeline wird jedes Mal ausgeführt, wenn ein Commit per Push an den Zweig „candidate“ des Repositorys hello-cloudbuild-env gesendet wird. Die Pipeline wendet die neue Version des Manifests auf den Kubernetes-Cluster an und kopiert das Manifest bei Erfolg in den Zweig „production“. Für diesen Prozess gilt Folgendes:

• Im Zweig „candidate“ werden die Deployment-Versuche in Verlaufsform angezeigt.
• Im Zweig „production“ werden die erfolgreichen Deployments in Verlaufsform angezeigt.
• Sie können die Anzahl erfolgreicher und fehlgeschlagener Deployments in Cloud Build einsehen.
• Sie können ein Rollback zu einem beliebigen vorherigen Deployment vornehmen, indem Sie den entsprechenden Build in Cloud Build noch einmal ausführen. Durch ein Rollback wird auch der Zweig „production“ aktualisiert, um den Verlauf der Deployments korrekt widerzuspiegeln.

Als Nächstes ändern Sie die CI-Pipeline, sodass der Zweig „candidate“ des Repositorys hello-cloudbuild-env aktualisiert wird, wodurch dann die CD-Pipeline ausgelöst wird.

Cloud Build Zugriff auf GKE gewähren

Damit die Anwendung im Kubernetes-Cluster bereitgestellt werden kann, benötigt Cloud Build die IAM-Rolle (Identity and Access Management) „Kubernetes Engine Developer“.

1. Führen Sie in Cloud Shell den folgenden Befehl aus:

PROJECT_NUMBER="$(gcloud projects describe ${PROJECT_ID} --format='get(projectNumber)')" gcloud projects add-iam-policy-binding ${PROJECT_NUMBER} \ --member=serviceAccount:${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com \ --role=roles/container.developer

Sie müssen das Repository hello-cloudbuild-env mit zwei Zweigen („production“ und „candidate“) und einer Cloud Build-Konfigurationsdatei initialisieren, in welcher der Deployment-Prozess beschrieben ist.

Klonen Sie als Erstes das Repository hello-cloudbuild-env und erstellen Sie den Zweig „production“, der noch leer ist.

2. Laden Sie in Cloud Shell den Beispielcode aus Cloud Storage herunter:

mkdir hello-cloudbuild-env gcloud storage cp -r gs://spls/gsp1077/gke-gitops-tutorial-cloudbuild/* hello-cloudbuild-env cd hello-cloudbuild-env export REGION={{{project_0.default_region | "REGION"}}} sed -i "s/us-central1/$REGION/g" cloudbuild.yaml sed -i "s/us-central1/$REGION/g" cloudbuild-delivery.yaml sed -i "s/us-central1/$REGION/g" cloudbuild-trigger-cd.yaml sed -i "s/us-central1/$REGION/g" kubernetes.yaml.tpl

3. Damit Cloud Build eine Verbindung zu GitHub herstellen kann, müssen Sie der Datei known_hosts in der Build-Umgebung von Cloud Build den öffentlichen SSH-Schlüssel hinzufügen. Erstellen Sie im Verzeichnis hello-cloudbuild-env eine Datei mit dem Namen known_hosts.github, fügen Sie der Datei den öffentlichen SSH-Schlüssel hinzu und erteilen Sie die erforderliche Berechtigung für die Datei:

cd ~/hello-cloudbuild-env ssh-keyscan -t rsa github.com > known_hosts.github chmod +x known_hosts.github git init git config credential.helper gcloud.sh git remote add google https://github.com/${GITHUB_USERNAME}/hello-cloudbuild-env git branch -m master git add . && git commit -m "initial commit" git push google master cd ~/hello-cloudbuild-env git checkout -b production

4. Ersetzen Sie als Nächstes die Datei cloudbuild.yaml aus dem Repository hello-cloudbuild-env und übernehmen Sie die Änderung:

cd ~/hello-cloudbuild-env

5. Ersetzen Sie die Datei cloudbuild.yaml im Repository hello-cloudbuild-env durch den folgenden Code. Ersetzen Sie {GITHUB-USERNAME} durch Ihren persönlichen GitHub-Nutzernamen:

# Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # [START cloudbuild-delivery] steps: # This step deploys the new version of our container image # in the hello-cloudbuild Kubernetes Engine cluster. - name: 'gcr.io/cloud-builders/kubectl' id: Deploy args: - 'apply' - '-f' - 'kubernetes.yaml' env: - 'CLOUDSDK_COMPUTE_REGION={{{ project_0.default_region }}}' - 'CLOUDSDK_CONTAINER_CLUSTER=hello-cloudbuild' # Access the id_github file from Secret Manager, and setup SSH - name: 'gcr.io/cloud-builders/git' secretEnv: ['SSH_KEY'] entrypoint: 'bash' args: - -c - | echo "$$SSH_KEY" >> /root/.ssh/id_rsa chmod 400 /root/.ssh/id_rsa cp known_hosts.github /root/.ssh/known_hosts volumes: - name: 'ssh' path: /root/.ssh # Clone the repository - name: 'gcr.io/cloud-builders/git' args: - clone - --recurse-submodules - git@github.com:${GITHUB-USERNAME}/hello-cloudbuild-env.git volumes: - name: ssh path: /root/.ssh # This step copies the applied manifest to the production branch # The COMMIT_SHA variable is automatically # replaced by Cloud Build. - name: 'gcr.io/cloud-builders/gcloud' id: Copy to production branch entrypoint: /bin/sh args: - '-c' - | set -x && \ cd hello-cloudbuild-env && \ git config user.email $(gcloud auth list --filter=status:ACTIVE --format='value(account)') sed "s/GOOGLE_CLOUD_PROJECT/${PROJECT_ID}/g" kubernetes.yaml.tpl | \ git fetch origin production && \ # Switch to the production branch and copy the kubernetes.yaml file from the candidate branch git checkout production && \ git checkout $COMMIT_SHA kubernetes.yaml && \ # Commit the kubernetes.yaml file with a descriptive commit message git commit -m "Manifest from commit $COMMIT_SHA $(git log --format=%B -n 1 $COMMIT_SHA)" && \ # Push the changes back to Cloud Source Repository git push origin production volumes: - name: ssh path: /root/.ssh availableSecrets: secretManager: - versionName: projects/${PROJECT_NUMBER}/secrets/ssh_key_secret/versions/1 env: 'SSH_KEY' # [END cloudbuild-delivery] options: logging: CLOUD_LOGGING_ONLY git add . git commit -m "Create cloudbuild.yaml for deployment"

In der Datei cloudbuild.yaml wird der Deployment-Prozess beschrieben, der in Cloud Build ausgeführt werden soll. Er besteht aus zwei Schritten:

• Cloud Build wendet das Manifest auf den GKE-Cluster an.
• Bei Erfolg kopiert Cloud Build das Manifest in den Zweig „production“.

6. Erstellen Sie einen Zweig mit der Bezeichnung „candidate“ und übertragen Sie beide Zweige per Push in GitHub-Repositories, damit sie dort verfügbar sind.

git checkout -b candidate git push google production git push google candidate

Trigger für die CD-Pipeline erstellen

1. Geben Sie in der Titelleiste der Console Cloud Build-Trigger ein und klicken Sie dann auf Trigger, Cloud Build.

2. Klicken Sie auf Trigger erstellen.

3. Geben Sie für Name den Wert hello-cloudbuild-deploy an. Legen Sie Region auf fest.

4. Wählen Sie unter Ereignis die Option Push zu Zweig aus.

5. Klicken Sie unter Quelle für Repository auf Neues Repository verbinden.

   a. Wählen Sie GitHub (Cloud Build-GitHub-App) aus. Klicken Sie auf Weiter.

   b. Authentifizieren Sie sich mit Ihrem Nutzernamen und Passwort in Ihrem Quell-Repository.

   c. Wählen Sie das Repository ${GITHUB_USERNAME}/hello-cloudbuild-env aus. Klicken Sie auf OK.

   d. Wählen Sie Mir ist bewusst, dass GitHub-Inhalte für die ausgewählten Repositories… aus.

   e. Klicken Sie auf Verbinden.

6. Wählen Sie unter Repository die Option ${GITHUB_USERNAME}/hello-cloudbuild-env aus.

7. Wählen Sie unter Quelle die Option ^candidate$ als Zweig aus.

8. Wählen Sie unter Build-Konfiguration die Option Cloud Build-Konfigurationsdatei aus.

9. Geben Sie im Feld Speicherort der Cloud Build-Konfigurationsdatei nach dem / cloudbuild.yaml ein.

10. Setzen Sie Dienstkonto auf das Compute Engine-Standarddienstkonto.

11. Klicken Sie auf Erstellen.

12. Erstellen Sie im Verzeichnis hello-cloudbuild-app eine Datei mit dem Namen known_hosts.github, fügen Sie der Datei den öffentlichen SSH-Schlüssel hinzu und erteilen Sie die erforderliche Berechtigung für die Datei:

cd ~/hello-cloudbuild-app ssh-keyscan -t rsa github.com > known_hosts.github chmod +x known_hosts.github git add . git commit -m "Adding known_host file." git push google master

CI-Pipeline ändern, damit die CD-Pipeline ausgelöst wird

Als Nächstes fügen Sie der CI-Pipeline einige Schritte hinzu, damit eine neue Version des Kubernetes-Manifests erzeugt wird, und übertragen dieses per Push in das Repository hello-cloudbuild-env, damit die CD-Pipeline ausgelöst wird.

• Kopieren Sie die erweiterte Version der Datei cloudbuild.yaml in das Repository app:

cd ~/hello-cloudbuild-app

Die Datei cloudbuild.yaml fügt die Schritte hinzu, durch die das neue Kubernetes-Manifest erzeugt und die CD-Pipeline ausgelöst wird.

Build konfigurieren

1. Ersetzen Sie die Datei cloudbuild.yaml im Repository hello-cloudbuild-app durch den folgenden Code. Ersetzen Sie ${GITHUB_USERNAME} durch Ihren GitHub-Nutzernamen:

# Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # [START cloudbuild] steps: # This step runs the unit tests on the app - name: 'python:3.7-slim' id: Test entrypoint: /bin/sh args: - -c - 'pip install flask && python test_app.py -v' # This step builds the container image. - name: 'gcr.io/cloud-builders/docker' id: Build args: - 'build' - '-t' - '{{{ project_0.default_region }}}-docker.pkg.dev/$PROJECT_ID/my-repository/hello-cloudbuild:$SHORT_SHA' - '.' # This step pushes the image to Artifact Registry # The PROJECT_ID and SHORT_SHA variables are automatically # replaced by Cloud Build. - name: 'gcr.io/cloud-builders/docker' id: Push args: - 'push' - '{{{ project_0.default_region }}}-docker.pkg.dev/$PROJECT_ID/my-repository/hello-cloudbuild:$SHORT_SHA' # [END cloudbuild] # Access the id_github file from Secret Manager, and setup SSH - name: 'gcr.io/cloud-builders/git' secretEnv: ['SSH_KEY'] entrypoint: 'bash' args: - -c - | echo "$$SSH_KEY" >> /root/.ssh/id_rsa chmod 400 /root/.ssh/id_rsa cp known_hosts.github /root/.ssh/known_hosts volumes: - name: 'ssh' path: /root/.ssh # Clone the repository - name: 'gcr.io/cloud-builders/git' args: - clone - --recurse-submodules - git@github.com:${GITHUB-USERNAME}/hello-cloudbuild-env.git volumes: - name: ssh path: /root/.ssh # [START cloudbuild-trigger-cd] # This step clones the hello-cloudbuild-env repository - name: 'gcr.io/cloud-builders/gcloud' id: Change directory entrypoint: /bin/sh args: - '-c' - | cd hello-cloudbuild-env && \ git checkout candidate && \ git config user.email $(gcloud auth list --filter=status:ACTIVE --format='value(account)') volumes: - name: ssh path: /root/.ssh # This step generates the new manifest - name: 'gcr.io/cloud-builders/gcloud' id: Generate manifest entrypoint: /bin/sh args: - '-c' - | sed "s/GOOGLE_CLOUD_PROJECT/${PROJECT_ID}/g" kubernetes.yaml.tpl | \ sed "s/COMMIT_SHA/${SHORT_SHA}/g" > hello-cloudbuild-env/kubernetes.yaml volumes: - name: ssh path: /root/.ssh # This step pushes the manifest back to hello-cloudbuild-env - name: 'gcr.io/cloud-builders/gcloud' id: Push manifest entrypoint: /bin/sh args: - '-c' - | set -x && \ cd hello-cloudbuild-env && \ git add kubernetes.yaml && \ git commit -m "Deploying image {{{ project_0.default_region }}}-docker.pkg.dev/$PROJECT_ID/my-repository/hello-cloudbuild:${SHORT_SHA} Built from commit ${COMMIT_SHA} of repository hello-cloudbuild-app Author: $(git log --format='%an <%ae>' -n 1 HEAD)" && \ git push origin candidate volumes: - name: ssh path: /root/.ssh availableSecrets: secretManager: - versionName: projects/${PROJECT_NUMBER}/secrets/ssh_key_secret/versions/1 env: 'SSH_KEY' # [END cloudbuild-trigger-cd] options: logging: CLOUD_LOGGING_ONLY Hinweis: Diese Pipeline verwendet einen einfachen sed-Befehl, um die Manifestvorlage zu rendern. In der Praxis bietet es sich an, dafür ein spezielles Tool wie kustomize oder skaffold zu verwenden, da Sie damit mehr Kontrolle über das Rendern von Manifestvorlagen haben.

2. Übernehmen Sie die Änderungen und übertragen Sie diese per Push in GitHub-Repositories:

cd ~/hello-cloudbuild-app git add cloudbuild.yaml git commit -m "Trigger CD pipeline" git push google master

Dadurch wird die CI-Pipeline in Cloud Build ausgelöst.

Klicken Sie auf Fortschritt prüfen. Testumgebung und CD-Pipeline erstellen

Aufgabe 7: Cloud Build-Pipeline überprüfen

In dieser Aufgabe überprüfen Sie die Cloud Build-Pipeline in der Console.

1. Klicken Sie in der Console im linken Bereich auf der Seite „Cloud Build“ auf Dashboard.
2. Klicken Sie auf den Trigger der hello-cloudbuild-app, um seine Ausführung zu beobachten und die Logs aufzurufen. Im letzten Schritt dieser Pipeline wird das neue Manifest per Push in das Repository hello-cloudbuild-env übertragen, wodurch die CD-Pipeline ausgelöst wird.
3. Kehren Sie zum Haupt-Dashboard zurück.
4. Sie sollten einen Build für das Repository hello-cloudbuild-env sehen, der gerade ausgeführt wird oder kürzlich abgeschlossen wurde.

Sie können auf den Build klicken, um dessen Ausführung zu verfolgen und die Logs zu überprüfen.

Aufgabe 8: Vollständige Pipeline testen

Sie haben jetzt die gesamte CI/CD-Pipeline konfiguriert. In dieser Aufgabe führen Sie einen End-to-End-Test durch.

1. Klicken Sie in der Console im Navigationsmenü () auf Kubernetes Engine > Gateways, Dienste und eingehender Traffic > Dienste.

Auf der Seite sollte nur ein Dienst namens hello-cloudbuild aufgelistet sein. Dieser wurde durch den CD-Build erstellt, der gerade ausgeführt wurde.

2. Klicken Sie auf den Endpunkt für den Dienst hello-cloudbuild. Es sollte „Hello World!“ angezeigt werden. Wenn kein Endpunkt vorhanden ist oder ein Load Balancer-Fehler auftritt, müssen Sie möglicherweise einige Minuten warten, bis der Load Balancer vollständig initialisiert wurde. Falls erforderlich, klicken Sie auf Aktualisieren, um die Seite neu zu laden.

3. Ersetzen Sie in Cloud Shell sowohl bei der Anwendung als auch beim Unittest „Hello World“ durch „Hello Cloud Build“.

cd ~/hello-cloudbuild-app sed -i 's/Hello World/Hello Cloud Build/g' app.py sed -i 's/Hello World/Hello Cloud Build/g' test_app.py

4. Führen Sie ein Commit der Änderung durch und übertragen Sie sie per Push an die GitHub-Repositories:

git add app.py test_app.py git commit -m "Hello Cloud Build" git push google master

5. Dadurch wird die gesamte CI/CD-Pipeline ausgelöst.

Aktualisieren Sie die Anwendung in Ihrem Browser nach einigen Minuten. Es sollte jetzt „Hello Cloud Build!“ angezeigt werden.

Aufgabe 9: Rollback testen

In dieser Aufgabe führen Sie ein Rollback zur Version der Anwendung durch, in der „Hello World!“ angezeigt wurde.

1. Geben Sie in der Titelleiste der Console Cloud Build-Dashboard in das Suchfeld ein und klicken Sie in den Suchergebnissen auf Cloud Build. Achten Sie darauf, dass im linken Bereich Dashboard ausgewählt ist.
2. Klicken Sie auf den Link Alle anzeigen unter Build-Verlauf für das Repository hello-cloudbuild-env.
3. Klicken Sie auf den zweitaktuellsten Build.
4. Klicken Sie auf Neu erstellen.

Wenn der Build fertig erstellt ist, laden Sie die Anwendung noch einmal in Ihrem Browser. Nun sollte wieder „Hello World!“ angezeigt werden.

Das wars! Sie haben das Lab erfolgreich abgeschlossen.

Jetzt können Sie Cloud Build verwenden, um CI-Pipelines mit GKE auf Google Cloud zu erstellen und zurückzusetzen.

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 19. Februar 2025 aktualisiert

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