Esegui il deployment canary di un'applicazione in un target

Questa guida rapida mostra come utilizzare Cloud Deploy per fornire un'immagine di applicazione di esempio in un deployment canary in Google Kubernetes Engine o Cloud Run. Puoi anche eseguire un deployment canary in GKE Enterprise, ma in questa procedura di avvio rapido vengono mostrati solo GKE e Cloud Run.

Un deployment canary suddivide il traffico tra una versione dell'applicazione già di cui è stato eseguito il deployment e la nuova versione. Cloud Run suddivide il traffico in base alle percentuali configurate nella pipeline di distribuzione. GKE esegue il deployment della nuova versione in una proporzione di pod. Questo quickstart viene implementato prima al 50% e poi al 100%.

In questa guida rapida è presente un solo target (prod). Quindi creiamo un solo cluster GKE o un servizio Cloud Run per eseguire la tua applicazione.

In questa guida rapida imparerai a:

  1. Crea un cluster GKE o definisci un servizio Cloud Run.

    Puoi eseguire il deployment canary anche nei cluster GKE Enterprise, ma questa guida rapida utilizza solo GKE e Cloud Run.

  2. Crea una configurazione Skaffold e un manifest Kubernetes per specificare l'immagine container (pre-costruita) da eseguire.

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

  4. Richiama la pipeline di distribuzione creando una release, che viene eseguita automaticamente su un target.

    Questa prima release salta la fase canary.

  5. Visualizza la pipeline di distribuzione e la release nella console Google Cloud.

  6. Crea una seconda release, questa volta eseguendo la fase canary per eseguire il deployment dell'applicazione al 50%.

  7. Fai avanzare la release da implementare al 100%.

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 utilizzare la versione più recente: 

    gcloud components update

  12. Assicurati che l'account di servizio Compute Engine predefinito abbia 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. 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 e GKE con l'API Gateway: 

        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 l'ambiente di runtime

GKE

Crea un cluster GKE Autopilot:

 gcloud container clusters create-auto canary-quickstart-cluster \
                  --project=PROJECT_ID \
                  --region=us-central1

GKE + API Gateway

  1. Crea un cluster GKE con le impostazioni consigliate per supportarne l'utilizzo con Istio:

    gcloud container clusters create canary-quickstart-cluster \
       --machine-type=n1-standard-1 \
       --num-nodes 4 \
       --region=us-central1 \
       --project=PROJECT_ID

  2. Recupera le credenziali del cluster:

    gcloud container clusters get-credentials canary-quickstart-cluster \
       --project=PROJECT_ID \
       --region=us-central1

  3. Installa i CRD dell'API Kubernetes Gateway, se non sono già presenti nel cluster.

    kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v0.6.2/standard-install.yaml

  4. Abilita l'implementazione di Gateway Controller di Istio installando Istio.

    curl -L https://istio.io/downloadIstio | ISTIO_VERSION=1.17.2 sh - \
&& ./istio-1.17.2/bin/istioctl install --set profile=minimal -y

Cloud Run

Se utilizzi Cloud Run, puoi saltare questo comando, non devi fare nulla qui.

Prepara la configurazione di Skaffold e il manifest dell'applicazione

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

In questa guida rapida, crei un file skaffold.yaml che identifica il manifest Kubernetes o la configurazione del servizio Cloud Run da eseguire.

  1. Apri una finestra del terminale.

  2. Crea una nuova directory e accedivi.

    GKE 

    mkdir deploy-canary-quickstart-gke
cd deploy-canary-quickstart-gke

    GKE + API Gateway 

    mkdir deploy-canary-quickstart-gke-gatewayapi
cd deploy-canary-quickstart-gke-gatewayapi

    Cloud Run 

    mkdir deploy-canary-quickstart-run
cd deploy-canary-quickstart-run

  3. Crea un file denominato skaffold.yaml con i seguenti contenuti:

    GKE 

    apiVersion: skaffold/v4beta7
kind: Config
manifests:
  rawYaml:
  - kubernetes.yaml
