Continuous Delivery-Pipelines mit Spinnaker und GKE

In dieser Anleitung erfahren Sie, wie Sie eine Continuous-Delivery-Pipeline mit Google Kubernetes Engine (GKE), Cloud Source Repositories, Cloud Build und Spinnaker for Google Cloud erstellen. Nachdem Sie eine Beispielanwendung erstellt haben, konfigurieren Sie diese Dienste so, dass die Anwendung automatisch erstellt, getestet und bereitgestellt wird. Wenn Sie den Anwendungscode später ändern, wird die Continuous-Delivery-Pipeline ausgelöst, um die aktualisierte Version automatisch neu zu erstellen, zu testen und bereitzustellen.

Die State of DevOps-Berichte haben Faktoren aufgezeigt, die die Leistung bei der Softwarebereitstellung beeinflussen. In dieser Anleitung werden die folgenden Funktionen erläutert:

Pipeline-Architektur

Das folgende Diagramm veranschaulicht die Architektur der Pipeline zur kontinuierlichen Bereitstellung.

Pipeline-Architektur für Entwickler und Nutzer

Zur kontinuierlichen Bereitstellung von Anwendungsupdates an Ihre Nutzer benötigen Sie einen automatisierten Prozess, der Ihre Software zuverlässig erstellt, testet und aktualisiert. Codeänderungen sollten automatisch durch eine Pipeline fließen, die Artefakterstellung, Einheitentests, Funktionstests und Produktionseinführungen umfasst. In einigen Fällen kann es erforderlich sein, eine Codeaktualisierung nur für einige Nutzer bereitzustellen, um den aktualisierten Code zuerst in der Praxis zu testen, bevor Sie ihn für alle Nutzer bereitstellen. Wenn einer dieser Canary-Releases nicht zufriedenstellend ist, muss das automatisierte Verfahren in der Lage sein, schnell ein Rollback der Softwareänderung durchzuführen.

Mit GKE und Spinnaker können Sie einen stabilen Continuous-Delivery-Fluss erstellen, damit Ihre Software genauso schnell ausgeliefert wird, wie sie entwickelt und geprüft wurde. Auch wenn eine schnelle Ausführung das letztendliche Ziel ist, müssen Sie zuerst einmal dafür sorgen, dass jede Anwendungsänderung eine Reihe von automatisierten Prüfungen besteht, bevor sie in die Produktion überführt wird. Wenn eine bestimmte Änderung automatisch geprüft wurde, können Sie die Anwendung danach auch manuell validieren und vor ihrer Veröffentlichung weiter testen.

Nachdem Ihr Team entschieden hat, dass die Anwendung produktionsreif ist, kann sie von einem Ihrer Teammitglieder für die Bereitstellung in der Produktion genehmigt werden.

Pipeline für Anwendungsbereitstellung

In dieser Anleitung erstellen Sie die Continuous-Delivery-Pipeline, die im folgenden Diagramm dargestellt ist.

Architektur der Pipeline für die Anwendungsbereitstellung

Für diese Pipeline müssen folgende Schritte ausgeführt werden:

  1. Ein Entwickler ändert Code und überträgt ihn in ein Repository.

  2. Cloud Build erkennt die Änderungen, erstellt das Docker-Image, testet das Image und überträgt das Image an Spinnaker.

  3. Spinnaker erkennt das Image, stellt es für Canary bereit und testet die Canary-Bereitstellung. Nach einer manuellen Genehmigung stellt Spinnaker das Image für die Produktion bereit.

Ziele

  • Umgebung einrichten: Cloud Shell starten und Spinnaker for Google Cloud bereitstellen
  • GKE-Cluster erstellen, in dem die Beispielanwendung bereitgestellt werden soll
  • Beispielanwendung herunterladen, Git-Repository erstellen und dieses in Cloud Source Repositories hochladen
  • Docker-Image erstellen
  • Trigger festlegen, um Docker-Images zu erstellen, wenn sich die Anwendung ändert
  • Spinnaker-Pipeline für die zuverlässige und kontinuierliche Bereitstellung Ihrer Anwendung in GKE
  • Eine Codeänderung bereitstellen, die Pipeline auslösen und die Änderung in der Produktion beobachten.

Kosten

In dieser Anleitung werden kostenpflichtige Komponenten von Google Cloud verwendet, darunter:

  • GKE
  • Cloud Load Balancing
  • Cloud Build
  • Cloud Quell-Repositories
  • Container Registry

