Guida rapida: esegui il deployment di un'app in più target contemporaneamente

Eseguire il deployment di un'app in più target contemporaneamente

Questa pagina mostra come utilizzare Google Cloud Deploy per distribuire un'applicazione di esempio a due target contemporaneamente: un deployment parallelo.

In questa guida rapida, procedi come segue:

Creare due cluster GKE o due servizi Cloud Run.

Puoi eseguire il deployment in parallelo anche ai cluster Anthos, ma questa guida rapida utilizza solo GKE e Cloud Run.
Creare una configurazione Skaffold e un manifest Kubernetes o una definizione del servizio Cloud Run.
Definire la pipeline di distribuzione e i target di deployment di Google Cloud Deploy.

Questa pipeline avrà un solo target, ma sarà un target multiplo, che rappresenta più di un target di deployment. Questo target multiplo comprenderà due target effettivi, ovvero la tua app verrà pubblicata nei due cluster o servizi.
Crea un'istanza della tua pipeline di distribuzione creando una release che esegua automaticamente il deployment nei due target in parallelo.
Visualizza "l'implementazione del controller" e le implementazioni secondarie nella console Google Cloud.

Prima di iniziare

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.

Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

Abilita le API Google Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage.

Abilita le API

Installa Google Cloud CLI.

Per inizializzare l'interfaccia a riga di comando gcloud, esegui il comando seguente:

gcloud init

Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

Abilita le API Google Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage.

Abilita le API

Installa Google Cloud CLI.

Per inizializzare l'interfaccia a riga di comando gcloud, esegui il comando seguente:

gcloud init

Se hai già installato l'interfaccia a riga di comando, assicurati di eseguire l'ultima versione:

gcloud components update

Assicurati che l'account di servizio Compute Engine predefinito abbia le 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.

Innanzitutto, aggiungi 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"

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)")-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"

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

Crea i tuoi ambienti di runtime

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

Per GKE, crea due cluster: quickstart-cluster-qsprod1 e quickstart-cluster-qsprod2, con impostazioni predefinite. Gli endpoint dell'API Kubernetes dei cluster devono essere raggiungibili dalla rete dalla rete Internet pubblica. I cluster GKE sono accessibili esternamente per impostazione predefinita.

gcloud container clusters create-auto quickstart-cluster-qsprod1 \
                 --project=PROJECT_ID \
                 --region=us-central1 \
                 && gcloud container clusters create-auto quickstart-cluster-qsprod2 \
                 --project=PROJECT_ID \
                 --region=us-west1

Prepara la configurazione Skaffold e il manifest Kubernetes

Google Cloud Deploy utilizza Skaffold per fornire i dettagli relativi agli elementi di cui eseguire il deployment e al modo corretto per i target separati.

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

Apri una finestra del terminale.

Crea una nuova directory e accedi alla directory.

GKE

mkdir deploy-gke-parallel-quickstart
cd deploy-gke-parallel-quickstart

Cloud Run

mkdir deploy-run-parallel-quickstart
cd deploy-run-parallel-quickstart

Crea un file denominato skaffold.yaml con il seguente contenuto:
GKE
```
apiVersion: skaffold/v4beta1
kind: Config
manifests:
  rawYaml:
  - k8s-pod.yaml
deploy:
  kubectl: {}
```
Cloud Run
```
apiVersion: skaffold/v4beta1
kind: Config
manifests:
  rawYaml:
  - service.yaml
deploy:
  cloudrun: {}
```
Questo file è una configurazione Skaffold minima. Per questa guida rapida, devi creare il file. Tuttavia, puoi anche chiedere a Google Cloud Deploy di crearne uno per te, per applicazioni semplici e non di produzione.

Per ulteriori informazioni su questo file, consulta il riferimento skaffold.yaml.
Crea la definizione della tua applicazione, ovvero la definizione di un 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: getting-started
spec:
  containers:
  - name: echoserver
    image: my-app-image
