Anwendung per Canary für ein Ziel bereitstellen

In dieser Kurzanleitung erfahren Sie, wie Sie mit Cloud Deploy ein Beispielanwendungs-Image in einem Canary-Deployment an Google Kubernetes Engine oder Cloud Run senden. Sie können auch ein Canary-Deployment in GKE Enterprise ausführen, aber in dieser Kurzanleitung werden nur GKE und Cloud Run gezeigt.

Bei einem Canary-Deployment wird der Traffic zwischen einer bereits bereitgestellten Version der Anwendung und der neuen Version aufgeteilt. Cloud Run teilt den Traffic anhand der Prozentsätze auf, die Sie in der Bereitstellungspipeline konfigurieren. GKE stellt die neue Version für einen Teil der Pods bereit. In diesem Schnellstart wird zuerst zu 50% und dann zu 100 % bereitgestellt.

In dieser Kurzanleitung gibt es nur ein Ziel (prod). Daher erstellen wir nur einen GKE-Cluster oder einen Cloud Run-Dienst zum Ausführen Ihrer Anwendung.

Dieser Schnellstart erläutert folgende Schritte:

  1. Erstellen Sie einen GKE-Cluster oder definieren Sie einen Cloud Run-Dienst.

    Sie können auch Canary-Deployments in GKE Enterprise-Clustern durchführen. In dieser Kurzanleitung werden jedoch nur GKE und Cloud Run verwendet.

  2. Erstellen Sie eine Skaffold-Konfiguration und ein Kubernetes-Manifest, um das bereitzustellende (vordefinierte) Container-Image anzugeben.

  3. Definieren Sie die Bereitstellungspipeline und das Bereitstellungsziel von Cloud Deploy.

  4. Rufen Sie die Bereitstellungspipeline auf, indem Sie einen Release erstellen, der automatisch auf einem Ziel bereitgestellt wird.

    Im ersten Release wird die Canary-Phase übersprungen.

  5. Sehen Sie sich die Bereitstellungspipeline und den Release in der Google Cloud Console an.

  6. Erstellen Sie einen zweiten Release und führen Sie diesmal die Canary-Phase aus, um die Anwendung zu 50 % bereitzustellen.

  7. Stufen Sie den Release für die Bereitstellung zu 100 % hoch.

Hinweise

  1. Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

  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 Google Cloud-Projekt muss aktiviert sein.

  4. Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage APIs aktivieren.

    Aktivieren Sie die APIs

  5. Installieren Sie die Google Cloud CLI.

  6. Führen Sie folgenden Befehl aus, um die gcloud CLI zu initialisieren: 

    gcloud init
    7.

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

    Zur Projektauswahl

  8. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

  9. Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage APIs aktivieren.

    Aktivieren Sie die APIs

  10. Installieren Sie die Google Cloud CLI.

  11. Führen Sie folgenden Befehl aus, um die gcloud CLI zu initialisieren: 

    gcloud init
    12.

    Wenn Sie die Befehlszeile bereits installiert haben, prüfen Sie, ob es sich um die neueste Version handelt: 

    gcloud components update

  12. Prüfen Sie, ob das Compute Engine-Standarddienstkonto die erforderlichen Berechtigungen hat.

    Das Dienstkonto hat möglicherweise bereits die erforderlichen Berechtigungen. Diese Schritte sind für Projekte enthalten, bei denen automatische Rollenzuweisungen für Standarddienstkonten deaktiviert werden.

    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. Fügen Sie die Entwicklerrolle für Ihre spezifische Laufzeit hinzu.
      • Für GKE und GKE mit Gateway API: 

        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"

    3. Fügen Sie die Rolle iam.serviceAccountUser hinzu, die die Berechtigung actAs zum Bereitstellen 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

Laufzeitumgebung erstellen

GKE

Erstellen Sie einen GKE Autopilot-Cluster:

 gcloud container clusters create-auto canary-quickstart-cluster \
                  --project=PROJECT_ID \
                  --region=us-central1

GKE + Gateway API

  1. Erstellen Sie einen GKE-Cluster mit den empfohlenen Einstellungen für die Verwendung mit Istio:

    gcloud container clusters create canary-quickstart-cluster \
       --machine-type=n1-standard-1 \
       --num-nodes 4 \
       --region=us-central1 \
       --project=PROJECT_ID

  2. Rufen Sie die Clusteranmeldedaten ab:

    gcloud container clusters get-credentials canary-quickstart-cluster \
       --project=PROJECT_ID \
       --region=us-central1

  3. Installieren Sie die CRDs der Kubernetes Gateway API, wenn sie noch nicht im Cluster vorhanden sind.

    kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v0.6.2/standard-install.yaml

  4. Aktivieren Sie die Gateway-Controller-Implementierung von Istio, indem Sie Istio installieren.

    curl -L https://istio.io/downloadIstio | ISTIO_VERSION=1.17.2 sh - \
