Automatizza la promozione delle release e l'avanzamento del lancio in Cloud Deploy

Automatizza la promozione delle release e l'avanzamento del lancio in Cloud Deploy

Questa pagina mostra come utilizzare Cloud Deploy per promuovere automaticamente una release in una destinazione e far avanzare un'implementazione alla fase successiva.

In questa guida rapida, imparerai a:

1. Creare due cluster GKE o due servizi Cloud Run.

2. Creare una configurazione Skaffold e un file manifest Kubernetes o una definizione del servizio Cloud Run.

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

   Il deployment della pipeline verrà eseguito in due destinazioni: dev e staging. E la destinazione staging usa una strategia di deployment canary.

4. Definisci due regole di automazione:

   • Un'automazione per promuovere la release nella destinazione staging al termine dell'implementazione in dev.

   • Un'automazione per far avanzare l'implementazione alla fase stable al completamento della fase canary-25.

5. Crea un'istanza della pipeline di distribuzione creando una release, che esegue automaticamente il deployment nella destinazione dev.

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

   A causa della promozione automatica, questa release viene promossa automaticamente nella staging.

   Poiché la destinazione staging utilizza una strategia di deployment canary e questo è il primo deployment in quel runtime, la fase canary-25 viene saltata. Consulta la sezione Perché le fasi a volte vengono ignorate per comprendere meglio perché la fase canary viene saltata la prima volta.

   Grazie all'avanzamento della fase automatizzato, l'implementazione passa alla fase stable.

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 clouddeploy.releaser:

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

    3. Aggiungi il ruolo sviluppatore per il runtime specifico.
    • Per GKE:

      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"
      

    4. Aggiungi il ruolo iam.serviceAccountUser, che include l'autorizzazione actAs per il deployment nel runtime per l'account di servizio predefinito:

       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
       

    5. Aggiungi il ruolo iam.serviceAccountUser, inclusa l'autorizzazione actAs per te, per utilizzare l'account di servizio predefinito:

       gcloud iam service-accounts add-iam-policy-binding $(gcloud projects describe PROJECT_ID \
           --format="value(projectNumber)")[e-mail] \
           --member=user:YOUR_EMAIL_ADDRESS \
           --role="roles/iam.serviceAccountUser" \
           --project=PROJECT_ID
       

       In questo caso, YOUR_EMAIL_ADDRESS è l'indirizzo email che utilizzi per accedere a Google Cloud.

Crea gli ambienti di runtime

Se stai eseguendo il deployment in Cloud Run, puoi saltare questo comando.

Per GKE, crea due cluster: automation-quickstart-cluster-dev e automation-quickstart-cluster-staging, con impostazioni predefinite. Gli endpoint API Kubernetes dei cluster devono essere raggiungibili in rete dalla rete internet pubblica. I cluster GKE sono accessibili dall'esterno per impostazione predefinita.

gcloud container clusters create-auto automation-quickstart-cluster-dev \
                 --project=PROJECT_ID \
                 --region=us-central1 \
                 && gcloud container clusters create-auto automation-quickstart-cluster-staging \
                 --project=PROJECT_ID \
                 --region=us-central1

Recupera il numero di progetto.

È necessario il numero di progetto per identificare l'account di servizio predefinito. Questo è necessario per configurare la risorsa di automazione.

1. Esegui questo comando per ottenere il numero di progetto:

   gcloud projects describe PROJECT_ID
   

2. Copia il numero del progetto dall'output della riga di comando e incollalo qui.

   Non è necessario eseguirlo come comando. Se lo incolli qui, verrà completato il riferimento dell'account di servizio nella configurazione dell'automazione più avanti in questa guida rapida.

   PROJECT_NUMBER
   

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 i target separati.

In questa guida rapida, creerai un file skaffold.yaml che identifica il manifest dell'applicazione da utilizzare per eseguire il deployment dell'app di esempio.

1. Apri una finestra del terminale.

2. Crea una nuova directory e aprila.

   GKE

   mkdir deploy-automation-gke-quickstart
   cd deploy-automation-gke-quickstart
   

   Cloud Run

   mkdir deploy-automation-run-quickstart
   cd deploy-automation-run-quickstart
   

