Canary-Deployment einer Anwendung für ein Ziel

Skaffold-Konfiguration und Anwendungsmanifest vorbereiten

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

In dieser Kurzanleitung erstellen Sie eine skaffold.yaml-Datei, die das bereitzustellende Kubernetes-Manifest oder die Cloud Run-Dienstkonfiguration identifiziert.

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. 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 das Anwendungsmanifest.

   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 Kubernetes-Manifest, das auf den Cluster angewendet wird, um die Anwendung bereitzustellen. Dieses Manifest enthält die für die Canary-Bereitstellung erforderlichen Service- und Deployment-Ressourcen sowie eine HTTPRoute- und die Gateway-Ressource, die für die Verwendung der Gateway API erforderlich sind.

   Das bereitzustellende Container-Image wird hier als Platzhalter my-app-image festgelegt, der beim Erstellen des Releases durch das spezifische Image ersetzt wird.

   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 die Canary-Bereitstellung erforderlichen Service- und Deployment-Ressourcen sowie eine HTTPRoute- und die Gateway-Ressource, die für die Verwendung der Gateway API erforderlich sind.

   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

   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
   

   Diese Datei ist eine einfache Cloud Run-Dienstdefinition, die bei der Bereitstellung angewendet wird, um Ihren Dienst in Cloud Run zu erstellen. Das bereitzustellende Container-Image wird hier als Platzhalter my-app-image festgelegt, der beim Erstellen des Releases durch das spezifische Image ersetzt wird.

Lieferpipeline und Ziele erstellen

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

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

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

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 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.

2. 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 Delivery-Pipeline wird angezeigt und das von Ihnen konfigurierte Ziel wird in der Spalte Ziele aufgeführt.

   

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.

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:

 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

 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

 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:95ade4b17adcd07623b0a0c68359e344fe54e65d0cb01b989e24c39f2fcd296a

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

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

Wir springen zur stabilen Phase.

Bei diesem ersten Release überspringen wir die Canary-Phase und stellen die Anwendung zu 100 % bereit (stabile Phase). Das liegt daran, dass die Anwendung noch nicht bereitgestellt wurde. Daher kann nicht berechnet werden, wie 50% der Pods (für GKE) oder der Traffic für den Dienst (für Cloud Run) aufgeteilt werden. Die Pods (GKE) oder Revisionen (Cloud Run) sind noch nicht vorhanden.

Da wir die Canary-Phase übersprungen haben, können wir jetzt mit der stabilen Phase beginnen, in der der Traffic auf 100 % erhöht wird. Danach erstellen wir einen weiteren Release, mit dem der Canary ausgeführt wird.

In der Praxis führen Sie in der Regel eine Canary-Bereitstellung aus, bei der Ihre Anwendung bereits ausgeführt wird. Das Überspringen dieser Phase ist daher selten.

Release in der Google Cloud -Konsole ansehen

Nachdem Sie den ersten Release erstellt haben, wird die Einführung erstellt. Sie können den Release und die Einführung in der Google Cloud -Konsole ansehen. Sie können sich auch die Pipeline-Visualisierung ansehen, in der der aktuelle Status der Veröffentlichung angezeigt wird.

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

   Zur Seite der Lieferpipelines

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

   Die Pipeline-Visualisierung zeigt den Bereitstellungsstatus der App. Da die Pipeline nur eine Phase hat, wird in der Visualisierung nur ein Knoten angezeigt.

   

   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 einen Roll-out klicken, um die Details aufzurufen, einschließlich des Bereitstellungslogs.

   

   Der Roll-out-Status ist „Pending advance“ (Ausstehendes Vorrücken) und das in der Pipeline-Visualisierung angezeigte Ziel hat einen Link zu „Advance to stable“ (Zum stabilen Status vorrücken).

Roll‑out-Phase fortsetzen

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

1. Klicken Sie in der Visualisierung der Pipeline auf Auf stabil hochstufen.

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

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

Canary-Deployment ausführen

Da beim ersten Release die Canary-Phase übersprungen wurde, erstellen wir jetzt ein weiteres Release, bei dem diesmal ein Canary-Deployment ausgeführt wird.

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 ein neues 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:95ade4b17adcd07623b0a0c68359e344fe54e65d0cb01b989e24c39f2fcd296a
   

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

   

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

   

   Das bedeutet, dass die Anwendung jetzt zu 50 % bereitgestellt ist. Bei serviceNetworking-basiertem GKE wird es in der Hälfte Ihrer Pods bereitgestellt. Für Gateway API-basierten GKE- und Cloud Run-Traffic werden 50 % zugewiesen.

2. Klicken Sie auf Advance Rollout (Rollout vorantreiben) und dann bei Aufforderung auf Advance (Vorantreiben).

   Dadurch wird das Roll-out in die Phase „Stabil“ verschoben und die Anwendung wird zu 100 % bereitgestellt.