&& ./istio-1.17.2/bin/istioctl install --set profile=minimal -y

Cloud Run

Wenn Sie Cloud Run verwenden, können Sie diesen Befehl überspringen. Sie müssen hier nichts tun.

Skaffold-Konfiguration und Anwendungsmanifest vorbereiten

Cloud Deploy verwendet Skaffold, um Details für die Bereitstellung und die ordnungsgemäße Bereitstellung für Ihr Ziel bereitzustellen.

In dieser Kurzanleitung erstellen Sie eine skaffold.yaml-Datei, die das Kubernetes-Manifest oder die Cloud Run-Dienstkonfiguration angibt, die bereitgestellt werden sollen.

  1. Öffnen Sie ein Terminalfenster.

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

    GKE 

    mkdir deploy-canary-quickstart-gke
cd deploy-canary-quickstart-gke

    GKE + Gateway API 

    mkdir deploy-canary-quickstart-gke-gatewayapi
cd deploy-canary-quickstart-gke-gatewayapi

    Cloud Run 

    mkdir deploy-canary-quickstart-run
cd deploy-canary-quickstart-run

  3. Erstellen Sie eine Datei mit dem Namen skaffold.yaml und mit folgendem Inhalt:

    GKE 

    apiVersion: skaffold/v4beta7
kind: Config
manifests:
  rawYaml:
  - kubernetes.yaml
deploy:
  kubectl: {}

    GKE + Gateway API 

    apiVersion: skaffold/v4beta7
kind: Config
manifests:
  rawYaml:
  - kubernetes.yaml
deploy:
  kubectl: {}

    Cloud Run 

    apiVersion: skaffold/v4beta7
kind: Config
manifests:
  rawYaml:
  - run.yaml
deploy:
  cloudrun: {}

    Diese Datei ist eine minimale Skaffold-Konfiguration, die Ihr Manifest identifiziert. Für diese Kurzanleitung erstellen Sie die Datei. Sie können aber auch eine Liste von Cloud Deploy für einfache Anwendungen erstellen lassen, die nicht in der Produktion verwendet werden.

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

  4. App-Manifest erstellen

    GKE

    Erstellen Sie im Verzeichnis deploy-canary-quickstart-gke eine Datei mit dem Namen kubernetes.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 auf den Cluster angewendet wird, um die Anwendung bereitzustellen.

    GKE + Gateway API

    Erstellen Sie im Verzeichnis deploy-canary-quickstart-gke-gatewayapi eine Datei mit dem Namen kubernetes.yaml und folgendem Inhalt:

    kind: Gateway
apiVersion: gateway.networking.k8s.io/v1beta1
metadata:
  name: my-gateway
  annotations:
    networking.istio.io/service-type: "ClusterIP"
spec:
  gatewayClassName: istio
  listeners:
  - name: default
    hostname: "*.example.com"
    port: 80
    protocol: HTTP
    allowedRoutes:
      namespaces:
        from: All
---
kind: HTTPRoute
apiVersion: gateway.networking.k8s.io/v1beta1
metadata:
  name: my-httproute
spec:
  parentRefs:
  - kind: Gateway
    name: my-gateway
  hostnames:
  - "test.example.com"
  rules:
  - backendRefs:
    - name: my-service
      port: 80
---
apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: my-app
  ports:
  - name: tcp-port
    protocol: TCP
    port: 80
    targetPort: 8080
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
  labels:
    app: my-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: nginx
        image: my-app-image

    Diese Datei ist ein Kubernetes-Manifest, das auf den Cluster angewendet wird, um die Anwendung bereitzustellen. Dieses Manifest enthält die für das Canary-Deployment erforderlichen Dienst- und Bereitstellungsressourcen sowie eine HTTPRoute- und die Gateway-Ressource, die für die Verwendung der Gateway API erforderlich sind.

    Cloud Run

    Erstellen Sie im Verzeichnis deploy-canary-quickstart-run eine Datei mit dem Namen run.yaml und folgendem Inhalt:

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

    Dies ist eine Cloud Run-Dienstkonfigurationsdatei, die zum Zeitpunkt der Bereitstellung angewendet wird, um Ihren Dienst in Cloud Run zu erstellen.