3. Crea un file denominato skaffold.yaml con il seguente contenuto:

   GKE

   apiVersion: skaffold/v4beta7
   kind: Config
   metadata:
     name: gke-automation
   manifests:
     rawYaml:
     - k8s-deployment.yaml
   deploy:
     kubectl: {}
   

   Cloud Run

   apiVersion: skaffold/v4beta7
   kind: Config
   metadata:
     name: run-automation
   profiles:
   - name: dev
     manifests:
       rawYaml:
       - run-dev.yaml
   - name: staging
     manifests:
       rawYaml:
       - run-staging.yaml
   deploy:
     cloudrun: {}
   

   Questo file è una configurazione Skaffold minima. 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. Crea la definizione per l'applicazione: una coppia di definizioni di servizio per Cloud Run o un manifest Kubernetes per GKE.

   GKE

   Crea un file denominato k8s-deployment.yaml, 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.

   Cloud Run

   1. Crea un file denominato run-dev.yaml, con il seguente contenuto:

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

   2. Crea un file denominato run-staging.yaml, con il seguente contenuto:

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

   Questo file è una semplice definizione del servizio Cloud Run, utilizzata al momento del deployment per creare il tuo servizio Cloud Run.

Crea pipeline di distribuzione, target e automazione

Puoi definire i target e la pipeline di distribuzione in un file o in file separati. Puoi anche definire un'azione di automazione in un file separato. Questa guida rapida utilizza un file per la pipeline, i target e l'automazione.

1. Crea la pipeline di distribuzione, le definizioni dei target e l'azione di automazione:

   GKE

   Nella directory deploy-automation-gke-quickstart, crea un nuovo file: clouddeploy.yaml, con il seguente contenuto:

   apiVersion: deploy.cloud.google.com/v1
   kind: DeliveryPipeline
   metadata:
     name: my-automation-demo-app-1
   description: Automation demonstration pipeline
   serialPipeline:
     stages:
     - targetId: automation-quickstart-dev
     - targetId: automation-quickstart-staging
       profiles: []
       strategy:
         canary:
           runtimeConfig:
             kubernetes:
               serviceNetworking:
                 service: "my-service"
                 deployment: "my-deployment"
           canaryDeployment:
             percentages: [25]
             verify: false
   ---
   
   apiVersion: deploy.cloud.google.com/v1
   kind: Target
   metadata:
     name: automation-quickstart-dev
   description: Dev cluster to demonstrate deploy automation
   gke:
     cluster: projects/PROJECT_ID/locations/us-central1/clusters/automation-quickstart-cluster-dev
   ---
   
   apiVersion: deploy.cloud.google.com/v1
   kind: Target
   metadata:
     name: automation-quickstart-staging
   description: Staging cluster to demonstrate deploy automation
   gke:
     cluster: projects/PROJECT_ID/locations/us-central1/clusters/automation-quickstart-cluster-staging
   ---
   
   apiVersion: deploy.cloud.google.com/v1
   kind: Automation
   metadata:
     name: my-automation-demo-app-1/promote
   description: promotes a release
   suspended: false
   serviceAccount: [e-mail]
   selector:
   - targets:
       id: automation-quickstart-dev
   rules:
   - promoteReleaseRule:
       name: "promote-release"
       wait: 1m
       toTargetId: "@next"
   ---
   
   apiVersion: deploy.cloud.google.com/v1
   kind: Automation
   metadata:
     name: my-automation-demo-app-1/advance
   description: advances a rollout
   suspended: false
   serviceAccount: [e-mail]
   selector:
   - targets:
       id: automation-quickstart-staging
   rules:
   - advanceRolloutRule:
       name: "advance-rollout"
       sourcePhases: ["canary-25"]
       wait: 1m
   

   Nota: in questo file i target e la configurazione delle automazioni sono inclusi nella pipeline di distribuzione, ma puoi definire i target in un file separato o in più file separati e le automazioni in uno o più file separati.

   Cloud Run

   Nella directory deploy-automation-run-quickstart, crea un nuovo file: clouddeploy.yaml, con il seguente contenuto:

   apiVersion: deploy.cloud.google.com/v1
   kind: DeliveryPipeline
   metadata:
     name: my-automation-demo-app-1
   description: Automation demonstration pipeline
   serialPipeline:
     stages:
     - targetId: automation-quickstart-dev
       profiles: [dev]
     - targetId: automation-quickstart-staging
       profiles: [staging]
       strategy:
         canary:
           runtimeConfig:
             cloudRun:
               automaticTrafficControl: true
           canaryDeployment:
             percentages: [25]
             verify: false
   ---
   
   apiVersion: deploy.cloud.google.com/v1
   kind: Target
   metadata:
     name: automation-quickstart-dev
   description: Dev cluster to demonstrate deploy automation
   run:
     location: projects/PROJECT_ID/locations/us-central1
   ---
   
   apiVersion: deploy.cloud.google.com/v1
   kind: Target
   metadata:
     name: automation-quickstart-staging
   description: Staging cluster to demonstrate deploy automation
   run:
     location: projects/PROJECT_ID/locations/us-central1
   ---
   
   apiVersion: deploy.cloud.google.com/v1
   kind: Automation
   metadata:
     name: my-automation-demo-app-1/promote
   description: Promotes a release to the next target
   suspended: false
   serviceAccount: [e-mail]
   selector:
   - targets:
       id: automation-quickstart-dev
   rules:
   - promoteReleaseRule:
       name: "promote-release"
       wait: 1m
       toTargetId: "@next"
   ---
   
   apiVersion: deploy.cloud.google.com/v1
   kind: Automation
   metadata:
     name: my-automation-demo-app-1/advance
   description: advances a rollout
   suspended: false
   serviceAccount: [e-mail]
   selector:
   - targets:
       id: automation-quickstart-staging
   rules:
   - advanceRolloutRule:
       name: "advance-rollout"
       sourcePhases: ["canary-25"]
       wait: 1m
   

   Nota: in questo file i target e la configurazione delle automazioni sono inclusi nella pipeline di distribuzione, ma puoi definire i target in un file separato o in più file separati e le automazioni in uno o più file separati.

