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. Crea un cluster GKE o un servizio Cloud Run.

   Puoi utilizzare anche un cluster GKE Enterprise, ma questa procedura guidata di avvio rapido utilizza solo GKE e Cloud Run.

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

   Nel file di configurazione di Skaffold è possibile configurare l'esecuzione degli hook di deployment. Identifica un contenitore da eseguire prima del deployment e un altro da eseguire dopo il deployment.

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

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

   Questa pipeline include un solo passaggio e utilizza un solo target.

4. Crea una release, che viene implementata automaticamente nel target.

   Uno degli hook viene eseguito prima del deployment dell'applicazione e 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. 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 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"
  

3. Aggiungi il ruolo iam.serviceAccountUser, che include l'autorizzazione actAs per 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 cluster: deploy-hooks-cluster, con le impostazioni predefinite. L'endpoint API Kubernetes del cluster deve essere accessibile tramite la rete dall'internet pubblico. 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 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 nel target.

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

1. Apri una finestra del terminale.

2. Crea una nuova directory e accedivi.

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

   GKE

   apiVersion: skaffold/v4beta7
   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/v4beta7
   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:. In questo modo vengono definiti i container da eseguire prima e dopo il deployment, ovvero gli hook.

   Per ulteriori informazioni su questo file di configurazione, consulta la pagina di riferimento skaffold.yaml.

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

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

   Questo file è un manifest Kubernetes di base, che viene applicato al cluster 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

   Crea un file denominato service.yaml con i seguenti contenuti:

   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 del servizio Cloud Run, utilizzata 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.

Nota: se vuoi utilizzare manifest diversi per ogni target, consulta questo articolo sulla gestione dei manifest per scoprire di più sull'utilizzo dei profili Skaffold.

Crea la pipeline di distribuzione e il target

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

1. Crea la pipeline di distribuzione e la definizione del 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, la destinazione è inclusa nella pipeline di importazione, ma puoi definire le destinazioni in un file separato 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 di distribuzione con una destinazione pronta per eseguire il deployment della tua applicazione ed 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 pubblicazione

   Viene visualizzata la pipeline di distribuzione appena creata, con un target elencato nella colonna Target.

   

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-hooks-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=deploy-hooks-demo-app-gke-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-hooks-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=deploy-hooks-demo-app-run-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 qualifica 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.

Come per tutte le release (a meno che non includano --disable-initial-rollout), Cloud Deploy crea automaticamente anche una risorsa di implementazione. L'applicazione viene eseguita automaticamente nel target configurato per questa pipeline di importazione.

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

Visualizza i risultati nella console Google Cloud

Dopo alcuni minuti, la release viene implementata nel runtime di destinazione.

Gli hook di pre- e post-deployment che abbiamo configurato (a scopo di esempio) stampano stringhe nei log di Cloud Build. Possiamo visualizzare questi log per verificare che gli hook abbiano 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 pubblicazione

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 di deployment dell'app. Poiché la pipeline contiene un solo passaggio, la visualizzazione mostra un solo nodo.

   

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

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

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

   

   Nota textPayload. Questa stringa è stata configurata in predeploy-action nella configurazione di 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 servizio Cloud Run o il cluster GKE:

   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, la release 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.

   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.

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