Hochstufen von Releases und Fortsetzen von Roll-outs in Cloud Deploy automatisieren

Auf dieser Seite wird beschrieben, wie Sie mit Cloud Deploy eine Release automatisch auf ein Ziel hochstufen und einen Roll-out in die nächste Phase verschieben.

Dieser Schnellstart erläutert folgende Schritte:

  1. Erstellen Sie zwei GKE-Cluster oder zwei Cloud Run-Dienste.

  2. Erstellen Sie eine Skaffold-Konfiguration und entweder ein Kubernetes-Manifest oder eine Cloud Run-Dienstdefinition.

  3. Definieren Sie Ihre Cloud Deploy-Bereitstellungspipeline und Bereitstellungsziele.

    Die Pipeline wird auf zwei Ziele bereitgestellt: dev und staging. Das staging-Ziel verwendet eine Canary-Bereitstellungsstrategie.

  4. Definieren Sie zwei Automatisierungsregeln:

    • Eine Automatisierung, um den Release nach erfolgreichem Roll-out für dev auf das Ziel staging hochzustufen.

    • Eine Automatisierung, um den Roll-out nach erfolgreichem Abschluss der Phase canary-25 in die Phase stable zu verschieben.

  5. Instanziieren Sie Ihre Bereitstellungspipeline. Dazu erstellen Sie einen Release, der automatisch für das Ziel dev bereitgestellt wird.

  6. Sehen Sie sich die Bereitstellungspipeline und das Release in der Google Cloud -Konsole an.

    Aufgrund der automatischen Höherstufung wird dieser Release automatisch in staging hochgestuft.

    Da für das Ziel staging eine Canary-Bereitstellungsstrategie verwendet wird und dies die erste Bereitstellung in dieser Laufzeit ist, wird die Phase canary-25 übersprungen. Weitere Informationen dazu, warum die Canary-Phase beim ersten Mal übersprungen wird, finden Sie unter Warum werden Phasen manchmal übersprungen?.

    Aufgrund der automatischen Phasenverschiebung wird das Roll-out in die Phase stable verschoben.

