Utilizzare i parametri di deployment

Questa pagina mostra come utilizzare Cloud Deploy per distribuire un'applicazione di esempio a due target contemporaneamente (un deployment parallelo), passando un valore parametro diverso a ogni manifest o definizione di servizio sottoposto a rendering, utilizzando tre metodi diversi.

In questa guida rapida, imparerai a:

Creare due cluster GKE o due servizi Cloud Run.

Puoi utilizzare anche i cluster GKE Enterprise, ma questa guida rapida utilizza solo GKE e Cloud Run.
Creare una configurazione Skaffold e un file manifest Kubernetes o una definizione del servizio Cloud Run.

La definizione del manifest o del servizio sarà la stessa per entrambi i target figlio, ma al momento del deployment il manifest visualizzato o la definizione del servizio per ogni target figlio avrà valori diversi per i parametri specifici configurati in questa guida rapida.
Definire la pipeline di distribuzione di Cloud Deploy e i target del deployment.

Questa pipeline avrà un target multi-target, che fa riferimento a due target secondari, per eseguire la distribuzione dell'app in due cluster o due servizi.
Definisci i parametri di deployment in tre posizioni diverse:
- Nella progressione della pipeline
- Nei target figlio
- Nella riga di comando, quando crei la release
Crea un'istanza della pipeline di distribuzione creando una release, che esegue il deployment automaticamente nelle due destinazioni 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.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

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

Abilita le API

Installa Google Cloud CLI.

Per initialize gcloud CLI, esegui questo comando:

gcloud init

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

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

Abilita le API

Installa Google Cloud CLI.

Per initialize gcloud CLI, esegui questo comando:

gcloud init

Se hai già installato l'interfaccia a riga di comando, assicurati di eseguire la versione più recente:

gcloud components update

Assicurati che l'account di servizio Compute Engine predefinito abbia le autorizzazioni sufficienti.

L'account di servizio potrebbe avere già le autorizzazioni necessarie. Questi passaggi sono inclusi per i progetti che disabilitano le concessioni automatiche 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 gli ambienti di runtime

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

Per GKE, crea due cluster: deploy-params-cluster-prod1 e deploy-params-cluster-prod2, con impostazioni predefinite. Gli endpoint API Kubernetes dei cluster devono essere raggiungibili in rete dalla rete internet pubblica. I cluster GKE sono accessibili dall'esterno per impostazione predefinita.

gcloud container clusters create-auto deploy-params-cluster-prod1 \
                 --project=PROJECT_ID \
                 --region=us-central1 \
                 && gcloud container clusters create-auto deploy-params-cluster-prod2 \
                 --project=PROJECT_ID \
                 --region=us-west1

Prepara la configurazione e i manifest di Skaffold

Cloud Deploy utilizza Skaffold per fornire i dettagli su cosa eseguire il deployment e come eseguirne il deployment correttamente per i target separati.

In questa guida rapida, creerai un file skaffold.yaml che identifica il manifest di Kubernetes o la definizione del servizio Cloud Run da utilizzare per eseguire il deployment dell'app di esempio.

Apri una finestra del terminale.

Crea una nuova directory e aprila.

GKE

mkdir deploy-params-gke-quickstart
cd deploy-params-gke-quickstart

Cloud Run

mkdir deploy-params-run-quickstart
cd deploy-params-run-quickstart

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

Consulta la documentazione di riferimento di skaffold.yaml per ulteriori informazioni su questo file.

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

GKE

Crea un file denominato kubernetes.yaml, con il seguente contenuto:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
spec:
  replicas: 1 # from-param: ${replicaCount}
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
      annotations:
        commit: defaultShaValue # from-param: ${git-sha}
    spec:
      containers:
      - name: nginx
        image: my-app-image
        env:
        - name: envvar1
          value: default1 # from-param: ${application_env1}
        - name: envvar2
          value: default2 # from-param: ${application_env2}

Questo file è un semplice manifest Kubernetes, che viene applicato al cluster per eseguire 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:
  autoscaling.knative.dev/minScale: 1 # from-param: ${minInstances}
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      annotations:
        commit: defaultShaValue # from-param: ${git-sha}
    spec:
      containers:
      - image: my-app-image
        env:
        - name: envvar1
          value: defaultValue1 # from-param: ${application_env1}
        - name: envvar2
          value: defaultValue2 # from-param: ${application_env2}

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

