Eseguire il deployment di un'applicazione in modalità canary in una destinazione

Eseguire il deployment di un'applicazione in modalità canary in una destinazione

Questa guida rapida mostra come utilizzare Cloud Deploy per distribuire un'immagine dell'applicazione di esempio in un deployment canary su Google Kubernetes Engine o Cloud Run. (Puoi anche eseguire un deployment canary in GKE Enterprise, ma in questa guida rapida sono mostrati solo GKE e Cloud Run.)

Un deployment canary suddivide il traffico tra una versione dell'applicazione di cui è già stato eseguito il deployment e la nuova versione. Cloud Run distribuisce il traffico in base alle percentuali configurate nella pipeline di distribuzione. GKE esegue il deployment della nuova versione in una proporzione di pod. Questa guida rapida esegue prima il deployment al 50%, poi al 100%.

In questa guida rapida è presente un solo target (prod). Pertanto, creiamo un solo cluster GKE o un solo servizio Cloud Run per eseguire l'applicazione.

In questa guida rapida, imparerai a:

1. Crea un cluster GKE o definisci un servizio Cloud Run.

   Puoi anche eseguire il deployment canary in cluster GKE Enterprise, ma questa guida rapida utilizza solo GKE e Cloud Run.

2. Creare una configurazione Skaffold e un manifest Kubernetes per specificare l'immagine del container (predefinita) di cui eseguire il deployment.

3. Definire la pipeline di distribuzione di Cloud Deploy e il target del deployment.

4. Richiama la pipeline di distribuzione creando una release, che esegue automaticamente il deployment in una destinazione.

   In questa prima release salta la fase canary.

5. Visualizza la pipeline di distribuzione e rilasciala nella console Google Cloud.

6. Crea una seconda release, questa volta eseguendo la fase canary per eseguire il deployment dell'applicazione al 50%.

7. Fai avanzare la release per eseguire il deployment al 100%.

Prima di iniziare

1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

2. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

   Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

   Vai al selettore progetti

3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

4. Abilita le API Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage.

   Abilita le API

5. Installa Google Cloud CLI.

6. Per initialize gcloud CLI, esegui questo comando:

   gcloud init

   Nota: puoi eseguire gcloud CLI nella console Google Cloud senza installare Google Cloud CLI. Per eseguire gcloud CLI nella console Google Cloud, utilizza Cloud Shell.

7. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

   Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

   Vai al selettore progetti

8. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

9. Abilita le API Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage.

   Abilita le API

10. Installa Google Cloud CLI.

11. Per initialize gcloud CLI, esegui questo comando:

    gcloud init

    Nota: puoi eseguire gcloud CLI nella console Google Cloud senza installare Google Cloud CLI. Per eseguire gcloud CLI nella console Google Cloud, utilizza Cloud Shell.

Se hai già installato l'interfaccia a riga di comando, assicurati di eseguire la versione più recente:

gcloud components update

12. Assicurati che l'account di servizio Compute Engine predefinito abbia le autorizzazioni sufficienti.

    L'account di servizio potrebbe avere già le autorizzazioni necessarie. Questi passaggi sono inclusi per i progetti che disabilitano le concessioni automatiche dei ruoli per gli account di servizio predefiniti.

    1. Innanzitutto, aggiungi il ruolo clouddeploy.jobRunner:

       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. Aggiungi il ruolo sviluppatore per il runtime specifico.
    • Per GKE e GKE con API Gateway:

      gcloud projects add-iam-policy-binding PROJECT_ID \
          --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
          --format="value(projectNumber)")[e-mail] \
          --role="roles/container.developer"
      

    • Per 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. Aggiungi il ruolo iam.serviceAccountUser, che include l'autorizzazione actAsper il deployment nel runtime:

       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
       

Crea l'ambiente di runtime

GKE

Crea un cluster GKE Autopilot:

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

API GKE + Gateway

1. Crea un cluster GKE, con le impostazioni consigliate per supportare l'utilizzo con Istio:

   gcloud container clusters create canary-quickstart-cluster \
          --machine-type=n1-standard-1 \
          --num-nodes 4 \
          --region=us-central1 \
          --project=PROJECT_ID
   

2. Recupera le credenziali del cluster:

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

3. Installa i CRD dell'API Kubernetes Gateway, se non sono già presenti nel cluster.

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

4. Abilita l'implementazione del controller gateway di Istio installando Istio.

   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

Se utilizzi Cloud Run, puoi saltare questo comando, non devi fare nulla qui.

Prepara il manifest dell'applicazione e della configurazione Skaffold

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

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