Hinweise

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Enable the Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage APIs.

    Enable the APIs

  5. Install the Google Cloud CLI.

  6. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

  7. To initialize the gcloud CLI, run the following command:

    gcloud init
  8. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  9. Make sure that billing is enabled for your Google Cloud project.

  10. Enable the Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage APIs.

    Enable the APIs

  11. Install the Google Cloud CLI.

  12. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

  13. To initialize the gcloud CLI, run the following command:

    gcloud init
  14. Wenn Sie die CLI bereits installiert haben, prüfen Sie, ob Sie die aktuelle Version verwenden:

    gcloud components update
    
  15. Prüfen Sie, ob das Compute Engine-Standarddienstkonto die erforderlichen Berechtigungen hat.

    Das Dienstkonto hat möglicherweise bereits die erforderlichen Berechtigungen. Diese Schritte gelten für Projekte, die automatische Rollenzuweisungen für Standarddienstkonten deaktivieren.

    1. Fügen Sie zuerst die Rolle clouddeploy.jobRunner hinzu:
      gcloud projects add-iam-policy-binding PROJECT_ID \
          --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
          --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
          --role="roles/clouddeploy.jobRunner"
      
    2. Rolle clouddeploy.releaser hinzufügen
      gcloud projects add-iam-policy-binding PROJECT_ID \
          --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
          --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
          --role="roles/clouddeploy.releaser"
      
    3. Fügen Sie die Entwicklerrolle für Ihre spezifische Laufzeit hinzu.
      • Für GKE:
        gcloud projects add-iam-policy-binding PROJECT_ID \
            --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
            --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
            --role="roles/container.developer"
        
      • Für Cloud Run:
        gcloud projects add-iam-policy-binding PROJECT_ID \
            --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
            --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
            --role="roles/run.developer"
        
    4. Fügen Sie dem Standarddienstkonto die Rolle iam.serviceAccountUser hinzu, die die Berechtigung actAs für die Bereitstellung in der Laufzeit enthält:
      gcloud iam service-accounts add-iam-policy-binding $(gcloud projects describe PROJECT_ID \
          --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
          --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
          --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
          --role="roles/iam.serviceAccountUser" \
          --project=PROJECT_ID
      
    5. Fügen Sie sich selbst die Rolle iam.serviceAccountUser hinzu, einschließlich der Berechtigung actAs, um das Standarddienstkonto zu verwenden:
      gcloud iam service-accounts add-iam-policy-binding $(gcloud projects describe PROJECT_ID \
          --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
          --member=user:YOUR_EMAIL_ADDRESS \
          --role="roles/iam.serviceAccountUser" \
          --project=PROJECT_ID
      

      In diesem Fall ist YOUR_EMAIL_ADDRESS die E‑Mail-Adresse, mit der Sie auf Google Cloud zugreifen.

    Laufzeitumgebungen erstellen

    Wenn Sie in Cloud Run bereitstellen, können Sie diesen Befehl überspringen.

    Erstellen Sie für GKE zwei Cluster: automation-quickstart-cluster-dev und automation-quickstart-cluster-staging mit den Standardeinstellungen. Die Kubernetes API-Endpunkte der Cluster müssen über das öffentliche Internet erreichbar sein. GKE-Cluster sind standardmäßig extern zugänglich.

    gcloud container clusters create-auto automation-quickstart-cluster-dev \
                     --project=PROJECT_ID \
                     --region=us-central1 \
                     && gcloud container clusters create-auto automation-quickstart-cluster-staging \
                     --project=PROJECT_ID \
                     --region=us-central1
    

Rufen Sie Ihre Projektnummer ab.

Sie benötigen Ihre Projektnummer, um das Standarddienstkonto zu identifizieren. Dies ist für die Konfiguration der Automatisierungsressource erforderlich.

  1. Führen Sie den folgenden Befehl aus, um Ihre Projektnummer zu erhalten:

    gcloud projects describe PROJECT_ID
    
  2. Kopieren Sie die Projektnummer aus der Befehlszeilenausgabe und fügen Sie sie hier ein.

    Sie müssen dies nicht als Befehl ausführen. Wenn Sie es hier einfügen, wird die Dienstkontoreferenz in der Automatisierungskonfiguration später in dieser Kurzanleitung eingefügt.

    PROJECT_NUMBER
    

Skaffold-Konfiguration und Anwendungsmanifest vorbereiten

Cloud Deploy verwendet Skaffold, um Details zu den bereitzustellenden Elementen und deren korrekte Bereitstellung für separate Ziele anzugeben.

In dieser Kurzanleitung erstellen Sie eine skaffold.yaml-Datei, in der das Anwendungsmanifest angegeben wird, das zum Bereitstellen der Beispielanwendung verwendet werden soll.

  1. Öffnen Sie ein Terminalfenster.

  2. Erstellen Sie ein neues Verzeichnis und rufen Sie es auf.

    GKE

    mkdir deploy-automation-gke-quickstart
    cd deploy-automation-gke-quickstart
    

    Cloud Run

    mkdir deploy-automation-run-quickstart
    cd deploy-automation-run-quickstart
    
  3. Erstellen Sie eine Datei mit dem Namen skaffold.yaml und mit folgendem Inhalt:

    GKE

    apiVersion: skaffold/v4beta7
    kind: Config
    metadata:
      name: gke-automation
    manifests:
      rawYaml:
      - k8s-deployment.yaml
    deploy:
      kubectl: {}
    

    Cloud Run

    apiVersion: skaffold/v4beta7
    kind: Config
    metadata:
      name: run-automation
    profiles:
    - name: dev
      manifests:
        rawYaml:
        - run-dev.yaml
    - name: staging
      manifests:
        rawYaml:
        - run-staging.yaml
    deploy:
      cloudrun: {}
    

    Diese Datei ist eine minimale Skaffold-Konfiguration. In dieser Kurzanleitung erstellen Sie die Datei. Sie können aber auch von Cloud Deploy eine erstellen lassen, wenn es sich um einfache Anwendungen handelt, die nicht für die Produktion bestimmt sind.

    Weitere Informationen zu dieser Datei finden Sie in der skaffold.yaml-Referenz.

  4. Erstellen Sie die Definition für Ihre Anwendung – ein Paar von Dienstdefinitionen für Cloud Run oder ein Kubernetes-Manifest für GKE.

    GKE

    Erstellen Sie eine Datei mit dem Namen k8s-deployment.yaml und folgendem Inhalt:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: my-deployment
      labels:
        app: my-app
      namespace: default
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: my-app
      template:
        metadata:
          labels:
            app: my-app
        spec:
          containers:
          - name: nginx
            image: my-app-image
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: my-service
      namespace: default
    spec:
      selector:
        app: my-app
      ports:
        - protocol: TCP
          port: 80
    

    Diese Datei ist ein einfaches Kubernetes-Manifest, das zum Bereitstellen der Anwendung verwendet wird. Das bereitzustellende Container-Image wird hier als Platzhalter my-app-image festgelegt, der beim Erstellen des Releases durch das spezifische Image ersetzt wird.

    Cloud Run

    1. Erstellen Sie eine Datei mit dem Namen run-dev.yaml und folgendem Inhalt:

      apiVersion: serving.knative.dev/v1
      kind: Service
      metadata:
        name: my-automation-run-service-dev
      spec:
        template:
          spec:
            containers:
            - image: my-app-image
      
    2. Erstellen Sie eine Datei mit dem Namen run-staging.yaml und folgendem Inhalt:

      apiVersion: serving.knative.dev/v1
      kind: Service
      metadata:
        name: my-automation-run-service-staging
      spec:
        template:
          spec:
            containers:
            - image: my-app-image
      

    Diese Dateien sind einfache Cloud Run-Dienstdefinitionen, die zum Bereitstellen der Anwendung verwendet werden. Das bereitzustellende Container-Image wird hier als Platzhalter my-app-image festgelegt, der beim Erstellen des Releases durch das spezifische Image ersetzt wird.

Bereitstellungspipeline, Ziele und Automatisierung erstellen

Sie können Ihre Lieferpipeline und Ziele in einer Datei oder in separaten Dateien definieren. Sie können auch eine Automatisierungsaktion in einer separaten Datei definieren. In dieser Kurzanleitung wird eine Datei für die Pipeline, die Ziele und die Automatisierung verwendet.

  1. Erstellen Sie Ihre Bereitstellungspipeline, Zieldefinitionen und Automatisierungsaktion:

    GKE

    Erstellen Sie im Verzeichnis deploy-automation-gke-quickstart eine neue Datei: clouddeploy.yaml mit folgendem Inhalt:

    apiVersion: deploy.cloud.google.com/v1
    kind: DeliveryPipeline
    metadata:
      name: my-automation-demo-app-1
    description: Automation demonstration pipeline
    serialPipeline:
      stages:
      - targetId: automation-quickstart-dev
      - targetId: automation-quickstart-staging
        profiles: []
        strategy:
          canary:
            runtimeConfig:
              kubernetes:
                serviceNetworking:
                  service: "my-service"
                  deployment: "my-deployment"
            canaryDeployment:
              percentages: [25]
              verify: false
    ---
    
    apiVersion: deploy.cloud.google.com/v1
    kind: Target
    metadata:
      name: automation-quickstart-dev
    description: Dev cluster to demonstrate deploy automation
    gke:
      cluster: projects/PROJECT_ID/locations/us-central1/clusters/automation-quickstart-cluster-dev
    ---
    
    apiVersion: deploy.cloud.google.com/v1
    kind: Target
    metadata:
      name: automation-quickstart-staging
    description: Staging cluster to demonstrate deploy automation
    gke:
      cluster: projects/PROJECT_ID/locations/us-central1/clusters/automation-quickstart-cluster-staging
    ---
    
    apiVersion: deploy.cloud.google.com/v1
    kind: Automation
    metadata:
      name: my-automation-demo-app-1/promote
    description: promotes a release
    suspended: false
    serviceAccount: PROJECT_NUMBER-compute@developer.gserviceaccount.com
    selector:
      targets:
      - id: automation-quickstart-dev
    rules:
    - promoteReleaseRule:
        name: "promote-release"
        wait: 1m
        toTargetId: "@next"
    ---
    
    apiVersion: deploy.cloud.google.com/v1
    kind: Automation
    metadata:
      name: my-automation-demo-app-1/advance
    description: advances a rollout
    suspended: false
    serviceAccount: PROJECT_NUMBER-compute@developer.gserviceaccount.com
    selector:
      targets:
      - id: automation-quickstart-staging
    rules:
    - advanceRolloutRule:
        name: "advance-rollout"
        sourcePhases: ["canary-25"]
        wait: 1m
    

    Cloud Run

    Erstellen Sie im Verzeichnis deploy-automation-run-quickstart eine neue Datei: clouddeploy.yaml mit folgendem Inhalt:

    apiVersion: deploy.cloud.google.com/v1
    kind: DeliveryPipeline
    metadata:
      name: my-automation-demo-app-1
    description: Automation demonstration pipeline
    serialPipeline:
      stages:
      - targetId: automation-quickstart-dev
        profiles: [dev]
      - targetId: automation-quickstart-staging
        profiles: [staging]
        strategy:
          canary:
            runtimeConfig:
              cloudRun:
                automaticTrafficControl: true
            canaryDeployment:
              percentages: [25]
              verify: false
    ---
    
    apiVersion: deploy.cloud.google.com/v1
    kind: Target
    metadata:
      name: automation-quickstart-dev
    description: Dev cluster to demonstrate deploy automation
    run:
      location: projects/PROJECT_ID/locations/us-central1
    ---
    
    apiVersion: deploy.cloud.google.com/v1
    kind: Target
    metadata:
      name: automation-quickstart-staging
    description: Staging cluster to demonstrate deploy automation
    run:
      location: projects/PROJECT_ID/locations/us-central1
    ---
    
    apiVersion: deploy.cloud.google.com/v1
    kind: Automation
    metadata:
      name: my-automation-demo-app-1/promote
    description: Promotes a release to the next target
    suspended: false
    serviceAccount: PROJECT_NUMBER-compute@developer.gserviceaccount.com
    selector:
      targets:
      - id: automation-quickstart-dev
    rules:
    - promoteReleaseRule:
        name: "promote-release"
        wait: 1m
        toTargetId: "@next"
    ---
    
    apiVersion: deploy.cloud.google.com/v1
    kind: Automation
    metadata:
      name: my-automation-demo-app-1/advance
    description: advances a rollout
    suspended: false
    serviceAccount: PROJECT_NUMBER-compute@developer.gserviceaccount.com
    selector:
      targets:
      - id: automation-quickstart-staging
    rules:
    - advanceRolloutRule:
        name: "advance-rollout"
        sourcePhases: ["canary-25"]
        wait: 1m
    
  2. Registrieren Sie Ihre Pipeline und Ziele beim Cloud Deploy-Dienst:

    gcloud deploy apply --file=clouddeploy.yaml --region=us-central1 --project=PROJECT_ID
    

    Sie haben jetzt eine Pipeline mit einem Multi-Target, das zwei GKE- oder Cloud Run-Ziele umfasst, und können Ihre Anwendung bereitstellen.

  3. Bestätigen Sie Pipeline und Ziele:

    Rufen Sie in der Google Cloud -Konsole die Seite Bereitstellungspipelines von Cloud Deploy auf, um eine Liste der verfügbaren Bereitstellungspipelines aufzurufen.

    Zur Seite der Lieferpipelines

    Die soeben erstellte Bereitstellungspipeline wird angezeigt und die beiden Ziele werden in der Spalte Ziele aufgeführt.

    Visualisierung der Lieferpipeline in der Google Cloud Console

  4. Klicken Sie auf den Namen der Pipeline, um die Visualisierung und die Details der Lieferpipeline zu öffnen.

  5. Wählen Sie unter Details zur Bereitstellungspipeline den Tab Automatisierungen aus.

    Die beiden von Ihnen erstellten Automatisierungen werden angezeigt.

    Visualisierung der Lieferpipeline in der Google Cloud Console

Release erstellen

Ein Release ist die zentrale Cloud Deploy-Ressource, die die bereitzustellenden Änderungen darstellt. Die Lieferpipeline definiert den Lebenszyklus dieses Releases. Weitere Informationen zu diesem Lebenszyklus finden Sie unter Cloud Deploy-Dienstarchitektur.

GKE

Führen Sie den folgenden Befehl im Verzeichnis deploy-automation-gke-quickstart aus, um eine release-Ressource zu erstellen, die das bereitzustellende Container-Image darstellt:

 gcloud deploy releases create test-release-001 \
   --project=PROJECT_ID \
   --region=us-central1 \
   --delivery-pipeline=my-automation-demo-app-1 \
   --images=my-app-image=gcr.io/google-containers/nginx@sha256:f49a843c290594dcf4d193535d1f4ba8af7d56cea2cf79d1e9554f077f1e7aaa

Beachten Sie das --images=-Flag, mit dem Sie den Platzhalter (my-app-image) im Manifest durch das spezifische, SHA-qualifizierte Bild ersetzen. Google empfiehlt, Ihre Manifeste auf diese Weise zu templatieren und bei der Erstellung von Releases SHA-qualifizierte Image-Namen zu verwenden.

Cloud Run

Führen Sie den folgenden Befehl im Verzeichnis deploy-automation-run-quickstart aus, um eine release-Ressource zu erstellen, die das bereitzustellende Container-Image darstellt:

 gcloud deploy releases create test-release-001 \
   --project=PROJECT_ID \
   --region=us-central1 \
   --delivery-pipeline=my-automation-demo-app-1 \
   --images=my-app-image=us-docker.pkg.dev/cloudrun/container/hello@sha256:95ade4b17adcd07623b0a0c68359e344fe54e65d0cb01b989e24c39f2fcd296a

Beachten Sie das --images=-Flag, mit dem Sie den Platzhalter (my-app-image) in der Dienstdefinition durch das spezifische, SHA-qualifizierte Image ersetzen. Google empfiehlt, Ihre Dienst- und Jobdefinitionen auf diese Weise zu templatieren und bei der Erstellung von Releases SHA-qualifizierte Imagenamen zu verwenden.

Wenn Sie einen Release erstellen, wird standardmäßig automatisch ein Rollout für das erste Ziel in Ihrer Pipeline erstellt.

Da diese Kurzanleitung zwei Automatisierungen umfasst, passieren zwei Dinge automatisch:

  • Nach einer erfolgreichen Bereitstellung im ersten Ziel wird der Release automatisch auf das zweite Ziel hochgestuft.

    Bei der Automatisierung zum Bewerben gibt es eine Wartezeit von einer Minute.

  • Beim zweiten Ziel, für das ein Canary-Prozentsatz von 25% konfiguriert ist, wird der Roll-out durch die zweite Automatisierung von canary-25 auf stable erhöht.

    Bei diesem ersten Release wird die canary-25-Phase übersprungen, da es keine vorhandene Version der App gibt, die als Canary-Version verwendet werden kann. Das Roll-out wird automatisch auf stable fortgesetzt.

    Die erweiterte Automatisierung wird mit einer Verzögerung von einer Minute ausgeführt.

Wenn alles abgeschlossen ist, wird die Anwendung erfolgreich auf beiden Zielen bereitgestellt, ohne dass Sie etwas weiter tun müssen.

Wenn Sie mehr über die Ausführung einer Canary-Bereitstellungsstrategie erfahren möchten, können Sie die Canary-Kurzanleitung ausprobieren.

Ergebnisse in der Google Cloud -Console ansehen

Die Ergebnisse, einschließlich der automatisierten Ausführungen, können Sie in derGoogle Cloud -Konsole ansehen.

  1. Rufen Sie die Cloud Deploy-Seite Bereitstellungspipelines auf, um Ihre Bereitstellungspipeline anzusehen.

    Zur Seite der Lieferpipelines

  2. Klicken Sie auf den Namen der Lieferpipeline „my-automation-demo-app-1“.

    Die Pipeline-Visualisierung zeigt den Bereitstellungsstatus der App. Wenn genügend Zeit vergangen ist, werden beide Ziele grün angezeigt.

    Visualisierung der Lieferpipeline in der Google Cloud Console

    Ihre Version wird auf dem Tab Releases unter Details zur Lieferpipeline aufgeführt.

  3. Klicken Sie auf den Tab Automatisierungsläufe.

    Es gibt zwei Einträge, einen für jede der beiden erstellten Automatisierungen. Sie können auf eine der beiden klicken, um die Details der Automatisierungsausführung aufzurufen.

    Details zur Automatisierungsausführung in der Google Cloud Console

Bereinigen

Mit den folgenden Schritten vermeiden Sie, dass Ihrem Google Cloud -Konto die auf dieser Seite verwendeten Ressourcen in Rechnung gestellt werden:

  1. Löschen Sie die GKE-Cluster oder Cloud Run-Dienste:

    GKE

    gcloud container clusters delete automation-quickstart-cluster-dev --region=us-central1 --project=PROJECT_ID \
    && gcloud container clusters delete automation-quickstart-cluster-staging --region=us-west1 --project=PROJECT_ID
    

    Cloud Run

    gcloud run services delete my-automation-run-service-dev --region=us-central1 --project=PROJECT_ID \
    && gcloud run services delete my-automation-run-service-staging --region=us-central1 --project=PROJECT_ID
    
  2. Löschen Sie die Bereitstellungspipeline, die Ziele, die Automatisierungen, das Release und die Roll-outs:

    gcloud deploy delete --file=clouddeploy.yaml --force --region=us-central1 --project=PROJECT_ID
    
  3. Löschen Sie die Cloud Storage-Buckets, die von Cloud Deploy erstellt wurden.

    Eine endet mit _clouddeploy und die andere ist [region].deploy-artifacts.[project].appspot.com.

    Die Cloud Storage-Browserseite öffnen

Das war alles. Sie haben diesen Schnellstart abgeschlossen!

Nächste Schritte