Automatizzare la promozione delle release e l'avanzamento dell'implementazione in Cloud Deploy

Automatizzare la promozione delle release e l'avanzamento dell'implementazione in Cloud Deploy

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

In questa guida rapida imparerai a:

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

2. Crea una configurazione Skaffold e un manifest Kubernetes o una definizione di servizio Cloud Run.

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

   La pipeline verrà implementata in due target: dev e staging. Inoltre, il target staging utilizza una strategia di deployment canary.

4. Definisci due regole di automazione:

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

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

5. Esegui l'inizializzazione della pipeline di distribuzione creando una release, che viene eseguita automaticamente nel target dev.

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

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

   Poiché il target staging utilizza una strategia di deployment canary e questo è il primo deployment in quel runtime, la fase canary-25 viene saltata. Consulta Perché a volte le fasi vengono saltate per saperne di più sul motivo per cui la fase canary viene saltata la prima volta.

   A causa dell'avanzamento automatico della fase, l'implementazione passa alla fase stable.

Prima di iniziare

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. Enable the Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage APIs.

   Enable the APIs

5. Install the Google Cloud CLI.

6. To initialize the gcloud CLI, run the following command:

   gcloud init

   Note: You can run the gcloud CLI in the Google Cloud console without installing the Google Cloud CLI. To run the gcloud CLI in the Google Cloud console, use Cloud Shell.

7. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

8. Make sure that billing is enabled for your Google Cloud project.

9. Enable the Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage APIs.

   Enable the APIs

10. Install the Google Cloud CLI.

11. To initialize the gcloud CLI, run the following command:

    gcloud init

    Note: You can run the gcloud CLI in the Google Cloud console without installing the Google Cloud CLI. To run the gcloud CLI in the Google Cloud console, use Cloud Shell.

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

gcloud components update

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

    L'account di servizio potrebbe già disporre delle autorizzazioni necessarie. Questi passaggi sono inclusi per i progetti che disattivano la concessione automatica dei ruoli per gli account di servizio predefiniti.

    1. Aggiungi prima 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 tuo 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 dell'account di servizio predefinito 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
       

    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 esegui il deployment in Cloud Run, puoi saltare questo comando.

Per GKE, crea due cluster: automation-quickstart-cluster-dev e automation-quickstart-cluster-staging, con le impostazioni predefinite. Gli endpoint dell'API Kubernetes dei cluster devono essere raggiungibili dalla rete dall'internet pubblico. I cluster GKE sono accessibili esternamente 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 del progetto.

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

1. Esegui il seguente 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 eseguire questo comando. Se lo incolli qui, il riferimento al account di servizio viene compilato nella configurazione dell'automazione in un secondo momento in questa guida introduttiva.

   PROJECT_NUMBER
   

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 per i singoli target.

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

   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 i seguenti contenuti:

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

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

4. Crea la definizione per la tua 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 i seguenti contenuti:

   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, utilizzato per eseguire il deployment dell'applicazione. L'immagine del container di cui eseguire il deployment è impostata qui come segnaposto,my-app-image, che viene sostituita con l'immagine specifica quando crei la release.

   Cloud Run

   1. Crea un file denominato run-dev.yaml con i seguenti contenuti:

      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 i seguenti contenuti:

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

   Questi file sono semplici definizioni di servizi Cloud Run, che vengono utilizzati per eseguire il deployment dell'applicazione. L'immagine del contenitore da eseguire il deployment viene impostata qui come segnaposto, my-app-image, che viene sostituita con l'immagine specifica quando crei la release.

Crea la pipeline di distribuzione, i target e l'automazione

Puoi definire la pipeline di importazione e i target in un file o in file distinti. Puoi anche definire un'azione di automazione in un file separato. Questo quickstart 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 con la pipeline di importazione, ma puoi definire i target in un file separato o in più file separati e le automazioni in un file 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 con la pipeline di importazione, ma puoi definire i target in un file separato o in più file separati e le automazioni in un file 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 multipla composto da due target GKE o Cloud Run, pronta per eseguire il deployment della tua 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 pubblicazione

   Viene visualizzata la pipeline di importazione appena creata, con due target elencati nella colonna Target.

   

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

5. Seleziona la scheda Automazioni in Dettagli sulla pipeline di importazione.

   Vengono mostrate le due automazioni che hai creato.

   

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.

GKE

Esegui il seguente comando dalla directory deploy-automation-gke-quickstart per creare una risorsa release che rappresenti l'immagine del container da 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

Tieni presente il flag --images=, che utilizzi per sostituire il segnaposto (my-app-image) nel manifest con l'immagine specifica con qualificatore SHA. Google consiglia di creare modelli per i manifest in questo modo e di utilizzare nomi di immagini qualificati SHA durante la creazione della release.

Cloud Run

Esegui il seguente comando dalla directory deploy-automation-run-quickstart per creare una risorsa release che rappresenti l'immagine del container da 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:4a856b6f1c3ce723a456ddc2adfbb794cbfba93f727e2d96fcf6540bd0d6fff4

Nota il flag --images=, che utilizzi per sostituire il segnaposto (my-app-image) nella definizione del servizio con l'immagine specifica con hash SHA. Google consiglia di creare modelli per le definizioni di servizi e job in questo modo e di utilizzare nomi di immagini qualificati SHA durante la creazione della release.

Per impostazione predefinita, quando crei una release, viene creata automaticamente un'implementazione per il primo target della pipeline.

Poiché questa guida introduttiva include due automazioni, accade automaticamente quanto segue:

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

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

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

  Per questa prima release, la fase canary-25 viene saltata perché non esiste una versione preesistente dell'app da confrontare con la versione canary. L'implementazione viene avanzata automaticamente a stable.

  L'automazione anticipata presenta un ritardo di un minuto.

Al termine, l'applicazione viene dispiattata correttamente su entrambi i target senza che tu debba fare altro.

Se vuoi saperne di più sull'esecuzione di una strategia di deployment canary, puoi provare la guida introduttiva al 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 tua pipeline di distribuzione.

   Apri la pagina Pipeline di pubblicazione

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

   La visualizzazione della pipeline mostra lo stato di deployment dell'app. Se è trascorso tempo sufficiente, entrambi i target saranno verdi.

   

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

3. Fai clic sulla scheda Esecuzioni automazioni.

   Sono presenti due voci, una per ciascuna delle due automazioni che hai creato. Puoi fare clic su una delle 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 la pipeline di distribuzione, le destinazioni, le automazioni, la release e le implementazioni:

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

3. Elimina 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 Cloud Storage

È tutto, hai completato questa guida rapida.

Passaggi successivi

• Scopri di più su Cloud Deploy.

• Prova altre automazioni.

• Scopri 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 efficacemente il software su GKE.