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 a una destinazione 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 e le destinazioni di deployment di Cloud Deploy.

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

4. Definisci due regole di automazione:

   • Un'automazione per promuovere la release nel target staging dopo l'implementazione riuscita 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 viene automaticamente implementata 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 questo runtime, la fase canary-25 viene ignorata. Consulta la sezione Perché a volte le fasi vengono saltate per capire meglio perché la fase canary viene saltata la prima volta.

   A causa dell'avanzamento automatico della fase, l'implementazione è stata portata alla fase stable.

Prima di iniziare

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.
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
Verify that billing is enabled for your Google Cloud project.
Enable the Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage APIs.
Enable the APIs
Install the Google Cloud CLI.
Se utilizzi un provider di identità (IdP) esterno, devi prima accedere alla gcloud CLI con la tua identità federata.
Per inizializzare 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.

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

Verify that billing is enabled for your Google Cloud project.

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

Enable the APIs

Install the Google Cloud CLI.

Se utilizzi un provider di identità (IdP) esterno, devi prima accedere alla gcloud CLI con la tua identità federata.

Per inizializzare 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 utilizzare l'ultima versione:

gcloud components update

1. Assicurati che l'account di servizio Compute Engine predefinito disponga delle autorizzazioni necessarie.

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

   1. Per prima cosa, 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 di 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 l'account di servizio predefinito per eseguire 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
      

   5. Aggiungi il ruolo iam.serviceAccountUser, inclusa l'autorizzazione actAs per utilizzare il 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 su 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 API Kubernetes dei cluster devono essere raggiungibili dalla rete internet pubblica. 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 di progetto.

   Per identificare il account di servizio predefinito, devi avere il numero di progetto. 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, il riferimento al account di servizio nella configurazione dell'automazione verrà compilato più avanti in questa guida rapida.

      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 come eseguirlo correttamente per i tuoi target separati.

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

   1. Apri una finestra del terminale.

   2. Crea una nuova directory e accedi.

      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. 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 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 container di cui eseguire il deployment è impostata qui come segnaposto, my-app-image, che viene sostituito 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 utilizzate per eseguire il deployment dell'applicazione. 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.

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

   Puoi definire la pipeline di pubblicazione e i target in un unico file o in file separati. 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, le configurazioni di target e automazioni sono incluse nella pipeline di pubblicazione, ma puoi definire i target in un file separato o in più file separati e le automazioni in un file separato o in più file.

      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, le configurazioni di destinazioni e automazioni sono incluse nella pipeline di pubblicazione, ma puoi definire le destinazioni in un file separato o in più file separati e le automazioni in un file o in 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 multiplo composto da due target GKE o Cloud Run, pronto per 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 un 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 Target.

      

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

   5. Seleziona la scheda Automazioni in Dettagli della pipeline di pubblicazione.

      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 questa release. Per informazioni dettagliate su questo 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 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
   

   Nota il flag --images=, che utilizzi per sostituire il segnaposto (my-app-image) nel manifest 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.

   Cloud Run

   Esegui questo comando dalla directory deploy-automation-run-quickstart per creare una risorsa release che rappresenti l'immagine 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:95ade4b17adcd07623b0a0c68359e344fe54e65d0cb01b989e24c39f2fcd296a
   

   Nota il flag --images=, che utilizzi per sostituire il segnaposto (my-app-image) nella definizione del servizio con l'immagine specifica qualificata con 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 rapida include due automazioni, due cose accadono automaticamente:

   • 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 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 da utilizzare come canary. e l'implementazione viene avanzata automaticamente a stable.

     L'automazione avanzata prevede un ritardo di un minuto.

   Al termine di tutte le operazioni, l'applicazione viene implementata correttamente in 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 rapida canary.

   Visualizza i risultati nella console Google Cloud

   Puoi visualizzare i risultati, comprese le esecuzioni dell'automazione, nella consoleGoogle Cloud .

   1. Vai alla pagina Pipeline di distribuzione di Cloud Deploy per visualizzare la tua 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 tempo sufficiente, entrambi i target verranno visualizzati in verde.

      

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

   3. Fai clic sulla scheda Esecuzioni dell'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 la pipeline di distribuzione, i target, 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

   Ecco fatto, 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 per Cloud Deploy.

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