Sie können mithilfe des Preisrechners eine Kostenschätzung für Ihre voraussichtliche Nutzung erstellen.

Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Hinweis

  1. Melden Sie sich bei Ihrem Google-Konto an.

    Wenn Sie noch kein Konto haben, melden Sie sich hier für ein neues Konto an.

  2. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  3. Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

  4. GKE, Cloud Build, and Cloud Source Repositories APIs aktivieren.

    Aktivieren Sie die APIs

Umgebung einrichten

In diesem Abschnitt konfigurieren Sie die für diese Anleitung erforderliche Infrastruktur.

Spinnaker for Google Cloud mit Cloud Shell bereitstellen

Dazu führen Sie alle Terminalbefehle in dieser Anleitung über Cloud Shell aus.

Mit Spinnaker for Google Cloud können Sie Spinnaker mit einer produktionsfertigen Konfiguration, die für Google Cloud optimiert wurde, einrichten und verwalten. Spinnaker for Google Cloud ermöglicht das Einrichten von Ressourcen (GKE, Cloud Memorystore, Cloud Storage-Buckets und Dienstkonten), das Einbinden von Spinnaker in zugehörige Dienste wie Cloud Build sowie das Bereitstellen einer Cloud Shell-basierten Verwaltungsumgebung für Ihre Spinnaker-Installationen mit Hilfsfunktionen und gängigen Tools wie spin und hal.

  1. Öffnen Sie Spinnaker for Google Cloud in Cloud Shell. Dadurch wird das Spinnaker for Google Cloud-Repository in Ihre Cloud Shell-Umgebung geklont und die detaillierte Installationsanleitung gestartet.

    Zu Cloud Shell

  2. Konfigurieren Sie Git. Wenn Sie Git bereits konfiguriert haben, können Sie diesen Schritt überspringen.

    git config --global user.email "EMAIL_ADDRESS"
    git config --global user.name "USERNAME"
    

    Ersetzen Sie Folgendes:

    • EMAIL_ADDRESS: Ihre Git-E-Mail-Adresse
    • USERNAME: Ihr Git-Nutzername
  3. Legen Sie eine Umgebungsvariable fest, die angibt, in welchem Cloud-Projekt Spinnaker installiert werden soll:

    DEVSHELL_PROJECT_ID=YOUR_PROJECT_ID
    

    Ersetzen Sie YOUR_PROJECT_ID durch das Projekt, das Sie für diese Anleitung ausgewählt oder erstellt haben.

  4. Installieren Sie Spinnaker for Google Cloud.

    PROJECT_ID=${DEVSHELL_PROJECT_ID} ~/cloudshell_open/spinnaker-for-gcp/scripts/install/setup_properties.sh
    ~/cloudshell_open/spinnaker-for-gcp/scripts/install/setup.sh
    
  5. Starten Sie Cloud Shell neu, um neue Umgebungseinstellungen zu laden.

  6. Stellen Sie eine Verbindung zu Spinnaker her.

    ~/cloudshell_open/spinnaker-for-gcp/scripts/manage/connect_unsecured.sh
    
  7. Klicken Sie in Cloud Shell auf das Symbol für die Webvorschau und wählen Sie Preview on port 8080 (Vorschau auf Port 8080) aus.

  8. Daraufhin wird der Willkommensbildschirm angezeigt, gefolgt von der Spinnaker-Benutzeroberfläche.

GKE-Cluster für Anwendungsbereitstellungen erstellen

Ein gängiges Muster ist die Verwendung eines GKE-Clusters für Builds, Bereitstellungen usw. und von zusätzlichen GKE-Clustern für das Ausführen der Anwendungen. In diesem Abschnitt erstellen Sie einen weiteren GKE-Cluster, app-cluster, in dem die Beispielanwendung bereitgestellt wird.

  1. Erstellen Sie in Cloud Shell einen neuen GKE-Cluster:

    ZONE=us-east1-c
    gcloud config set compute/zone $ZONE
    gcloud container clusters create app-cluster \
    --machine-type=n1-standard-2
    
  2. Fügen Sie Spinnaker den neuen GKE-Cluster hinzu. Die Standardwerte sollten korrekt sein.

    ~/cloudshell_open/spinnaker-for-gcp/scripts/manage/add_gke_account.sh
    

    Beispiel für Ausgabe und Werte:

    Please enter the context you wish to use to manage your GKE resources: gke_spinnaker-246920_us-east1-c_app-cluster
    Please enter the id of the project within which the referenced cluster lives: spinnaker-246920
    Please enter a name for the new Spinnaker account: app-cluster-acct
    

  3. Wählen Sie als Kubernetes-Kontext wieder Ihren Spinnaker-Cluster aus:

    kubectl config use-context gke_${DEVSHELL_PROJECT_ID}_${ZONE}_spinnaker-1
    
  4. Übertragen Sie die Konfigurationsänderungen per Push zu Spinnaker und wenden Sie sie an:

    ~/cloudshell_open/spinnaker-for-gcp/scripts/manage/push_and_apply.sh
    

