Esegui il deployment canary di un'applicazione in un target

Prepara la configurazione di Skaffold e il manifest dell'applicazione

Cloud Deploy utilizza Skaffold per fornire i dettagli su cosa eseguire il deployment e su come eseguirlo correttamente nel target.

In questa guida rapida, crei un file skaffold.yaml che identifica il manifest Kubernetes o la configurazione del servizio Cloud Run da eseguire.

1. Apri una finestra del terminale.

2. Crea una nuova directory e accedivi.

   GKE

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

   GKE + API Gateway

   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. Crea un file denominato skaffold.yaml con i seguenti contenuti:

   GKE

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

   GKE + API Gateway

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

   Cloud Run

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

   Questo file è una configurazione Skaffold minima che identifica il manifest. Per questa guida rapida, devi creare il file. Puoi anche chiedere a Cloud Deploy di crearne uno per te per applicazioni semplici non di produzione.

   Per ulteriori informazioni su questo file, consulta le informazioni di riferimento su skaffold.yaml.

4. Crea il file manifest dell'applicazione.

   GKE

   Crea un file denominato kubernetes.yaml nella directory deploy-canary-quickstart-gke con il seguente contenuto:

   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
   

   Questo file è un manifest Kubernetes, che viene applicato al cluster per eseguire il deployment dell'applicazione. Questo manifest include le risorse Service e Deployment necessarie per il deployment canary, oltre a un percorso HTTP e la risorsa Gateway necessaria per l'utilizzo dell'API Gateway.

   L'immagine del contenitore da eseguire il deployment è impostata qui come segnaposto, my-app-image, che viene sostituita con l'immagine specifica quando crei la release.

   GKE + API Gateway

   Crea un file denominato kubernetes.yaml nella directory deploy-canary-quickstart-gke-gatewayapi con il seguente contenuto:

   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
   

   Questo file è un manifest Kubernetes, che viene applicato al cluster per eseguire il deployment dell'applicazione. Questo manifest include le risorse Service e Deployment necessarie per il deployment canary, oltre a un percorso HTTP e la risorsa Gateway necessaria per l'utilizzo dell'API Gateway.

   L'immagine del contenitore da eseguire il deployment è impostata qui come segnaposto, my-app-image, che viene sostituita con l'immagine specifica quando crei la release.

   Cloud Run

   Crea un file denominato run.yaml nella directory deploy-canary-quickstart-run con il seguente contenuto:

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

   Questo file è una definizione di servizio Cloud Run di base, che viene applicata al momento del deployment per creare il servizio in Cloud Run. L'immagine del container di cui eseguire il deployment è impostata qui come segnaposto, my-app-image, che viene sostituito con l'immagine specifica quando crei la release.

Crea la pipeline di distribuzione e i target

Puoi definire la pipeline di importazione e i target in un file o in file distinti. In questa guida rapida, creiamo un file per la pipeline e un unico target:

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. Registra la pipeline e i target con il servizio Cloud Deploy:

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

   Ora hai una pipeline con un target configurato per una strategia di deployment canary.

2. Conferma la pipeline e i target:

   Nella console Google Cloud, vai alla pagina Pipeline di distribuzione di Cloud Deploy per visualizzare l'elenco delle pipeline di distribuzione disponibili.

   Apri la pagina Pipeline di pubblicazione

   Viene visualizzata la pipeline di importazione appena creata e l'unico target configurato è elencato nella colonna Target.

   

Crea una release

Una release è la risorsa Cloud Deploy centrale che rappresenta le modifiche di cui viene eseguito il deployment. La pipeline di distribuzione definisce il ciclo di vita della release. Per informazioni dettagliate sul ciclo di vita, consulta la sezione Architettura del servizio Cloud Deploy.

Per creare una risorsa release che rappresenti l'immagine del container da eseguire, esegui il seguente comando dalla directory deploy-canary-quickstart-gke, deploy-canary-quickstart-gke-gatewayapi o deploy-canary-quickstart-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/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:4a856b6f1c3ce723a456ddc2adfbb794cbfba93f727e2d96fcf6540bd0d6fff4

