Esegui il deployment di un'app in più destinazioni contemporaneamente

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

In questa guida rapida, imparerai a:

  1. Creare due cluster GKE o due servizi Cloud Run.

    Puoi eseguire il deployment in parallelo anche ai cluster GKE Enterprise, ma questa guida rapida utilizza solo GKE e Cloud Run.

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

  3. Definire la pipeline di distribuzione di Cloud Deploy e i target di deployment.

    Questa pipeline avrà un solo target, che sarà però un target multiplo, ovvero che rappresenta più destinazioni per il deployment. Questo target multiplo includerà due target effettivi, in modo da distribuire la tua app nei due cluster o servizi.

  4. Crea l'istanza della tua pipeline di distribuzione creando una release, che esegue automaticamente il deployment in parallelo delle due destinazioni.

  5. Visualizza l'"implementazione del controller" e le implementazioni secondarie nella console Google Cloud.

Prima di iniziare

  1. 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.
  2. Nella console di Google Cloud Console, nella pagina del selettore dei progetti, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

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

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

    Abilita le API

  5. Installa Google Cloud CLI.
  6. Per initialize gcloud CLI, esegui questo comando:

    gcloud init
  7. Nella console di Google Cloud Console, nella pagina del selettore dei progetti, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

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

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

    Abilita le API

  10. Installa Google Cloud CLI.
  11. Per initialize gcloud CLI, esegui questo comando:

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

    gcloud components update
    

  13. Assicurati che l'account di servizio Compute Engine predefinito disponga di autorizzazioni sufficienti.

    L'account di servizio potrebbe già disporre delle autorizzazioni necessarie. Questi passaggi sono inclusi per i progetti che disattivano le concessioni automatiche dei ruoli per gli account di servizio predefiniti.

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

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

    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 in Cloud Run, puoi saltare questo comando.

Per GKE, crea due cluster: quickstart-cluster-qsprod1 e quickstart-cluster-qsprod2, 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 quickstart-cluster-qsprod1 \
                 --project=PROJECT_ID \
                 --region=us-central1 \
                 && gcloud container clusters create-auto quickstart-cluster-qsprod2 \
                 --project=PROJECT_ID \
                 --region=us-west1

Prepara il manifest della configurazione e dell'applicazione Skaffold

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

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

  1. Apri una finestra del terminale.

  2. Crea una nuova directory e aprila.

    GKE

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

    Cloud Run

    mkdir deploy-run-parallel-quickstart
    cd deploy-run-parallel-quickstart
    
  3. Crea un file denominato skaffold.yaml con il seguente contenuto:

    GKE

    apiVersion: skaffold/v4beta1
    kind: Config
    manifests:
      rawYaml:
      - k8s-deployment.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 Cloud Deploy di crearne uno per te, per applicazioni semplici non di produzione.

    Consulta il riferimento skaffold.yaml per ulteriori informazioni su questo file.

  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-deployment.yaml con il seguente contenuto:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: my-deployment
      labels:
        app: my-app
      namespace: default
    spec:
      replicas: 1 # from-param: ${replicaCount}
      selector:
        matchLabels:
          app: my-app
      template:
        metadata:
          labels:
            app: my-app
        spec:
          containers:
          - name: nginx
            image: my-app-image
    

    Si tratta di un semplice manifest di 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:
        metadata:
          annotations:
            autoscaling.knative.dev/minScale: 1 # from-param: ${minInstances}
        spec:
          containers:
          - image: my-app-image
    

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

Crea i target e la pipeline di distribuzione

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

  1. Crea la pipeline di distribuzione e la definizione dei target:

    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: []
        deployParameters:
        - values:
            replicaCount: "1"
          matchTargetLabels:
            label1: label1
        - values:
            replicaCount: "2"
          matchTargetLabels:
            label2: label2
    ---
    
    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
      labels:
        label1: label1
    description: production cluster 2
    gke:
      cluster: projects/PROJECT_ID/locations/us-central1/clusters/quickstart-cluster-qsprod1
    ---
    
    apiVersion: deploy.cloud.google.com/v1
    kind: Target
    metadata:
      name: qsprod-b
      labels:
        label2: label2
    description: production cluster 3
    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: []
        deployParameters:
        - values:
            minInstances: "2"
          matchTargetLabels:
            label1: label1
        - values:
            minInstances: "3"
          matchTargetLabels:
            label2: label2
    ---
    
    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
      labels:
        label1: label1
    description: production us-central1
    run:
      location: projects/PROJECT_ID/locations/us-central1
    ---
    
    apiVersion: deploy.cloud.google.com/v1
    kind: Target
    metadata:
      name: qsprod-b
      labels:
        label2: label2
    description: production us-west1
    run:
      location: projects/PROJECT_ID/locations/us-west1
    

    Nota che questo file include tre destinazioni: una con target multiplo e due target secondari. Puoi anche configurare i target in un file separato, anziché nella tua pipeline di distribuzione.

    Nota inoltre che la pipeline di distribuzione include deployParameters, con etichette, e i target figlio includono etichette per corrispondere a questi parametri. In questo modo, puoi passare valori separati a target secondari separati, se vuoi. Scopri di più.

  2. Registra la tua pipeline e i tuoi 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 composto da due destinazioni GKE o Cloud Run, pronta per il deployment dell'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 appena creata. Tieni presente che è presente un solo target nella colonna Destinazioni anche se hai configurato tre target (un target multiplo e due target secondari) nel file clouddeploy.yaml.

    visualizzazione della pipeline di distribuzione nella console Google Cloud

    Nota che l'unico target elencato è il target multiplo qsprod-multi. I target figlio non vengono mostrati.

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 di quella release. Consulta Architettura del servizio Cloud Deploy per i dettagli su quel ciclo di vita.

GKE

Esegui questo comando dalla directory deploy-gke-parallel-quickstart per creare una risorsa release che rappresenti 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/google-containers/nginx@sha256:f49a843c290594dcf4d193535d1f4ba8af7d56cea2cf79d1e9554f077f1e7aaa \
   --to-target=qsprod-multi

Cloud Run

Esegui questo comando dalla directory deploy-run-parallel-quickstart per creare una risorsa release che rappresenti 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@sha256:7c0aeb55b25b12c656ad0856b13126ca0346c16dc631d9d7fa9dc335dd4a05df \
   --to-target=qsprod-multi

Come sempre, quando crei una release, viene creata automaticamente un'implementazione per la prima destinazione nella pipeline (o, come in questo caso, per un target specifico specificato utilizzando --to-target=). In questa guida rapida, si tratta di un target multiplo, quindi rollout è un'implementazione del controller per due target secondari e non esistono destinazioni successive 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 che hai creato l'implementazione del controller e delle implementazioni secondarie, il deployment di queste implementazioni secondarie viene eseguito (o è in corso 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 prevede una sola fase, la visualizzazione mostra solo un nodo.

    visualizzazione della pipeline di distribuzione nella console Google Cloud

    La tua release è elencata nella scheda Release in Dettagli della pipeline di pubblicazione.

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

    lanci nella console Google Cloud

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 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
    
  2. Elimina pipeline di distribuzione, target multipli, target figlio, release e implementazioni:

    gcloud deploy delete --file=clouddeploy.yaml --force --region=us-central1 --project=PROJECT_ID
    
  3. Elimina i bucket Cloud Storage creati da Cloud Deploy.

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

    Apri la pagina del browser di Cloud Storage

È tutto. Hai completato questa guida rapida.

Passaggi successivi