Esegui gli hook prima e dopo il deployment

Esegui gli hook prima e dopo il deployment

Questa guida rapida mostra come eseguire un hook di deployment, un programma arbitrario da eseguire prima o dopo il deployment utilizzando Cloud Deploy.

In questa guida rapida, imparerai a:

1. Creare un cluster GKE o un servizio Cloud Run.

   Puoi utilizzare un cluster GKE Enterprise anche per questo, ma questa guida rapida utilizza solo GKE e Cloud Run.

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

   Il file di configurazione Skaffold è il luogo in cui configuri gli hook di deployment da eseguire. Devi identificare un container da eseguire prima del deployment e un container da eseguire dopo il deployment.

3. Definisci la pipeline di distribuzione e la destinazione del deployment di Cloud Deploy.

   Nella configurazione della pipeline di distribuzione, farai riferimento agli hook di deployment definiti in skaffold.yaml per eseguirli.

   Questa pipeline include una sola fase e utilizza un solo target.

4. Crea una release, che esegue automaticamente il deployment nella destinazione.

   Uno degli hook viene eseguito prima del deployment dell'applicazione, mentre l'altro viene eseguito dopo.

5. Visualizza i risultati degli hook pre e post-deployment nei log di Cloud Build, utilizzando la pagina Dettagli implementazione di Cloud Deploy nella console Google Cloud.

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 console di Google Cloud Console, nella pagina del selettore dei progetti, seleziona o crea un progetto Google Cloud.

   Nota: se non prevedi di conservare le risorse che crei in questa procedura, crea un progetto invece di selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto e rimuovere 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 inizializzare l'interfaccia a riga di comando gcloud, esegui il comando seguente:

   gcloud init

   Nota: puoi eseguire gcloud CLI nella console Google Cloud senza installare Google Cloud CLI. Per eseguire l'interfaccia alla gcloud CLI nella console Google Cloud, utilizza Cloud Shell.

7. Nella console di Google Cloud Console, nella pagina del selettore dei progetti, seleziona o crea un progetto Google Cloud.

   Nota: se non prevedi di conservare le risorse che crei in questa procedura, crea un progetto invece di selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto e rimuovere 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 inizializzare l'interfaccia a riga di comando gcloud, esegui il comando seguente:

    gcloud init

    Nota: puoi eseguire gcloud CLI nella console Google Cloud senza installare Google Cloud CLI. Per eseguire l'interfaccia alla 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 disponga di autorizzazioni sufficienti.

    L'account di servizio potrebbe già disporre delle autorizzazioni necessarie. Questi passaggi sono inclusi per i progetti che disattivano 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 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"
  

3. Aggiungi il ruolo iam.serviceAccountUser, che include l'autorizzazione actAs 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
   

Crea l'ambiente di runtime

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

Per GKE, crea un solo cluster: deploy-hooks-cluster, con le impostazioni predefinite. L'endpoint API Kubernetes del cluster deve essere raggiungibile alla rete dalla rete internet pubblica. I cluster GKE sono accessibili dall'esterno per impostazione predefinita.

gcloud container clusters create-auto deploy-hooks-cluster \
                 --project=PROJECT_ID \
                 --region=us-central1

Prepara il manifest della configurazione e dell'applicazione Skaffold

Cloud Deploy utilizza Skaffold per fornire i dettagli su cosa eseguire il deployment e su come eseguirlo per il tuo target.

In questa guida rapida, creerai un file skaffold.yaml che identifica il manifest da utilizzare per eseguire il deployment dell'app di esempio e i container da eseguire prima e dopo il deployment (gli hook di deployment).

1. Apri una finestra del terminale.

2. Crea una nuova directory e aprila.

   GKE

   mkdir deploy-hooks-gke-quickstart
   cd deploy-hooks-gke-quickstart
   

   Cloud Run

   mkdir deploy-hooks-run-quickstart
   cd deploy-hooks-run-quickstart
   

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

   GKE

   apiVersion: skaffold/v4beta5
   kind: Config
   manifests:
     rawYaml:
     - k8s-pod.yaml
   deploy:
     kubectl: {}
   customActions:
   - name: predeploy-action
     containers:
     - name: predeploy-echo
       image: ubuntu
       command: ["/bin/sh"]
       args: ["-c", 'echo "this is a predeploy action"' ]
   - name: postdeploy-action
     containers:
     - name: postdeploy-echo
       image: ubuntu
       command: ["/bin/sh"]
       args: ["-c", 'echo "this is a postdeploy action"' ]
   

   Cloud Run

   apiVersion: skaffold/v4beta5
   kind: Config
   manifests:
     rawYaml:
     - service.yaml
   deploy:
     cloudrun: {}
   customActions:
   - name: predeploy-action
     containers:
     - name: predeploy-echo
       image: ubuntu
       command: ["/bin/sh"]
       args: ["-c", 'echo "this is a predeploy action"' ]
   - name: postdeploy-action
     containers:
     - name: postdeploy-echo
       image: ubuntu
       command: ["/bin/sh"]
       args: ["-c", 'echo "this is a postdeploy action"' ]
   

   Questo file include la stanza customActions:. Questo definisce i container da eseguire prima e dopo il deployment: gli hook.

   Consulta il riferimento skaffold.yaml per ulteriori informazioni su questo file di configurazione.