Crea la pipeline di distribuzione e i target

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

Crea la pipeline di distribuzione e la definizione del target:

GKE

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

apiVersion: deploy.cloud.google.com/v1
kind: DeliveryPipeline
metadata:
  name: my-params-demo-app-1
description: main application pipeline
serialPipeline:
  stages:
  - targetId: params-prod-multi
    deployParameters:
    - values:
        replicaCount: "2"
      matchTargetLabels:
        label1: label1
    - values:
        replicaCount: "3"
      matchTargetLabels:
        label2: label2
---

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

apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
  name: params-prod-a
  labels:
    label1: label1
description: production cluster 1
deployParameters:
  application_env1: "sampleValue1"
gke:
  cluster: projects/PROJECT_ID/locations/us-central1/clusters/deploy-params-cluster-prod1
---

apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
  name: params-prod-b
  labels:
    label2: label2
description: production cluster 2
deployParameters:
  application_env2: "sampleValue2"
gke:
  cluster: projects/PROJECT_ID/locations/us-west1/clusters/deploy-params-cluster-prod2

Cloud Run

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

apiVersion: deploy.cloud.google.com/v1
kind: DeliveryPipeline
metadata:
  name: my-params-demo-app-1
description: main application pipeline
serialPipeline:
  stages:
  - targetId: params-prod-multi
    deployParameters:
    - values:
        minInstances: "2"
      matchTargetLabels:
        label1: label1
    - values:
        minInstances: "3"
      matchTargetLabels:
        label2: label2
---

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

apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
  name: params-prod-a
  labels:
    label1: label1
description: production cluster 1
deployParameters:
  application_env1: "sampleValue1"
run:
  location: projects/PROJECT_ID/locations/us-central1
---

apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
  name: params-prod-b
  labels:
    label2: label2
description: production cluster 2
deployParameters:
  application_env2: "sampleValue2"
run:
  location: projects/PROJECT_ID/locations/us-west1

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 multi-target che comprende due destinazioni GKE o Cloud Run, pronta per il deployment dell'applicazione.
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. Nota che c'è un solo target elencato nella colonna Destinazioni anche se hai configurato tre target (uno multi-target e due secondari) nel tuo file clouddeploy.yaml.

Nota che l'unico target elencato è il target params-prod-multi. I target secondari non vengono mostrati.

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 quella release. Per i dettagli sul ciclo di vita, consulta Architettura del servizio Cloud Deploy.

GKE

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

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

Cloud Run

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

 gcloud deploy releases create test-release-001 \
   --project=PROJECT_ID \
   --region=us-central1 \
   --delivery-pipeline=my-params-demo-app-1 \
   --images=my-app-image=us-docker.pkg.dev/cloudrun/container/hello@sha256:6063adf8f687702b4065151acddba6781c47bc602167eb9f3bec8aebc9ce95cc \
   --deploy-parameters="git-sha=f787cac"

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

Visualizza i risultati nella console Google Cloud

Ora che hai creato la release e hai creato l'implementazione del controller e le implementazioni figlio, il deployment di queste implementazioni figlio viene eseguito (o è in corso il deployment) nei rispettivi cluster GKE o servizi Cloud Run.

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

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

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

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

Le implementazioni vengono visualizzate in Implementazioni. Puoi fare clic su un'implementazione per visualizzarne i dettagli, incluso il log di deployment.
In Dettagli sulla release, seleziona la scheda Artefatti.

La tabella Parametri di deployment elenca tutti i parametri configurati nel manifest e i valori forniti per tali parametri:

GKE

Cloud Run

Oltre ai parametri e ai valori, la tabella mostra a quale target si applica ciascun parametro.
Nella colonna Release Inspector, fai clic su Visualizza elementi per entrambi i target.
Fai clic su Mostra il confronto, quindi seleziona params-prod-a per un target e params-prod-b per l'altro.

Viene visualizzata una differenza quando confronta i manifest visualizzati dei due target, inclusi i valori specificati:

GKE

Cloud Run

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 deploy-params-cluster-prod1 --region=us-central1 --project=PROJECT_ID \
&& gcloud container clusters delete deploy-params-cluster-prod2 --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 i target secondari, multi-target, pipeline di distribuzione, release e implementazioni:

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

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

È tutto. Hai completato questa guida rapida.

Passaggi successivi

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