Anwendung für ein Ziel Canary bereitstellen

Anwendung für ein Ziel Canary 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. In dieser Kurzanleitung werden jedoch 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 basierend auf den Prozentsätzen auf, die Sie in der Bereitstellungspipeline konfigurieren. GKE stellt die neue Version für einen Teil der Pods bereit. In dieser Kurzanleitung 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 ein Canary-Deployment in GKE Enterprise-Clustern ausfü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 Ihre Cloud Deploy-Bereitstellungspipeline und das Bereitstellungsziel.

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

   Mit diesem 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 für 50 % bereitzustellen.

7. Release zu 100 % hochstufen.

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.

   Hinweis: Wenn Sie die Ressourcen, die Sie in diesem Verfahren erstellen, nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes Projekt auszuwählen. Wenn Sie fertig sind, können Sie das Projekt löschen und dadurch alle mit dem Projekt verknüpften Ressourcen entfernen.

   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

   Hinweis: Sie können die gcloud CLI in der Google Cloud Console ausführen, ohne die Google Cloud CLI zu installieren. Verwenden Sie Cloud Shell, um die gcloud CLI in der Google Cloud Console auszuführen.

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

   Hinweis: Wenn Sie die Ressourcen, die Sie in diesem Verfahren erstellen, nicht behalten möchten, erstellen Sie ein Projekt, anstatt ein vorhandenes Projekt auszuwählen. Wenn Sie fertig sind, können Sie das Projekt löschen und dadurch alle mit dem Projekt verknüpften Ressourcen entfernen.

   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

    Hinweis: Sie können die gcloud CLI in der Google Cloud Console ausführen, ohne die Google Cloud CLI zu installieren. Verwenden Sie Cloud Shell, um die gcloud CLI in der Google Cloud Console auszuführen.

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, 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)")[e-mail] \
           --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)")[e-mail] \
          --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)")[e-mail] \
          --role="roles/run.developer"
      

    3. Fügen Sie 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)")[e-mail] \
           --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
           --format="value(projectNumber)")[e-mail] \
           --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, falls 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 die Details für die Bereitstellung und die korrekte Bereitstellung für Ihr Ziel bereitzustellen.

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

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/v3alpha1
   kind: Config
   manifests:
     rawYaml:
     - kubernetes.yaml
   deploy:
     kubectl: {}
   

   GKE + Gateway API

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

   Cloud Run

   apiVersion: skaffold/v3alpha1
   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 von Cloud Deploy erstellte App für Sie erstellen lassen, um einfache Anwendungen zu erstellen, die nicht Teil der Produktion sind.

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

4. Erstellen Sie Ihr 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 einfaches Kubernetes-Manifest, das zum Bereitstellen der Anwendung auf den Cluster angewendet 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 zum Bereitstellen der Anwendung auf den Cluster angewendet wird. Dieses Manifest enthält die Dienst- und Bereitstellungsressourcen, die für das Canary-Deployment erforderlich sind, sowie eine HTTP-Route und die Gateway-Ressource, die für die Verwendung der Gateway API benötigt werden.

   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 Cloud Run-Dienstkonfigurationsdatei, die bei der Bereitstellung angewendet wird, um Ihren Dienst in Cloud Run zu erstellen.

Hinweis: Wenn Sie für jedes Ziel verschiedene Manifeste verwenden möchten, lesen Sie diesen Artikel zum Verwalten von Manifesten. Dort finden Sie weitere Informationen zur Verwendung von Skaffold-Profilen.

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 beim Cloud Deploy-Dienst:

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

   Sie haben jetzt eine Pipeline mit einem Multi-Ziel, das zwei GKE-Ziele umfasst, und ist bereit, Ihre Anwendung bereitzustellen.

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.

   

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 aus dem 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=gcr.io/cloudrun/hello@sha256:98cdb98c2d97a67d5e9183beedfec98ca9d5967acd874409b4800bf4d1a51710

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

Wir gehen zur stabilen Phase über,

Mit diesem ersten Release überspringen wir die Canary-Phase und stellen das Deployment zu 100% (stabile Phase) bereit. Dies 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 die Canary-Phase übersprungen wurde, können wir mit der stabilen Phase beginnen, in der der Traffic zu 100 % geleitet wird. Danach erstellen wir einen weiteren Release, der den Canary-Release ausführt.

In der Praxis führen Sie normalerweise eine Canary-Bereitstellung aus, in der Ihre Anwendung bereits ausgeführt wird. Daher wird diese Phase nur selten übersprungen.

Release in der Google Cloud Console ansehen

Nachdem Sie nun den ersten Release erstellt haben, wird der Roll-out erstellt. Sie können sich den Release und den Roll-out in der Google Cloud Console ansehen. Sie können auch die Pipeline-Visualisierung aufrufen, 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 nur eine Phase in der Pipeline gibt, zeigt die Visualisierung nur einen Knoten.

   

   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, einschließlich des Bereitstellungslogs, anzusehen.

   

   Beachten Sie, dass der Roll-out-Status „Ausstehend“ lautet und das in der Pipelinevisualisierung angezeigte Ziel einen Link zu „Zu stabilen wechseln“ hat.

Einführungsphase fortsetzen

Nach dem ersten Release wurde die Canary-Phase übersprungen und das Roll-out wartet auf den Start der "stabilen" Phase, in der die Anwendung zu 100 % bereitgestellt wird:

1. Klicken Sie in der Pipeline-Visualisierung auf Zu stabilen wechseln.

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

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

Canary-Deployment ausführen

Da beim ersten Release die Canary-Phase übersprungen wurde, wird jetzt ein weiterer Release erstellt. Diesmal wird ein Canary-Deployment ausgefü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=gcr.io/cloudrun/hello@sha256:98cdb98c2d97a67d5e9183beedfec98ca9d5967acd874409b4800bf4d1a51710
   

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

   

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

   

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

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

   Dadurch wird die Einführung in die "stabile" Phase fortgesetzt und die Anwendung wird 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.

   Das eine endet mit _clouddeploy, das andere auf [region].deploy-artifacts.[project].appspot.com.

   Die Cloud Storage-Browserseite öffnen

Das war alles. Sie haben diesen Schnellstart abgeschlossen!

Nächste Schritte

• Weitere Informationen zu Cloud Deploy

• Machen Sie sich mit den Grundlagen der Anwendungsbereitstellung vertraut.

• Schritt-für-Schritt-Anleitung für Cloud Deploy ausprobieren

• Erfahren Sie, wie Sie Manifeste verwalten.

• Hier erfahren Sie, wie Sie Google Cloud-CI/CD-Tools kombinieren, um Software effektiv zu entwickeln und in GKE bereitzustellen.