Diese Seite wurde von der Cloud Translation API übersetzt.

Canary-Bereitstellung einer Anwendung auf einem Ziel

In dieser Kurzanleitung erfahren Sie, wie Sie mit Cloud Deploy eine Beispielanwendung bereitstellen in einem Canary-Deployment entweder in der Google Kubernetes Engine oder in Cloud Run. (Sie können auch ein Canary-Deployment in GKE Enterprise ausführen, aber nur GKE und Cloud Run werden hier gezeigt. quickstart.)

Bei einem Canary-Deployment wird der Traffic zwischen einer bereits bereitgestellten Version des und die neue Version. Cloud Run-Kontingenttraffic basierend auf den Prozentsätzen, die Sie in der Bereitstellungspipeline konfigurieren. GKE stellt die neue Version für einen Teil von Pods bereit. Dieses wird der Schnellstart zu 50 % bereitgestellt.

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

Dieser Schnellstart erläutert folgende Schritte:

GKE-Cluster erstellen oder Cloud Run definieren Service.

Sie können auch ein Canary-Deployment in GKE Enterprise-Clustern durchführen. verwendet nur GKE und Cloud Run.
Erstellen Sie eine Skaffold-Konfiguration und ein Kubernetes-Manifest, Geben Sie das (vordefinierte) Container-Image an, das bereitgestellt werden soll.
Cloud Deploy-Bereitstellungspipeline und -Deployment definieren target angeben.
Rufen Sie Ihre Bereitstellungspipeline auf, indem Sie einen Release erstellen, der automatisch die für ein Ziel bereitgestellt werden.

In diesem ersten Release wird die Canary-Phase übersprungen.
Rufen Sie die Lieferpipeline und den Release in der Google Cloud Console auf.
Erstellen Sie einen zweiten Release. Führen Sie diesmal die Canary-Phase aus, um den auf 50 % reduzieren.
Stellen Sie den Release vor, um die Bereitstellung zu 100 % zu ermöglichen.

Hinweise

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.

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

Go to project selector

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

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

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

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

Go to project selector

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

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

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Wenn Sie die Befehlszeile bereits installiert haben, achten Sie darauf, dass Sie die neueste Version:

gcloud components update

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 den Standarddienst deaktiviert sind Konten.

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"

Fügen Sie die Entwicklerrolle für die jeweilige 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"

Fügen Sie die Rolle iam.serviceAccountUser hinzu, die enthält die Berechtigung actAs zur Bereitstellung in der Laufzeit:

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

GKE-Autopilot erstellen Cluster:

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

GKE + Gateway API

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

Rufen Sie die Clusteranmeldedaten ab:

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

Installieren Sie die Kubernetes Gateway API-CRDs, falls diese nicht bereits im Cluster.

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

Aktivieren Sie die Implementierung des Gateway-Controllers 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 brauchen hier nichts zu tun.

Skaffold-Konfiguration und Anwendungsmanifest vorbereiten

Cloud Deploy nutzt Skaffold, um was genau bereitgestellt wird und wie Sie es ordnungsgemäß auf Ihrem target angeben.

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

Öffnen Sie ein Terminalfenster.

Erstellen Sie ein neues Verzeichnis und wechseln Sie zu diesem Verzeichnis.

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

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. In diesem Fall erstellen Sie die Datei. Sie können aber auch eine von Cloud Deploy erstellen lassen, für einfache Nicht-Produktionsumgebungen.

Siehe Referenz zu skaffold.yaml finden Sie weitere Informationen zu dieser Datei.

Erstellen Sie Ihr Anwendungsmanifest.

GKE

Erstellen Sie im deploy-canary-quickstart-gke eine Datei mit dem Namen kubernetes.yaml. mit 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 namens kubernetes.yaml mit 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 die Canary-Bereitstellung 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 namens run.yaml mit folgendem Inhalt:

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

Diese Datei ist eine Cloud Run-Dienstkonfigurationsdatei, der bei der Bereitstellung angewendet wird, um Ihren Dienst in Cloud Run

Lieferpipeline und Ziele erstellen

Sie können die Lieferpipeline und die Ziele in einer Datei oder in separaten Dateien definieren. In diesem Schnellstart erstellen wir eine Datei für unsere Pipeline und unsere einzelne Ziel:

GKE

Erstellen Sie im Verzeichnis deploy-canary-quickstart-gke eine Datei namens clouddeploy.yaml mit 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 namens clouddeploy.yaml mit 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 namens clouddeploy.yaml mit 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

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 Ziel, das für eine Canary-Bereitstellungsstrategie konfiguriert ist.
Bestätigen Sie Pipeline und Ziele:

Rufen Sie in der Google Cloud Console Cloud Deploy auf. Seite Bereitstellungspipelines zur Liste der verfügbaren Bereitstellungspipelines Pipelines.

Zur Seite der Lieferpipelines

Es wird die Bereitstellungspipeline angezeigt, die Sie gerade erstellt haben, wird in der Spalte Ziele aufgeführt.

Release erstellen