Docker-Image erstellen

In diesem Abschnitt konfigurieren Sie Cloud Build, damit es Änderungen an Ihrem Anwendungsquellcode erkennt, ein Docker-Image erstellt und es mithilfe von Push in Container Registry überträgt.

Quellcode-Repository erstellen

  1. Laden Sie in Cloud Shell den Beispielquellcode herunter:

    cd ~
    wget https://gke-spinnaker.storage.googleapis.com/sample-app-v4.tgz
    
  2. Entpacken Sie den Quellcode:

    tar xzfv sample-app-v4.tgz
    
  3. Wechseln Sie in das Verzeichnis mit dem Quellcode:

    cd sample-app
    
  4. Führen Sie den ersten Commit in Ihrem Quellcode-Repository aus:

    git init
    git add .
    git commit -m "Initial commit"
    
  5. Erstellen Sie ein Repository zum Hosten Ihres Codes:

    gcloud source repos create sample-app
    git config credential.helper gcloud.sh
    
  6. Fügen Sie Ihr neu erstelltes Repository als remote hinzu:

    export PROJECT=$(gcloud info --format='value(config.project)')
    git remote add origin https://source.developers.google.com/p/$PROJECT/r/sample-app
    
  7. Übertragen Sie den Code in den Master-Branch des Repositorys:

    git push origin master
  8. Überprüfen Sie, ob der Quellcode in der Konsole angezeigt wird.

    Zum Quellcode

Build-Trigger konfigurieren

Das folgende Diagramm zeigt den Trigger, den Sie in diesem Abschnitt erstellen.

Spinnaker-Workflow

Sie konfigurieren Cloud Build so, dass Ihre Docker-Images jedes Mal erstellt und gepusht werden, wenn Sie Git-Tags mithilfe von Push in Ihr Quell-Repository übertragen. Cloud Build ruft automatisch Ihren Quellcode ab, erstellt das Docker-Image aus dem Dockerfile in Ihrem Repository und überträgt das Image mit Push in Cloud Container Registry.

  1. Klicken Sie in der Cloud Console im Abschnitt Cloud Build auf Trigger und dann auf Trigger erstellen.

    Zur Seite „Build-Trigger“

  2. Legen Sie die folgenden Trigger-Einstellungen fest:

    • Name: sample-app-tags.
    • Ereignis: Wählen Sie Neues Tag per Push übertragen aus.
    • Repository: sample-app.
    • Tag (regulärer Ausdruck): v.*.
    • Build-Konfiguration: /cloudbuild.yaml.
  3. Klicken Sie auf Erstellen.

Ab jetzt erstellt Cloud Build Ihre Anwendung automatisch und überträgt sie mithilfe von Push als Docker-Image in Container Registry, sobald Sie ein Git-Tag mit dem Buchstaben "v" als Präfix per Push in Ihr Quellcode-Repository übertragen.

Kubernetes-Manifeste für den Einsatz in Spinnaker vorbereiten

