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

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 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, 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: PROJECT_NUMBER-compute@developer.gserviceaccount.com
   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: PROJECT_NUMBER-compute@developer.gserviceaccount.com
   selector:
     targets:
     - id: automation-quickstart-staging
   rules:
   - advanceRolloutRule:
       name: "advance-rollout"
       sourcePhases: ["canary-25"]
       wait: 1m
   

   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: PROJECT_NUMBER-compute@developer.gserviceaccount.com
   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: PROJECT_NUMBER-compute@developer.gserviceaccount.com
   selector:
     targets:
     - id: automation-quickstart-staging
   rules:
   - advanceRolloutRule:
       name: "advance-rollout"
       sourcePhases: ["canary-25"]
       wait: 1m
   

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

 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

 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

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 testare con il 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 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 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.