Nota il flag --images=, che viene utilizzato per sostituire il segnaposto (my-app-image) nel manifest o nella definizione del servizio con l'immagine specifica con qualifica SHA. Google consiglia di creare modelli per i manifest in questo modo e di utilizzare nomi di immagini qualificati con SHA al momento della creazione della release.

Quando crei una release, Cloud Deploy crea automaticamente anche una risorsa di implementazione per eseguire immediatamente il deployment nel tuo unico target, prod.

Saltiamo alla fase stabile

Con questa prima release, saltiamo la fase Canary e eseguiamo il deployment al 100% (fase stabile). Questo perché l'applicazione non è stata dispiata in precedenza, quindi non è possibile calcolare il 50% dei pod (per GKE) o come viene suddiviso il traffico per il servizio (per Cloud Run). I pod (GKE) o le revisioni (Cloud Run) non esistono ancora.

Dopo aver saltato la fase canary, siamo pronti per iniziare la fase stabile, che prevede il 100% del traffico. Dopodiché creeremo un'altra release che eseguirà il canary.

In una situazione reale, in genere esegui un deployment canary in cui l'applicazione è già in esecuzione, pertanto il salto di questa fase sarà raro.

Visualizza la release nella console Google Cloud

Ora che hai creato la prima release, l'implementazione è stata creata e puoi visualizzarla nella console Google Cloud. Puoi anche visualizzare la visualizzazione della pipeline, che mostra lo stato attuale della release.

1. Nella console Google Cloud, vai alla pagina Pipeline di distribuzione di Cloud Deploy per visualizzare la pipeline di distribuzione my-canary-demo-app-1.

   Apri la pagina Pipeline di pubblicazione

2. Fai clic sul nome della pipeline di distribuzione "my-canary-demo-app-1".

   La visualizzazione della pipeline mostra lo stato di deployment dell'app. Poiché la pipeline contiene un solo passaggio, la visualizzazione mostra un solo nodo.

   

   La tua uscita è elencata nella scheda Uscite in Dettagli della pipeline di distribuzione.

3. Fai clic sul nome della release, test-release-001.

   Le implementazioni vengono visualizzate in Implementazioni. Puoi fare clic su un'implementazione per visualizzarne i dettagli, incluso il log di implementazione.

   

   Tieni presente che lo stato dell'implementazione è "In attesa di avanzamento" e che il target mostrato nella visualizzazione della pipeline ha un link a "Esegui l'avanzamento alla versione stabile".

Avanzare nella fase di implementazione

Dopo la prima release, la fase canary è stata saltata e l'implementazione è in attesa di avviare la fase "stabile", che esegue il deployment dell'applicazione al 100%:

1. Nella visualizzazione della pipeline, fai clic su Passa a stabile.

2. Quando richiesto, fai clic su Advance per confermare.

Dopo alcuni minuti, l'implementazione è in fase "stabile" e l'applicazione è stata implementata al 100%.

Esegui il deployment canary

Poiché la prima release ha saltato la fase canary, ora creeremo un'altra release, che questa volta eseguirà un deployment canary.

1. Per creare un nuovo release, esegui il comando seguente dalla directory deploy-canary-quickstart-gke, deploy-canary-quickstart-gke-gatewayapi o 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 + API Gateway

   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
   

   Dopo alcuni minuti viene creato un rollout e questa volta viene eseguito il livello canary:

   

   Al termine della prima fase di implementazione, l'implementazione passa alla fase canary:

   

   Ciò significa che il deployment dell'applicazione è stato completato per il 50%. Per GKE basato su serviceNetworking, viene eseguito il deployment su metà dei pod. Per GKE e Cloud Run basati sull'API Gateway, il traffico viene allocato al 50%.

2. Fai clic su Implementazione avanzata e poi su Avanti quando richiesto.

   In questo modo, l'implementazione passa alla fase "stabile" e l'applicazione viene implementata al 100%.