Ein Release ist die zentrale Cloud Deploy-Ressource, die den Änderungen bereitgestellt werden. Die Bereitstellungspipeline definiert den Lebenszyklus Veröffentlichung. Weitere Informationen finden Sie unter Cloud Deploy-Dienstarchitektur finden Sie weitere Informationen zu diesem Lebenszyklus.

Führen Sie 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:4a856b6f1c3ce723a456ddc2adfbb794cbfba93f727e2d96fcf6540bd0d6fff4

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

Wir springen zur stabilen Phase

Bei diesem ersten Release überspringen wir die Canary-Phase und führen ein Deployment zu 100 % (stabile Phase) durch. Das liegt daran, dass die Anwendung noch nicht bereitgestellt wurde. Daher können 50 % der Pods (für GKE) oder die Aufteilung des Traffics für den Dienst (für Cloud Run) nicht berechnet werden. Die Pods (GKE) oder Revisionen (Cloud Run) existieren noch nicht.

Nachdem wir die Canary-Phase übersprungen haben, können wir mit der stabilen Phase beginnen. wodurch der Traffic auf 100 % geleitet wird. Danach erstellen wir einen weiteren Release, führt das Canary-Objekt aus.

In einer realen Situation führen Sie normalerweise eine Canary-Deployment, bei der Ihre Anwendung bereits ausgeführt wird, ist es eher selten.

Release in der Google Cloud Console ansehen

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

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

Zur Seite der Lieferpipelines
Klicken Sie auf den Namen Ihrer Bereitstellungspipeline „my-Canary-demo-app-1“.

Die Pipelinevisualisierung zeigt den Bereitstellungsstatus der App. Weil es nur eine Phase in der Pipeline hat, wird in der Visualisierung nur ein Knoten angezeigt.

Ihre Version wird auf dem Tab Releases unter Details zur Lieferpipeline aufgeführt.
Klicken Sie auf den Releasenamen, test-release-001.

Ihre Roll-outs werden unter Roll-outs angezeigt. Sie können auf ein Roll-out klicken, Details, einschließlich des Bereitstellungsprotokolls.

Beachten Sie, dass der Roll-out-Status „Weiter ausstehend“ lautet. und das Ziel in enthält die Pipeline-Visualisierung den Link „Weiter zu Stabil“.

Roll-out-Phase fortsetzen

Nach dem ersten Release wurde die Canary-Phase übersprungen und das Roll-out wird Warten auf den Start von „stable“ Phase, in der die Anwendung zu 100 % bereitgestellt wird:

Klicken Sie in der Pipeline-Visualisierung auf Weiter zur stabilen Version.
Wenn Sie dazu aufgefordert werden, klicken Sie zur Bestätigung auf Advance.

Nach wenigen Minuten ist das Roll-out jetzt in der „stable“ Version und die Anwendung zu 100 % bereitgestellt wird.

Bereitstellungspipeline in der stabilen Phase

Canary-Deployment ausführen

Da bei der ersten Version die Canary-Phase übersprungen wurde, erstellen wir jetzt eine weitere Version, bei der diesmal ein Canary-Deployment ausgeführt wird.

Führen Sie zum Erstellen eines neuen release den folgenden Befehl über die deploy-canary-quickstart-gke, deploy-canary-quickstart-gke-gatewayapi oder Verzeichnis deploy-canary-quickstart-run:

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:4a856b6f1c3ce723a456ddc2adfbb794cbfba93f727e2d96fcf6540bd0d6fff4

Nach einigen Minuten wird ein Rollout erstellt und diesmal die Canary-Phase. Ausgeführt:

Bereitstellungspipeline startet Canary-Phase

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 mit Bereitstellung der Anwendung zu 50%

Das bedeutet, dass die Anwendung jetzt zu 50 % bereitgestellt ist. Für serviceNetworking-basierten GKE, wird er auf der Hälfte Pods. Für die Gateway API-basierte GKE und Cloud Run-Traffic wird zu 50 % zugewiesen.

Klicken Sie auf Erweitertes Roll-out und dann auf Erweitert, wenn Sie dazu aufgefordert werden.

Dadurch wird das Roll-out zum „stable“ die Bereitstellung der Anwendung 100%.

Bereinigen

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

canary-quickstart-cluster-Cluster löschen (nur GKE):

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

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

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

Löschen Sie die von Cloud Deploy erstellten Cloud Storage-Buckets.

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

Die Cloud Storage-Browserseite öffnen

Das war alles. Sie haben diesen Schnellstart abgeschlossen!

Canary-Bereitstellung einer Anwendung auf einem Ziel

Hinweise

Laufzeitumgebung erstellen

GKE

GKE + Gateway API

Cloud Run

Skaffold-Konfiguration und Anwendungsmanifest vorbereiten

GKE

GKE + Gateway API

Cloud Run

GKE

GKE + Gateway API

Cloud Run

GKE

GKE + Gateway API

Cloud Run

Lieferpipeline und Ziele erstellen

GKE

GKE + Gateway API

Cloud Run

Release erstellen

GKE

GKE + Gateway API

Cloud Run

Wir springen zur stabilen Phase

Release in der Google Cloud Console ansehen

Roll-out-Phase fortsetzen

Canary-Deployment ausführen

GKE

GKE + Gateway API

Cloud Run

Bereinigen

Nächste Schritte