Utilizza i parametri di deployment

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

In questa guida rapida imparerai a:

  1. Crea due cluster GKE o due Cloud Run i servizi di machine learning.

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

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

    La definizione del manifest o del servizio sarà la stessa per entrambi destinazioni 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.

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

    Questa pipeline avrà un target multiplo che fa riferimento a due target figli per caricare la tua app nei due cluster o nei due servizi.

  4. Definisci i parametri di deployment in tre diversi luoghi:

    • Nella progressione della pipeline
    • Nei target secondari
    • Nella riga di comando, durante la creazione della release

  5. Esegui l'inizializzazione della pipeline di distribuzione creando una release, che viene eseguita automaticamente su entrambi i target in parallelo.

  6. Visualizza l'"implementazione del controller" e le implementazioni secondarie 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.

    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

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

    3. Aggiungi il ruolo iam.serviceAccountUser, che include l'actAsautorizzazione per eseguire 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: deploy-params-cluster-prod1 e deploy-params-cluster-prod2, con le impostazioni predefinite. Gli endpoint API Kubernetes dei cluster devono essere raggiungibili dalla 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 su come eseguirlo correttamente per i singoli target.

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

  1. Apri una finestra del terminale.

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

  3. 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, creerai . Ma puoi anche fai in modo che Cloud Deploy ne crei uno per te, per applicazioni semplici non di produzione.

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

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

    GKE

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

    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 di servizio Cloud Run, che viene utilizzato al momento del deployment per creare Cloud Run completamente gestito di Google Cloud.

Crea la pipeline di distribuzione e i target

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

  1. Crea la pipeline di distribuzione e la definizione della destinazione:

    GKE

    Nella directory deploy-params-gke-quickstart, crea un nuovo file: clouddeploy.yaml, con i seguenti contenuti:

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

    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

  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. Nota che c'è uno target elencato nella colonna Destinazioni anche se hai configurato tre (un target multiplo e due secondari) in clouddeploy.yaml .

    Visualizzazione della pipeline di distribuzione nella console Google Cloud

    Tieni presente che l'unico target elencato è il target multiplo params-prod-multi. I target secondari non vengono visualizzati.

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

GKE

Esegui questo comando dal comando deploy-gke-parallel-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-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 dall'deploy-run-parallel-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-params-demo-app-1 \
   --images=my-app-image=us-docker.pkg.dev/cloudrun/container/hello@sha256:4a856b6f1c3ce723a456ddc2adfbb794cbfba93f727e2d96fcf6540bd0d6fff4 \
   --deploy-parameters="git-sha=f787cac"

Come sempre, quando crei una release, viene creata automaticamente un'implementazione per primo target nella pipeline (a meno che non venga specificato un target specifico --to-target=). In questa guida rapida, questo target è un multi-target, quindi rollout è un'implementazione responsabile per due 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, l'implementazione del controller e le implementazioni secondarie, a questo punto viene eseguito il deployment (oppure di deployment) nei rispettivi cluster GKE o Cloud Run.

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

    Apri la pagina Pipeline di pubblicazione

  2. Fai clic sul nome della pipeline di distribuzione "my-parallel-demo-app-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.

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

    le implementazioni nella console Google Cloud

  4. In Dettagli sulla release, seleziona la scheda Artefatti.

    La tabella Deployment di parametri elenca tutti i parametri configurati in il file manifest e i valori forniti per tali parametri:

    GKE

    i parametri di deployment valori mostrati nella console Google Cloud

    Cloud Run

    parametri di deployment e valori mostrati nella console Google Cloud

    Oltre ai parametri e ai valori, la tabella mostra quale target a cui si applica.

  5. Nella colonna Controllo release, fai clic su Visualizza artefatti per target.

  6. Fai clic su Mostra il confronto, quindi seleziona params-prod-a per un target params-prod-b per l'altro.

    Viene mostrata una differenza, confrontando i manifest sottoposti a rendering dei due target, inclusi i valori specificati:

    GKE

    diff dei manifest visualizzati, con i valori passati

    Cloud Run

    Un manifest sottoposto a rendering specifico per il target, con i valori trasmessi

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi per le risorse utilizzate in questa pagina, segui questi passaggi.

  1. Elimina i cluster GKE o Cloud Run. Google Cloud:

    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

  2. Elimina pipeline di distribuzione, target multipli, target secondari, release implementazioni:

    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