2. 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 multi-target che comprende due destinazioni GKE o Cloud Run, pronta per il deployment dell'applicazione.

3. 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, con due target elencati nella colonna Destinazioni.

   

4. Fai clic sul nome della pipeline per aprire la relativa visualizzazione e i dettagli.

5. Seleziona la scheda Automazioni in Dettagli pipeline di distribuzione.

   Vengono mostrate le due automazioni che hai creato.

   

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.

GKE

Esegui questo comando dalla directory deploy-automation-gke-quickstart per creare una risorsa release che rappresenti l'immagine del container di cui eseguire il deployment:

 gcloud deploy releases create test-release-001 \
   --project=PROJECT_ID \
   --region=us-central1 \
   --delivery-pipeline=my-automation-demo-app-1 \
   --images=my-app-image=gcr.io/google-containers/nginx@sha256:f49a843c290594dcf4d193535d1f4ba8af7d56cea2cf79d1e9554f077f1e7aaa

Cloud Run

Esegui questo comando dalla directory deploy-automation-run-quickstart per creare una risorsa release che rappresenti l'immagine del container di cui eseguire il deployment:

 gcloud deploy releases create test-release-001 \
   --project=PROJECT_ID \
   --region=us-central1 \
   --delivery-pipeline=my-automation-demo-app-1 \
   --images=my-app-image=us-docker.pkg.dev/cloudrun/container/hello@sha256:6063adf8f687702b4065151acddba6781c47bc602167eb9f3bec8aebc9ce95cc

Per impostazione predefinita, quando crei una release, viene creata automaticamente un'implementazione per la prima destinazione nella pipeline.

Poiché questa guida rapida include due automazioni, si verificano due passaggi automaticamente:

• Dopo un deployment riuscito nel primo target, la release viene promossa automaticamente al secondo target.

  L'automazione della promozione richiede un tempo di attesa di un minuto.

• Nel secondo target, in cui è configurato una versione canary del 25%, la seconda automazione fa avanzare l'implementazione da canary-25 a stable.

  Per questa prima release, la fase canary-25 viene ignorata perché non esiste una versione preesistente dell'app di nuovo per la versione canary. E l'implementazione passa automaticamente a stable.

  L'automazione dell'avanzamento della procedura subisce un ritardo di un minuto.

Al termine, viene eseguito il deployment dell'applicazione in entrambi i target, senza che tu debba fare altro.

Per saperne di più sull'esecuzione di una strategia di deployment canary, prova la guida rapida canary.

Visualizza i risultati nella console Google Cloud

Puoi visualizzare i risultati, incluse le esecuzioni dell'automazione, nella console Google Cloud.

1. Vai alla pagina pipeline di distribuzione di Cloud Deploy per visualizzare la pipeline di distribuzione.

   Apri la pagina Pipeline di distribuzione

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

   La visualizzazione della pipeline mostra lo stato del deployment dell'app. Se è trascorso un po' di tempo, entrambi gli obiettivi verranno visualizzati in verde.

   

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

3. Fai clic sulla scheda Esecuzioni automazione.

   Sono presenti due voci, una per ciascuna delle due automazioni che hai creato. Puoi fare clic su uno dei due per visualizzare i dettagli dell'esecuzione dell'automazione.

   

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 i cluster GKE o i servizi Cloud Run:

   GKE

   gcloud container clusters delete automation-quickstart-cluster-dev --region=us-central1 --project=PROJECT_ID \
   && gcloud container clusters delete automation-quickstart-cluster-staging --region=us-west1 --project=PROJECT_ID
   

   Cloud Run

   gcloud run services delete my-automation-run-service-dev --region=us-central1 --project=PROJECT_ID \
   && gcloud run services delete my-automation-run-service-staging --region=us-central1 --project=PROJECT_ID
   

2. Elimina pipeline di distribuzione, target, automazioni, release e implementazioni:

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

3. 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 combinare gli strumenti CI/CD di Google Cloud per sviluppare e distribuire il software in modo efficace su GKE.