deploy:
  kubectl: {}

    GKE + API Gateway 

    apiVersion: skaffold/v4beta7
kind: Config
manifests:
  rawYaml:
  - kubernetes.yaml
deploy:
  kubectl: {}

    Cloud Run 

    apiVersion: skaffold/v4beta7
kind: Config
manifests:
  rawYaml:
  - run.yaml
deploy:
  cloudrun: {}

    Questo file è una configurazione Skaffold minima che identifica il manifest. Per questa guida rapida, devi creare il file. Puoi anche chiedere a Cloud Deploy di crearne uno per te per applicazioni semplici non di produzione.

    Per ulteriori informazioni su questo file, consulta le informazioni di riferimento su skaffold.yaml.

  4. Crea il file manifest dell'applicazione.

    GKE

    Crea un file denominato kubernetes.yaml nella directory deploy-canary-quickstart-gke con il seguente contenuto:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
  labels:
    app: my-app
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: nginx
        image: my-app-image
---
apiVersion: v1
kind: Service
metadata:
  name: my-service
  namespace: default
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80

    Questo file è un manifest Kubernetes, che viene applicato al cluster per eseguire il deployment dell'applicazione. Questo manifest include le risorse Service e Deployment necessarie per il deployment canary, oltre a un percorso HTTP e la risorsa Gateway necessaria per l'utilizzo dell'API Gateway.

    L'immagine del contenitore da eseguire il deployment è impostata qui come segnaposto, my-app-image, che viene sostituita con l'immagine specifica quando crei la release.

    GKE + API Gateway

    Crea un file denominato kubernetes.yaml nella directory deploy-canary-quickstart-gke-gatewayapi con il seguente contenuto:

    kind: Gateway
apiVersion: gateway.networking.k8s.io/v1beta1
metadata:
  name: my-gateway
  annotations:
    networking.istio.io/service-type: "ClusterIP"
spec:
  gatewayClassName: istio
  listeners:
  - name: default
    hostname: "*.example.com"
    port: 80
    protocol: HTTP
    allowedRoutes:
      namespaces:
        from: All
---
kind: HTTPRoute
apiVersion: gateway.networking.k8s.io/v1beta1
metadata:
  name: my-httproute
spec:
  parentRefs:
  - kind: Gateway
    name: my-gateway
  hostnames:
  - "test.example.com"
  rules:
  - backendRefs:
    - name: my-service
      port: 80
---
apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: my-app
  ports:
  - name: tcp-port
    protocol: TCP
    port: 80
    targetPort: 8080
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
  labels:
    app: my-app
spec:
  replicas: 1
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: nginx
        image: my-app-image

    Questo file è un manifest Kubernetes, che viene applicato al cluster per eseguire il deployment dell'applicazione. Questo manifest include le risorse Service e Deployment necessarie per il deployment canary, oltre a un percorso HTTP e la risorsa Gateway necessaria per l'utilizzo dell'API Gateway.

    L'immagine del contenitore da eseguire il deployment è impostata qui come segnaposto, my-app-image, che viene sostituita con l'immagine specifica quando crei la release.

    Cloud Run

    Crea un file denominato run.yaml nella directory deploy-canary-quickstart-run con il seguente contenuto:

    apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: my-canary-run-service
spec:
  template:
    spec:
      containers:
      - image: my-app-image

    Questo file è una definizione di servizio Cloud Run di base, che viene applicata al momento del deployment per creare il servizio in Cloud Run. L'immagine del contenitore di cui 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 di importazione e i target in un file o in file distinti. In questa guida rapida, creiamo un file per la pipeline e un singolo target:

GKE

Crea un file denominato clouddeploy.yaml nella directory deploy-canary-quickstart-gke con il seguente contenuto:

apiVersion: deploy.cloud.google.com/v1
kind: DeliveryPipeline
metadata:
  name: my-canary-demo-app-1
description: main application pipeline
serialPipeline:
  stages:
  - targetId: prod
    profiles: []
    strategy:
      canary:
        runtimeConfig:
          kubernetes:
            serviceNetworking:
              service: "my-service"
              deployment: "my-deployment"
        canaryDeployment:
          percentages: [50]
          verify: false
