Esegui il deployment canary di un'applicazione in una destinazione

Prepara la configurazione di Skaffold e il manifest dell'applicazione

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

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

1. Apri una finestra del terminale.

2. Crea una nuova directory e accedi.

   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 il seguente contenuto:

   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, crei il file. ma puoi anche chiedere a Cloud Deploy di crearne uno per te, per applicazioni semplici non di produzione.

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

4. Crea il 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 una risorsa HTTPRoute e Gateway necessaria per l'utilizzo dell'API Gateway.

   L'immagine container da eseguire il deployment è impostata qui come segnaposto, my-app-image, che viene sostituito 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 una risorsa HTTPRoute e Gateway necessaria per l'utilizzo dell'API Gateway.

   L'immagine container da eseguire il deployment è impostata qui come segnaposto, my-app-image, che viene sostituito 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 base del servizio Cloud Run, 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 pubblicazione e i target in un unico file o in file separati. In questa guida rapida, creiamo un file per la pipeline e un singolo 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 distribuzione

   Viene visualizzata la pipeline di distribuzione appena creata e il target che hai configurato è elencato nella colonna Target.

   

Crea una release

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

Per creare una risorsa release che rappresenti l'immagine container da eseguire il deployment, esegui il comando seguente 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:95ade4b17adcd07623b0a0c68359e344fe54e65d0cb01b989e24c39f2fcd296a

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

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

Passiamo alla fase stabile

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

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

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

Visualizzare la release nella console Google Cloud

Ora che hai creato la prima release, il lancio è stato creato e puoi visualizzare la release e il lancio nella console Google Cloud . Puoi anche visualizzare la visualizzazione della pipeline, che mostra lo stato attuale del rilascio.

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 distribuzione

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

   La visualizzazione della pipeline mostra lo stato del deployment dell'app. Poiché la pipeline contiene una sola fase, 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.

   I rollout vengono visualizzati nella sezione Rollout. Puoi fare clic su un rollout per visualizzarne i dettagli, incluso il log di implementazione.

   

   Nota che lo stato di implementazione è "Avanzamento in attesa" e che la destinazione mostrata nella visualizzazione della pipeline ha un link ad "Avanza alla versione stabile".

Avanza alla fase di implementazione

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

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

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

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

Esegui il deployment canary

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

1. Per creare un nuovo release, esegui questo comando 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:95ade4b17adcd07623b0a0c68359e344fe54e65d0cb01b989e24c39f2fcd296a
   

   Dopo alcuni minuti, viene creata un'implementazione e questa volta viene eseguita la fase canary:

   

   Al termine della prima fase di implementazione, l'implementazione si trova ora nella fase canary:

   

   Ciò significa che l'applicazione è ora implementata al 50%. Per GKE basato su serviceNetworking, viene eseguito il deployment sulla metà dei tuoi pod. Per GKE e Cloud Run basati sull'API Gateway, il traffico viene allocato al 50%.

2. Fai clic su Implementazione avanzata, quindi su Avanza quando richiesto.

   In questo modo, l'implementazione passa alla fase "stabile", eseguendo il deployment dell'applicazione al 100%.