Lieferpipeline und Ziele erstellen

Sie können Ihre Bereitstellungspipeline und Ziele in einer Datei oder in separaten Dateien definieren. In dieser Kurzanleitung erstellen wir eine Datei für unsere Pipeline und unser einzelnes Ziel:

GKE

Erstellen Sie im Verzeichnis deploy-canary-quickstart-gke eine Datei mit dem Namen clouddeploy.yaml und folgendem Inhalt:

apiVersion: deploy.cloud.google.com/v1
kind: DeliveryPipeline
metadata:
  name: my-canary-demo-app-1
description: main application pipeline
serialPipeline:
  stages:
  - targetId: prod
    profiles: []
    strategy:
      canary:
        runtimeConfig:
          kubernetes:
            serviceNetworking:
              service: "my-service"
              deployment: "my-deployment"
        canaryDeployment:
          percentages: [50]
          verify: false
---
apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
  name: prod
description: prod GKE cluster
gke:
 cluster: projects/PROJECT_ID/locations/us-central1/clusters/canary-quickstart-cluster

GKE + Gateway API

Erstellen Sie im Verzeichnis deploy-canary-quickstart-gke-gatewayapi eine Datei mit dem Namen clouddeploy.yaml und folgendem Inhalt:

apiVersion: deploy.cloud.google.com/v1
kind: DeliveryPipeline
metadata:
  name: my-canary-demo-app-1
description: main application pipeline
serialPipeline:
  stages:
  - targetId: prod
    profiles: []
    strategy:
      canary:
        runtimeConfig:
          kubernetes:
            gatewayServiceMesh:
              httpRoute: "my-httproute"
              service: "my-service"
              deployment: "my-deployment"
        canaryDeployment:
          percentages: [50]
          verify: false
---
apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
  name: prod
description: prod GKE cluster
gke:
 cluster: projects/PROJECT_ID/locations/us-central1/clusters/canary-quickstart-cluster

Cloud Run

Erstellen Sie im Verzeichnis deploy-canary-quickstart-run eine Datei mit dem Namen clouddeploy.yaml und folgendem Inhalt:

apiVersion: deploy.cloud.google.com/v1
kind: DeliveryPipeline
metadata:
  name: my-canary-demo-app-1
description: main application pipeline
serialPipeline:
  stages:
  - targetId: prod
    profiles: []
    strategy:
      canary:
        runtimeConfig:
          cloudRun:
            automaticTrafficControl: true
        canaryDeployment:
          percentages: [50]
          verify: false
---
apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
  name: prod
description: prod Run Service
run:
  location: projects/PROJECT_ID/locations/us-central1

  1. Registrieren Sie Ihre Pipeline und Ziele mit dem Cloud Deploy-Dienst:

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

    Sie haben jetzt eine Pipeline mit einem Ziel, das für eine Canary-Bereitstellungsstrategie konfiguriert ist.

  2. Bestätigen Sie Pipeline und Ziele:

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

    Zur Seite der Lieferpipelines

    Die soeben erstellte Bereitstellungspipeline wird angezeigt und das von Ihnen konfigurierte Ziel wird in der Spalte Ziele aufgeführt.

    Visualisierung der Bereitstellungspipeline in der Google Cloud Console

Release erstellen

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

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

GKE 

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

GKE + Gateway API 

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

Cloud Run 

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

Wenn Sie einen Release erstellen, erstellt Cloud Deploy automatisch auch eine Rollout-Ressource, um sie sofort auf Ihrem Ziel prod bereitzustellen.

Wir gehen zur stabilen Phase über,

Mit diesem ersten Release überspringen wir die Canary-Phase und stellen die Bereitstellung zu 100% (stabile Phase) bereit. Das liegt daran, dass die Anwendung zuvor noch nicht bereitgestellt wurde. Daher ist es nicht möglich, 50% der Pods (für GKE) oder die Aufteilung des Traffics für den Dienst (für Cloud Run) zu berechnen. Die Pods (GKE) oder Überarbeitungen (Cloud Run) sind noch nicht vorhanden.

Nachdem Sie die Canary-Phase übersprungen haben, können Sie mit der stabilen Phase beginnen, in der der Traffic zu 100 % erreicht wird. Danach erstellen wir einen weiteren Release, der den Canary-Vorgang ausführt.

In der Praxis führen Sie normalerweise ein Canary-Deployment aus, in dem Ihre Anwendung bereits ausgeführt wird. Daher wird dieses Überspringen selten vorkommen.