---
apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
  name: prod
description: prod GKE cluster
gke:
 cluster: projects/PROJECT_ID/locations/us-central1/clusters/canary-quickstart-cluster

GKE + API Gateway

Crea un file denominato clouddeploy.yaml nella directory deploy-canary-quickstart-gke-gatewayapi con il seguente contenuto:

apiVersion: deploy.cloud.google.com/v1
kind: DeliveryPipeline
metadata:
  name: my-canary-demo-app-1
description: main application pipeline
serialPipeline:
  stages:
  - targetId: prod
    profiles: []
    strategy:
      canary:
        runtimeConfig:
          kubernetes:
            gatewayServiceMesh:
              httpRoute: "my-httproute"
              service: "my-service"
              deployment: "my-deployment"
        canaryDeployment:
          percentages: [50]
          verify: false
---
apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
  name: prod
description: prod GKE cluster
gke:
 cluster: projects/PROJECT_ID/locations/us-central1/clusters/canary-quickstart-cluster

Cloud Run

Crea un file denominato clouddeploy.yaml nella directory deploy-canary-quickstart-run con i seguenti contenuti:

apiVersion: deploy.cloud.google.com/v1
kind: DeliveryPipeline
metadata:
  name: my-canary-demo-app-1
description: main application pipeline
serialPipeline:
  stages:
  - targetId: prod
    profiles: []
    strategy:
      canary:
        runtimeConfig:
          cloudRun:
            automaticTrafficControl: true
        canaryDeployment:
          percentages: [50]
          verify: false
---
apiVersion: deploy.cloud.google.com/v1
kind: Target
metadata:
  name: prod
description: prod Run Service
run:
  location: projects/PROJECT_ID/locations/us-central1

  1. 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 configurato per una strategia di deployment canary.

  2. 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 visualizzata la pipeline di importazione appena creata e l'unico target configurato è elencato nella colonna Target.

    Visualizzazione della pipeline di distribuzione nella console Google Cloud

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 della release. Per informazioni dettagliate sul ciclo di vita, consulta la sezione Architettura del servizio Cloud Deploy.

Per creare una risorsa release che rappresenti l'immagine del container da eseguire, esegui il seguente comando dalla directory deploy-canary-quickstart-gke, deploy-canary-quickstart-gke-gatewayapi o deploy-canary-quickstart-run:

GKE 

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

GKE + API Gateway 

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

Cloud Run 

 gcloud deploy releases create test-release-001 \
   --project=PROJECT_ID \
   --region=us-central1 \
   --delivery-pipeline=my-canary-demo-app-1 \
   --images=my-app-image=us-docker.pkg.dev/cloudrun/container/hello@sha256:4a856b6f1c3ce723a456ddc2adfbb794cbfba93f727e2d96fcf6540bd0d6fff4

Nota il flag --images=, che viene utilizzato per sostituire il segnaposto (my-app-image) nel manifest o nella definizione del servizio con l'immagine specifica con qualifica SHA. Google consiglia di creare modelli per i manifest in questo modo e di utilizzare nomi di immagini qualificati con SHA al momento della creazione della release.

Quando crei una release, Cloud Deploy crea automaticamente anche una risorsa di implementazione per eseguire immediatamente il deployment nel tuo unico target, prod.

Saltiamo alla fase stabile

Con questa prima release, saltiamo la fase Canary e eseguiamo il deployment al 100% (fase stabile). Questo perché l'applicazione non è stata dispiata in precedenza, quindi non è possibile calcolare il 50% dei pod (per GKE) o come viene suddiviso il traffico per il servizio (per Cloud Run). I pod (GKE) o le revisioni (Cloud Run) non esistono ancora.

Dopo aver saltato la fase canary, siamo pronti per iniziare la fase stabile, che prevede il 100% del traffico. Dopodiché creeremo un'altra release che eseguirà il canary.

In una situazione reale, in genere esegui un deployment canary in cui l'applicazione è già in esecuzione, pertanto il salto di questa fase sarà raro.