```
Questo file è un semplice manifest 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-parallel-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 servizio Cloud Run.

Crea la pipeline e i target di distribuzione

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

Crea la pipeline di distribuzione e la definizione della destinazione:

GKE

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

apiVersion: deploy.cloud.google.com/v1
kind: DeliveryPipeline
metadata:
 name: my-parallel-demo-app-1
description: main application pipeline
serialPipeline:
 stages:
 - targetId: qsprod-multi
   profiles: []
---

apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
 name: qsprod-multi
description: production clusters
multiTarget:
 targetIds: [qsprod-a, qsprod-b]
---

apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
 name: qsprod-a
description: production cluster 1
gke:
 cluster: projects/PROJECT_ID/locations/us-central1/clusters/quickstart-cluster-qsprod1
---

apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
 name: qsprod-b
description: production cluster 2
gke:
 cluster: projects/PROJECT_ID/locations/us-west1/clusters/quickstart-cluster-qsprod2

Cloud Run

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

apiVersion: deploy.cloud.google.com/v1
kind: DeliveryPipeline
metadata:
 name: my-parallel-demo-app-1
description: main application pipeline
serialPipeline:
 stages:
 - targetId: qsprod-multi
   profiles: []
---

apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
 name: qsprod-multi
description: production
multiTarget:
 targetIds: [qsprod-a, qsprod-b]
---

apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
 name: qsprod-a
description: production us-central1
run:
 location: projects/PROJECT_ID/locations/us-central1
---

apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
 name: qsprod-b
description: production us-west1
run:
 location: projects/PROJECT_ID/locations/us-west1

Registra la pipeline e le destinazioni con il servizio Google Cloud Deploy:
```
gcloud deploy apply --file=clouddeploy.yaml --region=us-central1 --project=PROJECT_ID
```
Ora hai una pipeline, con un target multiplo che comprende due target GKE o Cloud Run, pronti per il deployment dell'applicazione.
Conferma la pipeline e le destinazioni:

Nella console Google Cloud, vai alla pagina Pipeline di distribuzione di Google Cloud Deploy per visualizzare l'elenco delle tue pipeline di distribuzione disponibili.

Apri la pagina Pipeline di distribuzione

Viene mostrata la pipeline di distribuzione appena creata. Tieni presente che nella colonna Destinazioni è indicato un target, anche se hai configurato tre target (un target multiplo e due target secondari) nel file clouddeploy.yaml.

Tieni presente che l'unico target elencato è il qsprod-multi multitarget. I target secondari non vengono mostrati.

Crea una release

Una release è la risorsa centrale di Google Cloud Deploy che rappresenta le modifiche di cui viene eseguito il deployment. La pipeline di distribuzione definisce il ciclo di vita di quella release. Per i dettagli sul ciclo di vita, consulta Architettura del servizio Google Cloud Deploy.

GKE

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

 gcloud deploy releases create test-release-001 \
   --project=PROJECT_ID \
   --region=us-central1 \
   --delivery-pipeline=my-parallel-demo-app-1 \
   --images=my-app-image=registry.k8s.io/echoserver:1.4 \
   --to-target=qsprod-multi

Cloud Run

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

 gcloud deploy releases create test-release-001 \
   --project=PROJECT_ID \
   --region=us-central1 \
   --delivery-pipeline=my-parallel-demo-app-1 \
   --images=my-app-image=gcr.io/cloudrun/hello \
   --to-target=qsprod-multi

Come sempre, quando crei una release, viene creata automaticamente un'implementazione per il primo target nella pipeline (o, come in questo caso, per un target specifico specificato utilizzando --to-target=). In questa guida rapida, questo target è multitarget, quindi rollout è un "deployment del controller" per due target secondari e non sono presenti target nella pipeline di distribuzione. Ciò significa che il deployment dell'applicazione viene eseguito ovunque al momento della creazione.

Visualizzare i risultati nella console Google Cloud

Ora che hai creato la release, e che sono state create l'implementazione del controller e le implementazioni secondarie, il deployment delle implementazioni secondarie viene eseguito (o sta per essere eseguito) nei rispettivi cluster GKE o servizi Cloud Run.

Nella console Google Cloud, vai alla pagina Pipeline di distribuzione di Google Cloud Deploy per visualizzare la tua pipeline di distribuzione my-parallel-demo-app-1.

Apri la pagina Pipeline di distribuzione
Fai clic sul nome della tua pipeline di distribuzione "my-parallel-demo-app-1".

La visualizzazione della pipeline mostra lo stato di deployment dell'app. Poiché nella pipeline è presente una sola fase, la visualizzazione mostra un solo nodo.

La tua release è elencata nella scheda Release in Dettagli della pipeline di distribuzione.
Fai clic sul nome della release, test-release-001.

Le implementazioni vengono visualizzate nella sezione Implementazioni. Puoi fare clic su un'implementazione per visualizzarne i dettagli, incluso il log di deployment.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questa pagina, segui questi passaggi:

Elimina i cluster GKE o i servizi Cloud Run:

GKE

gcloud container clusters delete quickstart-cluster-qsprod1 --region=us-central1 --project=PROJECT_ID \
&& gcloud container clusters delete quickstart-cluster-qsprod2 --region=us-west1 --project=PROJECT_ID

Cloud Run

gcloud run services delete my-parallel-run-service --region=us-central1 --project=PROJECT_ID \
&& gcloud run services delete my-parallel-run-service --region=us-west1 --project=PROJECT_ID

Elimina la pipeline di distribuzione, il multi-target, i target secondari, il rilascio e l'implementazione:
```
gcloud deploy delete --file=clouddeploy.yaml --force --region=us-central1 --project=PROJECT_ID
```
Elimina i bucket Cloud Storage creati da Google Cloud Deploy.

Una termina con _clouddeploy e l'altra è [region].deploy-artifacts.[project].appspot.com.

Apri la pagina del browser di Cloud Storage

Ecco fatto, hai completato questa guida rapida.

Passaggi successivi

Scopri di più su come eseguire il deployment in più target contemporaneamente.
Scopri di più su Google Cloud Deploy.
Scopri le nozioni di base sul deployment delle applicazioni.
Prova la procedura dettagliata di Google Cloud Deploy.
Scopri come gestire i file manifest.
Scopri come combinare gli strumenti CI/CD di Google Cloud per sviluppare e distribuire software in modo efficace su GKE.