1. Apri una finestra del terminale.

2. Crea una nuova directory e aprila.

   GKE

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

   API GKE + 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: {}
   

   API GKE + 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. Ma puoi anche chiedere a Cloud Deploy di crearne uno per applicazioni semplici non di produzione.

   Consulta la documentazione di riferimento di skaffold.yaml per ulteriori informazioni su questo file.

4. Creare 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 semplice manifest Kubernetes, che viene applicato al cluster per eseguire il deployment dell'applicazione.

   API GKE + 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 di servizio e deployment necessarie per il deployment canary, oltre a HTTPRoute e alla risorsa Gateway necessarie per l'utilizzo dell'API Gateway.

   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 è un file di configurazione del servizio Cloud Run, che viene applicato al momento del deployment per creare il tuo servizio in Cloud Run.

Nota: se vuoi utilizzare manifest diversi per ogni destinazione, leggi questo articolo sulla gestione dei manifest per saperne di più sull'uso dei profili Skaffold.

Crea la pipeline di distribuzione e i target

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

GKE

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

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

API GKE + Gateway

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

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

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

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 una destinazione configurata 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 Destinazioni.

   

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 quella release. Per i dettagli sul ciclo di vita, consulta Architettura del servizio Cloud Deploy.

Per creare una risorsa release che rappresenti l'immagine del container di cui eseguire il deployment, 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-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

API GKE + Gateway

 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:6063adf8f687702b4065151acddba6781c47bc602167eb9f3bec8aebc9ce95cc

Quando crei una release, Cloud Deploy crea automaticamente anche una risorsa di implementazione, per eseguire immediatamente il deployment nella tua singola destinazione, prod.

Passiamo alla fase stabile

Con questa prima release, saltiamo la fase canary ed eseguiamo il deployment al 100% (fase stabile). Il motivo è che il deployment dell'applicazione non è stato eseguito in precedenza, quindi non è possibile calcolare il 50% dei pod (per GKE) o la suddivisione del 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 avviare la fase stabile, che porta il traffico al 100%. In seguito, creeremo un'altra release e verrà eseguita la versione canary.

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

Visualizza la release nella console Google Cloud

Ora che hai creato la prima release, puoi visualizzare il lancio e l'implementazione 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 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é c'è una sola fase nella pipeline, la visualizzazione mostra solo un nodo.

   

   La release è elencata nella scheda Release in Dettagli della pipeline di pubblicazione.

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

   

   Tieni presente che lo stato dell'implementazione è "In attesa di avanzamento" e il target mostrato nella visualizzazione della pipeline include il link "Passa alla versione stabile".

Prosegui la 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 Avanza per confermare.

Dopo alcuni minuti, l'implementazione è ora nella fase "stabile" e il deployment dell'applicazione è stato eseguito al 100%.

Esegui il deployment canary

Poiché la prima release ha saltato la fase canary, ne creeremo un'altra, 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
   

   API GKE + 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:6063adf8f687702b4065151acddba6781c47bc602167eb9f3bec8aebc9ce95cc
   

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

   

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

   

   Ciò significa che il deployment dell'applicazione è stato eseguito al 50%. Nel caso di GKE basato su serviceNetworking, ne viene eseguito il deployment in metà dei pod. Per il traffico GKE e Cloud Run basato su API Gateway è allocato al 50%.

2. Fai clic su Avanzamento implementazione, quindi su Avanza quando richiesto.

   Questo porta l'implementazione alla fase "stabile", eseguendo il deployment dell'applicazione al 100%.

   

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questa pagina, segui questi passaggi:

1. Elimina il cluster canary-quickstart-cluster (solo GKE):

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

2. Elimina il servizio my-canary-run-service (solo Cloud Run):

   gcloud run services delete my-canary-run-service --region=us-central1 --project=PROJECT_ID
   

3. Elimina la pipeline di distribuzione, la destinazione e tutte le risorse di rilascio e implementazione:

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

4. Eliminare i bucket Cloud Storage creati da Cloud Deploy.

   Uno termina con _clouddeploy e l'altro è [region].deploy-artifacts.[project].appspot.com.

   Apri la pagina del browser di Cloud Storage

È tutto. Hai completato questa guida rapida.

Passaggi successivi

• Scopri di più su Cloud Deploy.

• Apprendi le nozioni di base sul deployment delle applicazioni.

• Prova la procedura dettagliata di Cloud Deploy.

• Scopri come gestire i manifest.

• Scopri come combinare gli strumenti CI/CD di Google Cloud per sviluppare e distribuire il software in modo efficace su GKE.