4. Crea la definizione per la tua applicazione: una definizione di servizio per Cloud Run o un manifest Kubernetes per GKE.

   GKE

   Crea un file denominato k8s-pod.yaml con il seguente contenuto:

   apiVersion: v1
   kind: Pod
   metadata:
     name: my-hooks-pod
   spec:
     containers:
     - name: nginx
       image: my-app-image
   

   Si tratta di un semplice manifest di Kubernetes, che viene applicato al cluster per il deployment dell'applicazione.

   Cloud Run

   Crea un file denominato service.yaml con il seguente contenuto:

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

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

Nota: se vuoi utilizzare manifest diversi per destinazione, leggi questo articolo sulla gestione dei manifest per saperne di più sull'utilizzo dei profili Skaffold.

Crea la tua pipeline di distribuzione e il target

Puoi definire la pipeline e il target in un file o in file separati. In questa guida rapida, crei un singolo file.

1. Crea la pipeline di distribuzione e la definizione dei target:

   GKE

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

   apiVersion: deploy.cloud.google.com/v1
   kind: DeliveryPipeline
   metadata:
     name: deploy-hooks-demo-app-gke-1
   description: main application pipeline
   serialPipeline:
     stages:
     - targetId: hooks-staging
       profiles: []
       strategy:
         standard:
           predeploy:
             actions: ["predeploy-action"]
           postdeploy:
             actions: ["postdeploy-action"]
   ---
   
   apiVersion: deploy.cloud.google.com/v1
   kind: Target
   metadata:
     name: hooks-staging
   description: hooks staging cluster
   gke:
     cluster: projects/PROJECT_ID/locations/us-central1/clusters/deploy-hooks-cluster
   

   Cloud Run

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

   apiVersion: deploy.cloud.google.com/v1
   kind: DeliveryPipeline
   metadata:
     name: deploy-hooks-demo-app-run-1
   description: main application pipeline
   serialPipeline:
     stages:
     - targetId: hooks-staging
       profiles: []
       strategy:
         standard:
           predeploy:
             actions: ["predeploy-action"]
           postdeploy:
             actions: ["postdeploy-action"]
   ---
   
   apiVersion: deploy.cloud.google.com/v1
   kind: Target
   metadata:
     name: hooks-staging
   description: staging Run service
   run:
     location: projects/PROJECT_ID/locations/us-central1
   

   Nota: in questo file, il target è incluso nella pipeline di distribuzione, ma puoi definire i target in un file separato o in più file separati.

2. Registra la tua pipeline e i tuoi target con il servizio Cloud Deploy:

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

   Ora hai una pipeline di distribuzione, con una destinazione, pronta per eseguire il deployment della tua applicazione e per eseguire i job di pre-deployment e post-deployment.

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 una destinazione elencata nella colonna Destinazioni.

   

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 di quella release. Consulta Architettura del servizio Cloud Deploy per i dettagli su quel ciclo di vita.

GKE

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

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

Cloud Run

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

 gcloud deploy releases create test-release-001 \
   --project=PROJECT_ID \
   --region=us-central1 \
   --delivery-pipeline=deploy-hooks-demo-app-run-1 \
   --images=my-app-image=gcr.io/cloudrun/hello@sha256:7c0aeb55b25b12c656ad0856b13126ca0346c16dc631d9d7fa9dc335dd4a05df

Come per tutte le release (a meno che non includano --disable-initial-rollout), Cloud Deploy crea automaticamente anche una risorsa implementazione. Il deployment dell'applicazione viene eseguito automaticamente nell'unica destinazione configurata per questa pipeline di distribuzione.

Inoltre, il job di pre-deployment viene eseguito prima del deployment dell'applicazione, mentre il job post-deployment viene eseguito dopo.

Visualizza i risultati nella console Google Cloud

Dopo qualche minuto, viene eseguito il deployment della release nel runtime di destinazione.

Gli hook pre e post-deployment che abbiamo configurato (ad esempio) stampano le stringhe nei log di Cloud Build. Possiamo visualizzare questi log per confermare che gli hook hanno funzionato come previsto.

1. Nella console Google Cloud, vai alla pagina pipeline di distribuzione di Cloud Deploy per visualizzare la pipeline di distribuzione ("deploy-hooks-demo-app-gke-1" o "deploy-hooks-demo-app-run-1").

   Apri la pagina Pipeline di distribuzione

2. Fai clic sul nome della pipeline di distribuzione ("deploy-hooks-demo-app-gke-1" o "deploy-hooks-demo-app-run-1").

   La visualizzazione della pipeline mostra lo stato del deployment dell'app. Poiché la pipeline prevede una sola fase, la visualizzazione mostra solo un nodo.

   

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

3. Fai clic sulla scheda Implementazioni in Dettagli pipeline di distribuzione.

4. Fai clic sul nome dell'implementazione per visualizzarne i dettagli.

   

   Predeploy e Postdeploy sono elencati come job.

5. Fai clic su Pre-deployment

   Viene visualizzato il log di esecuzione del job.

6. Scorri verso il basso nell'elenco delle voci di log fino a trovare predeploy-echo e fai clic su di esso.

   

   Osserva il textPayload. La stringa è quella che è stata configurata in predeploy-action nella configurazione Skaffold.

7. Fai clic sul job Postdeploy e trova la voce di log postdeploy-echo.

   

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 il cluster GKE o il servizio Cloud Run:

   GKE

   gcloud container clusters delete deploy-hooks-cluster --region=us-central1 --project=PROJECT_ID
   

   Cloud Run

   gcloud run services delete my-hooks-run-service --region=us-central1 --project=PROJECT_ID
   

2. Elimina la pipeline di distribuzione, il target, il rilascio e l'implementazione:

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

3. Elimina i bucket Cloud Storage creati da Cloud Deploy.

   Una termina con _clouddeploy e l'altra è [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.