Eseguire il deployment canary di un'applicazione in una destinazione

Questa guida rapida mostra come utilizzare Cloud Deploy per distribuire un'applicazione di esempio in un deployment canary in Google Kubernetes Engine o in Cloud Run. Puoi anche eseguire un deployment canary su GKE Enterprise, ma in questo grafico vengono mostrati solo GKE e Cloud Run quickstart.)

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 la guida rapida esegue prima il deployment al 50% e poi al 100%.

In questa guida rapida è presente un solo target: (prod). Creiamo quindi un solo cluster GKE o servizio Cloud Run per eseguire l'applicazione.

In questa guida rapida, imparerai a:

  1. Crea un cluster GKE o definisci un Cloud Run completamente gestito di Google Cloud.

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

  2. Creare una configurazione Skaffold e un manifest Kubernetes per specifica l'immagine del container (predefinita) di cui eseguire il deployment.

  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 rilasciala nella console Google Cloud.

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

  7. Fai avanzare la release per eseguire il deployment 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 eseguire la versione più recente versione: 

    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. Ottieni 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 del controller gateway 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 niente qui.

Prepara la configurazione Skaffold e il manifest dell'applicazione

Cloud Deploy utilizza Skaffold per fornire i dettagli su cosa eseguire il deployment e come 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 aprila.

    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 le 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 nel file 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 semplice manifest Kubernetes, che viene applicato al cluster per eseguire il deployment dell'applicazione.

    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 file manifest include le risorse per il servizio e il deployment necessarie per la versione canary del deployment, più una connessione HTTPRoute e la risorsa Gateway necessarie per l'utilizzo API Gateway.

    Cloud Run

    Crea un file denominato run.yaml nel file 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 è un file di configurazione del servizio Cloud Run, che viene applicato al momento del deployment per creare il servizio in Cloud Run.

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, creeremo un file per la pipeline e target:

GKE

Crea un file denominato clouddeploy.yaml nel file 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 nel file deploy-canary-quickstart-run , 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:
          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 una destinazione configurata per un deployment canary strategia.

  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 distribuzione 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 centrale di Cloud Deploy che rappresenta delle modifiche implementate. La pipeline di distribuzione definisce il ciclo di vita della release. Consulta: Architettura del servizio Cloud Deploy per maggiori dettagli sul ciclo di vita.

Per creare una risorsa release che rappresenti l'immagine container di cui eseguire il deployment, esegui questo comando da deploy-canary-quickstart-gke, deploy-canary-quickstart-gke-gatewayapi oppure deploy-canary-quickstart-run directory:

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

Quando crei una release, Cloud Deploy crea automaticamente di implementazione, per eseguire immediatamente il deployment nell'unico target, prod.

Passiamo alla fase stabile

Con questa prima release, saltiamo la fase canary ed eseguiamo il deployment al 100% (stabile ). Il motivo è che non è stato eseguito il deployment dell'applicazione in precedenza, quindi non è possibile calcolare il 50% dei pod (per GKE) o come il traffico sia suddiviso per il servizio (per Cloud Run). I pod (GKE) o revisioni (Cloud Run) non esistono .

Abbiamo saltato la fase canary, ora possiamo iniziare la fase stabile, portando il traffico al 100%. Dopodiché creeremo un'altra release, eseguirà la versione canary.

In una situazione del mondo reale, di solito eseguirai una deployment canary dove la tua applicazione è già in esecuzione, quindi questa fase è 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 inoltre 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 distribuzione

  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é c'è in una sola fase della pipeline, 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 tra cui il log di deployment.

    implementazioni nella console Google Cloud

    Lo stato dell'implementazione è "In attesa di avanzamento", e il target mostrato la visualizzazione della pipeline ha un link "Passa a stabile".

Proseguire la 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, l'implementazione è quella canary:

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

    Ciò significa che viene eseguito il deployment dell'applicazione al 50%. Per basato su serviceNetworking, ne viene eseguito il deployment dei pod. Per GKE e Cloud Run basati sull'API Gateway, il traffico viene allocato al 50%.

  2. Fai clic su Implementazione avanzata, quindi su Avanzamento quando richiesto.

    In questo modo l'implementazione avanza al livello "stabile" di deployment dell'applicazione 100%.

    pipeline di distribuzione in fase stabile, implementata al 100%

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 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 rilascio e implementazione:

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

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

È tutto, hai completato questa guida rapida.

Passaggi successivi