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

Questa pagina mostra come utilizzare Cloud Deploy per promuovere automaticamente un in un target e passare alla fase successiva dell'implementazione.

In questa guida rapida, imparerai a:

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

  2. Crea una configurazione Skaffold e un cluster 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 su implementazione in dev riuscita.

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

  5. Crea un'istanza per la tua pipeline di distribuzione creando una release, che automaticamente viene eseguito nel target dev.

  6. Visualizza la pipeline di distribuzione e rilasciala 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.

    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
  7. In the Google Cloud console, on the project selector page, select or create a Google Cloud 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
  12. Se hai già installato l'interfaccia a riga di comando, assicurati di eseguire la versione più recente versione:

    gcloud components update
    
  13. 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 disabilitano le concessioni automatiche di ruoli per il servizio predefinito .

    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)")-compute@developer.gserviceaccount.com \
          --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)")-compute@developer.gserviceaccount.com \
          --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)")-compute@developer.gserviceaccount.com \
            --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)")-compute@developer.gserviceaccount.com \
            --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)")-compute@developer.gserviceaccount.com \
          --member=serviceAccount:$(gcloud projects describe PROJECT_ID \
          --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
          --role="roles/iam.serviceAccountUser" \
          --project=PROJECT_ID
      
    5. Aggiungi il ruolo iam.serviceAccountUser, incluso actAs per te, per usare l'account di servizio predefinito:
      gcloud iam service-accounts add-iam-policy-binding $(gcloud projects describe PROJECT_ID \
          --format="value(projectNumber)")-compute@developer.gserviceaccount.com \
          --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 i tuoi 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 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 tuo progetto.

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

  1. Esegui questo comando per ottenere il numero del tuo 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, viene compilata riferimento all'account di servizio nella configurazione dell'automazione 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 per di cosa eseguire il deployment e di come eseguirne il deployment target.

In questa guida rapida creerai un file skaffold.yaml, che identifica le manifest dell'applicazione da usare per 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, creerai . Puoi anche chiedere a Cloud Deploy di crearne uno per te per 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 strumento manifest, applicata 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, che viene utilizzata al momento del deployment per creare il servizio Cloud Run.

Crea pipeline di distribuzione, target e automazione

Puoi definire la pipeline di distribuzione e i target in un file o in file . 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 i seguenti contenuti:

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

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

    Viene mostrata la pipeline di distribuzione appena creata, con due target elencati in nella colonna Destinazioni.

    Visualizzazione della pipeline di distribuzione nella console Google Cloud

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

  5. Seleziona la scheda Automazioni nella sezione Dettagli pipeline di distribuzione.

    Vengono visualizzate le due automazioni che hai creato.

    Visualizzazione della pipeline di distribuzione nella console Google Cloud

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. Consulta: Architettura del servizio Cloud Deploy per maggiori dettagli sul ciclo di vita.

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

Cloud Run

Esegui questo comando dall'deploy-automation-run-quickstart per creare una risorsa release che rappresenti il 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:4a856b6f1c3ce723a456ddc2adfbb794cbfba93f727e2d96fcf6540bd0d6fff4

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, si verificano automaticamente due cose:

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

    È previsto un tempo di attesa di un minuto per l'automazione della promozione.

  • 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. Il lancio è avanza automaticamente a stable.

    L'automazione avanzata ha 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 prova la guida rapida di Canary.

Visualizza i risultati nella console Google Cloud

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

  1. Vai alla pagina Pipeline di distribuzione di Cloud Deploy per visualizzare della 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 c'è abbastanza tempo trascorsi entrambi i target, entrambi i target saranno verdi.

    visualizzazione della pipeline di distribuzione nella console Google Cloud

    La tua release sarà elencata nella scheda Uscite della sezione Pipeline di pubblicazione dettagli.

  3. Fai clic sulla scheda Esecuzioni automazioni.

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

    dettagli dell'esecuzione dell'automazione mostrati nella console Google Cloud

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 Cloud Run. Google Cloud:

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

Hai completato questa guida rapida.

Passaggi successivi