Utilizzare i parametri di deployment

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

In questa guida rapida imparerai a:

  1. Crea 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.

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

    Il manifest o la definizione del servizio saranno gli stessi per entrambi i target secondari, ma al momento del deployment il manifest o la definizione del servizio sottoposti a rendering per ogni target secondario avranno valori diversi per i parametri specifici configurati in questa guida rapida.

  3. Definisci la pipeline di distribuzione e le destinazioni di deployment di Cloud Deploy.

    Questa pipeline avrà un target multiplo, che fa riferimento a due target figlio, per distribuire l'app ai due cluster o ai due servizi.

  4. Definisci i parametri di deployment in tre posizioni diverse:

    • Nella progressione della pipeline
    • Nei target figlio
    • Nella riga di comando, durante la creazione della release
  5. Crea un'istanza della pipeline di distribuzione creando una release, che viene automaticamente implementata in parallelo nei due target.

  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. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

  7. To initialize the gcloud CLI, run the following command:

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

    Go to project selector

  9. Make sure that billing is enabled for your Google Cloud project.

  10. Enable the Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage APIs.

    Enable the APIs

  11. Install the Google Cloud CLI.

  12. If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.

  13. To initialize the gcloud CLI, run the following command:

    gcloud init
  14. Se hai già installato l'interfaccia a riga di comando, assicurati di utilizzare l'ultima versione:

    gcloud components update
    

  15. Assicurati che l'account di servizio Compute Engine predefinito disponga delle autorizzazioni necessarie.

    Il account di servizio potrebbe già disporre delle autorizzazioni necessarie. Questi passaggi sono inclusi per i progetti che disattivano la concessione automatica dei ruoli per i service account predefiniti.

    1. Per prima cosa, 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"
      

    2. Aggiungi il ruolo di 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"
        

    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)")-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 esegui il deployment su 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 internet pubblica. I cluster GKE sono accessibili esternamente 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
    

Preparare la configurazione e i manifest di Skaffold

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

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

  1. Apri una finestra del terminale.

  2. Crea una nuova directory e accedi.

    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, crea il file. ma puoi anche chiedere a Cloud Deploy di crearne uno per te, per applicazioni semplici non di produzione.

    Per ulteriori informazioni su questo file, consulta il 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 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 manifest Kubernetes, che viene applicato al cluster per eseguire il deployment dell'applicazione. L'immagine container di cui eseguire il deployment è impostata qui come segnaposto, my-app-image, che viene sostituito 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-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 definizione di base del servizio Cloud Run, che viene utilizzata per eseguire il deployment dell'applicazione. L'immagine container da eseguire il deployment è impostata qui come segnaposto, my-app-image, che viene sostituito con l'immagine specifica quando crei la release.

Crea la pipeline di distribuzione e i target

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

  1. 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"
          # Apply the deploy parameter replicaCount: "2" to the target with this label
          matchTargetLabels:
            label1: label1
        - values:
            replicaCount: "3"
          # Apply the deploy parameter replicaCount: "3" to the target with this label
          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"
          # Apply the deploy parameter minInstances: "2" to the target with this label
          matchTargetLabels:
            label1: label1
        - values:
            minInstances: "3"
          # Apply the deploy parameter minInstances: "3" to the target with this label
          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 multiplo composto da due target GKE o Cloud Run, pronto per 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 visualizzata la pipeline di distribuzione che hai appena creato. Tieni presente che nella colonna Target è elencato un solo target, anche se nel file clouddeploy.yaml hai configurato tre target (un target multiplo e due target secondari).

    visualizzazione della pipeline di distribuzione nella console Google Cloud

    Tieni presente che l'unico target elencato è il target multiplo params-prod-multi. I target per bambini 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 questa release. Per informazioni dettagliate su questo 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 container da 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"

Nota il flag --images=, che utilizzi per sostituire il segnaposto (my-app-image) nel manifest con l'immagine specifica qualificata con 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 questo comando dalla directory deploy-run-parallel-quickstart per creare una risorsa release che rappresenti l'immagine container da 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:95ade4b17adcd07623b0a0c68359e344fe54e65d0cb01b989e24c39f2fcd296a \
   --deploy-parameters="git-sha=f787cac"

Nota il flag --images=, che utilizzi per sostituire il segnaposto (my-app-image) nella definizione del servizio con l'immagine specifica qualificata con 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 sempre, quando crei una release, viene creata automaticamente un'implementazione per il primo target della pipeline (a meno che non venga specificato un target specifico utilizzando --to-target=). In questa guida rapida, questo target è un target multiplo, quindi rollout è un'implementazione del controller per due target secondari e non sono presenti target successivi nella pipeline di distribuzione. Ciò significa che la tua applicazione viene implementata ovunque al momento della creazione del lancio.

Visualizza i risultati nella console Google Cloud

Ora che hai creato la release e le implementazioni del controller e figlio, queste implementazioni figlio vengono ora sottoposte a deployment (o sono in fase di deployment) nei rispettivi cluster GKE o servizi Cloud Run.

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

  2. 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é la pipeline contiene una sola fase, la visualizzazione mostra un solo nodo.

    visualizzazione della pipeline di distribuzione nella console Google Cloud

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

  3. Fai clic sul nome della release, test-release-001.

    I rollout vengono visualizzati nella sezione Rollout. Puoi fare clic su un rollout per visualizzarne i dettagli, incluso il log di implementazione.

    implementazioni nella console Google Cloud

  4. Nella sezione Dettagli release, seleziona la scheda Artefatti.

    La tabella Parametri di deployment elenca tutti i parametri che hai configurato nel manifest e i valori che hai fornito per questi parametri:

    GKE

    i parametri di deployment e
i valori visualizzati nella console Google Cloud

    Cloud Run

    i parametri di deployment e
i valori visualizzati nella console Google Cloud

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

  5. Nella colonna Strumento di controllo delle release, fai clic su Visualizza artefatti per la destinazione.

  6. Fai clic su Mostra diff, poi seleziona params-prod-a per un target e params-prod-b per l'altro.

    Viene mostrato un diff che confronta i manifest sottoposti a rendering dei due target, inclusi i valori specificati:

    GKE

    Differenza tra i manifest sottoposti a rendering, con i valori passati

    Cloud Run

    Un manifest sottoposto a rendering specifico per la destinazione, con i valori trasmessi

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 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
    
  2. Elimina la pipeline di distribuzione, il target multiplo, i target secondari, la release e le 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

Ecco fatto, hai completato questa guida rapida.

Passaggi successivi