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

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

In questa guida rapida, imparerai a:

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

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

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

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

    Questa pipeline avrà un solo target, che sarà però una più target: un target che rappresenta più di un target del deployment. Questo target multiplo sarà composto da due target effettivi, che pubblicheranno l'app nei due cluster o servizi.

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

  5. 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 disattivano la concessione automatica dei ruoli per gli account di servizio 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 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'autorizzazione actAs per 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 esegui il deployment in Cloud Run, puoi saltare questo comando.

Per GKE, crea due cluster: quickstart-cluster-qsprod1 e quickstart-cluster-qsprod2, con le impostazioni predefinite. Gli endpoint dell'API Kubernetes dei cluster devono essere raggiungibili dalla rete dall'internet pubblico. I cluster GKE sono accessibili esternamente predefinito.

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 di Skaffold e il manifest dell'applicazione

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

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

    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, crea il file. Puoi anche chiedere a Cloud Deploy di crearne 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 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

    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:
  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, 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 di questa guida rapida, creerai un singolo file.

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

    GKE

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

    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

    Tieni presente che questo file include tre target: un target multiplo e due target figli. Puoi anche configurare le destinazioni in un file separato, anziché con la tua pipeline di distribuzione.

    Tieni inoltre presente che la pipeline di distribuzione include deployParameters, con etichette e i target secondari includono etichette corrispondenti a questi parametri. Questo ti consente di trasferire valori distinti a target secondari separati, se vuoi. Scopri di più.

  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 pubblicazione

    Viene mostrata la pipeline di distribuzione appena creata. Tieni presente che nella colonna Target è elencato un 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 qsprod-multi. Bambino/a i target non vengono mostrati.

Crea una release

Una release è la risorsa centrale di Cloud Deploy che rappresenta delle modifiche implementate. 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 il seguente comando dalla directory deploy-gke-parallel-quickstart per creare una risorsa release che rappresenti l'immagine del container da 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 il seguente comando dalla directory deploy-run-parallel-quickstart per creare una risorsa release che rappresenti l'immagine del container da 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=us-docker.pkg.dev/cloudrun/container/hello@sha256:4a856b6f1c3ce723a456ddc2adfbb794cbfba93f727e2d96fcf6540bd0d6fff4 \
   --to-target=qsprod-multi

Come sempre, quando crei una release, viene creato automaticamente un rollout per il primo target della 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 "rollout del controller" per due target secondari e non sono presenti target successivi nella pipeline di distribuzione. Ciò significa che l'applicazione viene implementata ovunque al momento della creazione dell'implementazione.

Visualizza i risultati nella console Google Cloud

Ora che hai creato la release e le implementazioni del controller e secondarie, queste implementazioni secondarie vengono eseguite (o sono in fase di esecuzione) 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 pubblicazione

  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 un solo passaggio, 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 caricamento.

  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.

    implementazioni 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 secondari, release implementazioni:

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

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