Spinnaker benötigt Zugriff auf Ihre Kubernetes-Manifeste, um sie in den Clustern bereitzustellen. In diesem Abschnitt wird ein Cloud Storage-Bucket erstellt, in dem während des CI-Prozesses in Cloud Build Ihre Manifeste gespeichert werden. Sobald sich die Manifeste in Cloud Storage befinden, kann Spinnaker sie während der Ausführung Ihrer Pipeline herunterladen und anwenden.

  1. Erstellen Sie den Bucket:

    export PROJECT=$(gcloud info --format='value(config.project)')
    gsutil mb gs://$PROJECT-kubernetes-manifests
    
  2. Aktivieren Sie die Versionsverwaltung im Bucket, damit Sie einen Verlauf der Manifeste erhalten:

    gsutil versioning set on gs://$PROJECT-kubernetes-manifests
    
  3. Legen Sie in den Kubernetes-Deployment-Manifesten die richtige Google Cloud-Projekt-ID fest:

    sed -i s/PROJECT/$PROJECT/g k8s/deployments/*
    
  4. Übernehmen Sie die Änderungen im Repository:

    git commit -a -m "Set project ID"
    

Bereitstellungspipelines konfigurieren

Ihre Images werden jetzt automatisch erstellt, müssen aber noch im Kubernetes-Cluster bereitgestellt werden.

Das folgende Diagramm veranschaulicht die Schritte der Bereitstellungspipeline.

Bereitstellungspipeline konfigurieren

Die Bereitstellung wird für Integrationstests in einer reduzierten Umgebung durchgeführt. Wenn die Integrationstests erfolgreich waren, müssen Sie die Änderungen manuell genehmigen, um den Code für Produktionsdienste bereitstellen zu können.

Deployment-Pipeline erstellen

  1. Verwenden Sie spin, um in Spinnaker eine Anwendung zu erstellen.

    spin application save --application-name sample \
                          --owner-email example@example.com \
                          --cloud-providers kubernetes \
                          --gate-endpoint http://localhost:8080/gate
    

    Nun erstellen Sie die Continuous-Delivery-Pipeline. In dieser Anleitung ist die Pipeline so konfiguriert, dass sie erkennt, wenn ein Docker-Image mit einem Tag mit dem Präfix v in der Container Registry angekommen ist.

  2. Führen Sie auf einem neuen Tab von Cloud Shell den folgenden Befehl im Quellcodeverzeichnis aus, um eine Beispielpipeline in Ihre Spinnaker-Instanz zu laden:

    export PROJECT=$(gcloud info --format='value(config.project)')
    sed s/PROJECT/$PROJECT/g spinnaker/pipeline-deploy.json > pipeline.json
    spin pipeline save --gate-endpoint http://localhost:8080/gate -f pipeline.json
    

Image erstellen

Führen Sie die folgenden Schritte aus, um Ihr erstes Image mithilfe von Push zu übertragen.

  1. Wechseln Sie in Cloud Shell zu Ihrem Quellcode-Verzeichnis.
  2. Erstellen Sie ein Git-Tag:

    git tag v1.0.0
  3. Übertragen Sie das Tag mit Push:

    git push --tags
  4. Klicken Sie in Cloud Build auf Build-Verlauf, um zu prüfen, ob der Build ausgelöst wurde. Wenn nicht, überprüfen Sie, ob der Trigger im vorherigen Abschnitt ordnungsgemäß konfiguriert wurde.

    Zur Seite "Build-Verlauf"

    Build-Verlauf

Pipeline-Ausführung anzeigen lassen

In der soeben erstellten Konfiguration werden Benachrichtigungen über neu mit Tags gekennzeichnete Images verwendet, um eine Spinnaker-Pipeline auszulösen. In einem vorherigen Schritt haben Sie ein Tag per Push in Cloud Source Repositories übertragen. Daraufhin hat Cloud Build das Image erstellt und in Container Registry verschoben. Sie können nun die ausgelöste Pipeline prüfen.

  1. Klicken Sie auf Pipelines, um zur Seite "Pipelines" zurückzukehren.

  2. Klicken Sie auf Details für weitere Informationen zum Fortschritt der Pipeline. Dieser Abschnitt zeigt den Status der Bereitstellungspipeline und die zugehörigen Schritte. Blau hervorgehobene Schritte werden derzeit ausgeführt, grün hervorgehobene Schritte wurden erfolgreich abgeschlossen und rot hervorgehobene Schritte sind fehlgeschlagen. Klicken Sie auf eine Phase für weitere Informationen.

    Nach 3 bis 5 Minuten ist die Integrationstestphase abgeschlossen und die Pipeline muss manuell genehmigt werden, um die Bereitstellung fortzusetzen.

  3. Zeigen Sie auf Push to production (Push-Übertragung in Produktion) und klicken Sie dann auf Continue (Weiter).

    Ihr Rollout wird für die Front-End- und Back-End-Bereitstellungen des Produkts fortgesetzt. Es ist nach ein paar Minuten fertig.

  4. Sie können sich die Anwendung anzeigen lassen. Wählen Sie dazu oben in der Spinnaker-UI Infrastructure (Infrastruktur) > Load Balancers (Load-Balancer) aus.

    Drop-down-Liste der Infrastruktur mit ausgewählten Load-Balancern

  5. Scrollen Sie in der Liste der Load-Balancer nach unten und klicken Sie unter sample-frontend-production auf Default (Standard).

    Standard-Load-Balancer

  6. Scrollen Sie im Detailbereich auf der rechten Seite nach unten und kopieren Sie die IP-Adresse Ihrer Anwendung, indem Sie in der Ingress-IP auf die Zwischenablage klicken. Der Ingress-IP-Link von der Spinnaker-Benutzeroberfläche verwendet standardmäßig HTTPS, die Anwendung ist jedoch für die Verwendung von HTTP konfiguriert.

    Detailbereich mit der IP-Adresse Ihrer App

  7. Fügen Sie die Adresse in Ihren Browser ein, damit Sie die Produktionsversion der Anwendung sehen können.

    Produktionsversion der App

    Sie haben die Pipeline, die Ihre Anwendung erstellt, testet und bereitstellt, jetzt manuell ausgelöst.

Pipeline über Codeänderungen auslösen

In diesem Abschnitt führen Sie einen End-to-End-Test der Pipeline durch, indem Sie eine Codeänderung vornehmen, ein Git-Tag mithilfe von Push übertragen und beobachten, wie die Pipeline daraufhin ausgeführt wird. Durch Push-Übertragung eines Git-Tags, das mit "v" beginnt, veranlassen Sie Cloud Build, ein neues Docker-Image zu erstellen und mithilfe von Push in Container Registry zu übertragen. Spinnaker erkennt, dass das neue Image-Tag mit "v" beginnt, und löst eine Pipeline aus, um eine Canary-Implementierung des Images durchzuführen, Tests auszuführen und das Image an alle Pods in der Implementierung zu verteilen.

  1. Ändern Sie die Farbe der Anwendung von Orange zu Blau:

    cd ~/sample-app
    sed -i 's/orange/blue/g' cmd/gke-info/common-service.go
    
  2. Versehen Sie Ihre Änderung mit einem Tag und übertragen Sie sie mithilfe von Push in das Quellcode-Repository:

    git commit -a -m "Change color to blue"
    git tag v1.0.1
    git push --tags
    
  3. Der neue Build wird im Build-Verlauf von Cloud Build angezeigt.

  4. Klicken Sie auf Pipelines, um zu beobachten, wie die Pipeline das Image bereitstellt.

  5. Beobachten Sie die Canary-Bereitstellungen. Wenn die Bereitstellung angehalten wird und auf die Übernahme in die Produktion wartet, aktualisieren Sie den Tab mit Ihrer Anwendung. Vier der Back-Ends verwenden die vorherige Version der Anwendung, während nur ein Back-End die Canary-Version ausführt. Die neue, blaue Version Ihrer Anwendung erscheint etwa jedes zehnte Mal, wenn Sie sie aktualisieren.

  6. Kehren Sie nach Abschluss der Tests zum Tab Spinnaker zurück und genehmigen Sie die Bereitstellung.

  7. Wenn die Pipeline abgeschlossen ist, entspricht Ihre Anwendung der Darstellung im folgenden Screenshot. Im Feld Version wird jetzt v1.0.1 angezeigt.

    Produktionsversion der aktualisierten App

    Sie haben Ihre Anwendung jetzt erfolgreich in der gesamten Produktionsumgebung bereitgestellt.

  8. Optional können Sie ein Rollback dieser Änderung durchführen, indem Sie den vorherigen Commit zurücksetzen. Das Rollback fügt dann ein neues Tag ((v1.0.2) hinzu. Dieses Tag wird per Push über dieselbe Pipeline zurückübertragen, die Sie zur Bereitstellung von v1.0.1 verwendet haben:

    git revert v1.0.1
    git tag v1.0.2
    git push --tags

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder behalten Sie das Projekt und löschen Sie die einzelnen Ressourcen.

  1. Löschen Sie Spinnaker for Google Cloud:

    cd ~
    ~/cloudshell_open/spinnaker-for-gcp/scripts/manage/generate_deletion_script.sh
    ~/cloudshell_open/spinnaker-for-gcp/scripts/manage/delete-all_${DEVSHELL_PROJECT_ID}_spinnaker-1_spinnaker-1.sh
    
  2. Löschen Sie den GKE-Cluster:

    gcloud container clusters delete app-cluster --zone=us-east1-c
    
  3. Löschen Sie das Repository:

    gcloud source repos delete sample-app
    
  4. Löschen Sie den Bucket:

    export PROJECT=$(gcloud info --format='value(config.project)')
    export BUCKET=$PROJECT-kubernetes-manifests
    gsutil -m rm -r gs://$BUCKET
    
  5. Löschen Sie die Container-Images:

    export PROJECT=$(gcloud info --format='value(config.project)')
    gcloud container images delete gcr.io/$PROJECT/sample-app:v1.0.0
    gcloud container images delete gcr.io/$PROJECT/sample-app:v1.0.1
    
  6. Wenn Sie oben im optionalen Rollback-Schritt v1.0.2 erstellt haben, löschen Sie dieses Container-Image:

    gcloud container images delete gcr.io/$PROJECT/sample-app:v1.0.2
    

Nächste Schritte