Visualizza la release nella console Google Cloud

Ora che hai creato la prima release, l'implementazione è stata creata e puoi visualizzarla nella console Google Cloud. Puoi anche visualizzare la visualizzazione della pipeline, che mostra lo stato attuale della release.

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

    Apri la pagina Pipeline di pubblicazione

  2. Fai clic sul nome della pipeline di distribuzione "my-canary-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 uscita è elencata nella scheda Uscite in Dettagli della pipeline di distribuzione.

  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

    Tieni presente che lo stato dell'implementazione è "In attesa di avanzamento" e che il target mostrato nella visualizzazione della pipeline ha un link a "Esegui l'avanzamento alla versione stabile".

Avanzare nella fase di implementazione

Dopo la prima release, la fase canary è stata saltata e l'implementazione è in attesa di avviare la fase "stabile", che esegue il deployment dell'applicazione al 100%:

  1. Nella visualizzazione della pipeline, fai clic su Passa a stabile.

  2. Quando richiesto, fai clic su Avanti per confermare.

Dopo alcuni minuti, l'implementazione è in fase "stabile" e l'applicazione è stata implementata al 100%.

pipeline di distribuzione in fase stabile

Esegui il deployment canary

Poiché la prima release ha saltato la fase canary, ora creeremo un'altra release, che questa volta eseguirà un deployment canary.

  1. Per creare un nuovo release, esegui il comando seguente dalla directory deploy-canary-quickstart-gke, deploy-canary-quickstart-gke-gatewayapi o deploy-canary-quickstart-run:

    GKE 

    gcloud deploy releases create test-release-002 \
  --project=PROJECT_ID \
  --region=us-central1 \
  --delivery-pipeline=my-canary-demo-app-1 \
  --images=my-app-image=gcr.io/google-containers/nginx@sha256:f49a843c290594dcf4d193535d1f4ba8af7d56cea2cf79d1e9554f077f1e7aaa

    GKE + API Gateway 

    gcloud deploy releases create test-release-002 \
  --project=PROJECT_ID \
  --region=us-central1 \
  --delivery-pipeline=my-canary-demo-app-1 \
  --images=my-app-image=gcr.io/google-containers/nginx@sha256:f49a843c290594dcf4d193535d1f4ba8af7d56cea2cf79d1e9554f077f1e7aaa

    Cloud Run 

    gcloud deploy releases create test-release-002 \
  --project=PROJECT_ID \
  --region=us-central1 \
  --delivery-pipeline=my-canary-demo-app-1 \
  --images=my-app-image=us-docker.pkg.dev/cloudrun/container/hello@sha256:4a856b6f1c3ce723a456ddc2adfbb794cbfba93f727e2d96fcf6540bd0d6fff4

    Dopo alcuni minuti viene creato un rollout e questa volta viene eseguito il livello canary:

    fase iniziale della pipeline di distribuzione canary

    Al termine della prima fase di implementazione, l'implementazione passa alla fase canary:

    Visualizzazione della pipeline di distribuzione nella console Google Cloud, con l'applicazione di cui è stato eseguito il deployment al 50%

    Ciò significa che l'applicazione è ora di cui è stato eseguito il deployment per il 50%. Per GKE basato su serviceNetworking, viene eseguito il deployment su metà dei pod. Per GKE e Cloud Run basati sull'API Gateway, il traffico viene allocato al 50%.

  2. Fai clic su Implementazione avanzata e poi su Avanti quando richiesto.

    In questo modo, l'implementazione passa alla fase "stabile" e viene eseguita al 100%.

    pipeline di distribuzione in fase stabile, implementata al 100%

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 il cluster canary-quickstart-cluster (solo GKE):

    gcloud container clusters delete canary-quickstart-cluster --region=us-central1 --project=PROJECT_ID

  2. Elimina il servizio my-canary-run-service (solo Cloud Run):

    gcloud run services delete my-canary-run-service --region=us-central1 --project=PROJECT_ID

  3. Elimina la pipeline di distribuzione, la destinazione e tutte le risorse di release e implementazione:

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

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