Release in der Google Cloud Console ansehen

Nachdem Sie nun den ersten Release erstellt haben, wird das Roll-out erstellt. Sie können sich den Release und das Roll-out in der Google Cloud Console ansehen. Sie können sich auch die Pipeline-Visualisierung ansehen, die den aktuellen Status des Release anzeigt.

  1. Rufen Sie in der Google Cloud Console die Cloud Deploy-Seite Bereitstellungspipelines auf, um Ihre my-canary-demo-app-1-Bereitstellungspipeline anzusehen.

    Zur Seite der Lieferpipelines

  2. Klicken Sie auf den Namen der Bereitstellungspipeline „my-Canary-demo-app-1“.

    Die Pipelinevisualisierung zeigt den Bereitstellungsstatus der Anwendung. Da es in der Pipeline nur eine Phase gibt, zeigt die Visualisierung nur einen Knoten.

    Visualisierung der Bereitstellungspipeline in der Google Cloud Console

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

  3. Klicken Sie auf den Releasenamen, test-release-001.

    Ihre Roll-outs werden unter Roll-outs angezeigt. Sie können auf ein Roll-out klicken, um die zugehörigen Details anzusehen, einschließlich des Bereitstellungslogs.

    Roll-outs in der Google Cloud Console

    Beachten Sie, dass der Roll-out-Status „Fortsetzung ausstehend“ lautet und das in der Pipelinevisualisierung angezeigte Ziel den Link „Weiter zu stabilen“ enthält.

Einführungsphase fortsetzen

Nach dem ersten Release wurde die Canary-Phase übersprungen und das Roll-out wartet darauf, die "stabile" Phase zu starten, in der die Anwendung zu 100 % bereitgestellt wird:

  1. Klicken Sie in der Pipelinevisualisierung auf Weiter zur stabilen Seite.

  2. Wenn Sie dazu aufgefordert werden, klicken Sie zur Bestätigung auf Fortfahren.

Nach einigen Minuten befindet sich das Roll-out in der „stabilen“ Phase und die Anwendung ist zu 100 % bereitgestellt.

Bereitstellungspipeline in der stabilen Phase

Canary-Deployment ausführen

Da beim ersten Release die Canary-Phase übersprungen wurde, wird jetzt ein weiterer Release erstellt, der diesmal ein Canary-Deployment ausführt.

  1. Führen Sie den folgenden Befehl im Verzeichnis deploy-canary-quickstart-gke, deploy-canary-quickstart-gke-gatewayapi oder deploy-canary-quickstart-run aus, um eine neue release zu erstellen:

    GKE 

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

    GKE + Gateway API 

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

    Cloud Run 

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

    Nach einigen Minuten wird ein Roll-out erstellt und diesmal die Canary-Phase ausgeführt:

    Bereitstellungspipeline, die die Canary-Phase startet

    Wenn die erste Roll-out-Phase abgeschlossen ist, befindet sich das Roll-out jetzt in der Canary-Phase:

    Visualisierung der Bereitstellungspipeline in der Google Cloud Console, wobei die Anwendung zu 50 % bereitgestellt wurde

    Das bedeutet, dass die Anwendung jetzt zu 50 % bereitgestellt ist. Bei der dienstnetzwerkbasierten GKE wird sie auf der Hälfte Ihrer Pods bereitgestellt. Beim Gateway API-basierten GKE- und Cloud Run-Traffic werden 50 % des Traffics zugewiesen.

  2. Klicken Sie auf Erweiterte Einführung und dann auf Fortsetzen, wenn Sie dazu aufgefordert werden.

    Dadurch wird das Roll-out in der „stabilen“ Phase fortgesetzt und die Anwendung wird zu 100 % bereitgestellt.

    Bereitstellungspipeline in stabiler Phase, zu 100 % bereitgestellt

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 den Cluster canary-quickstart-cluster (nur GKE):

    gcloud container clusters delete canary-quickstart-cluster --region=us-central1 --project=PROJECT_ID

  2. Löschen Sie den Dienst my-canary-run-service (nur Cloud Run):

    gcloud run services delete my-canary-run-service --region=us-central1 --project=PROJECT_ID

  3. Löschen Sie die Bereitstellungspipeline, das Ziel und alle Release- und Roll-out-Ressourcen:

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

  4. Löschen Sie die Cloud Storage-Buckets, die von Cloud Deploy erstellt wurden.

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

    Die Cloud Storage-Browserseite öffnen

Das war alles. Sie haben diesen Schnellstart abgeschlossen!

Nächste Schritte