Eseguire il deployment canary di un'applicazione in una destinazione

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 creerai un file skaffold.yaml, che identifica le il manifest di Kubernetes o la configurazione del servizio Cloud Run di cui è stato eseguito il deployment.

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 il seguente contenuto:

   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 questo rapida, devi creare il file. Ma puoi anche fai in modo che Cloud Deploy ne crei 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 il 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 strumento manifest, che viene applicato al cluster per eseguire il deployment dell'applicazione.

   GKE + API Gateway

   Crea un file denominato kubernetes.yaml nel file 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 file Kubernetes manifest, 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 è 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 distribuzione e i target in un file o in file . In questa guida rapida, creeremo un file per la pipeline e target:

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

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

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 a Cloud Deploy Pagina Pipeline di distribuzione per visualizzare l'elenco della distribuzione disponibile pipeline di dati.

   Apri la pagina Pipeline di distribuzione

   Viene mostrata la pipeline di distribuzione appena creata e quella di destinazione configurato è elencato nella colonna Destinazioni.

   

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.

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:

 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

 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

 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:6063adf8f687702b4065151acddba6781c47bc602167eb9f3bec8aebc9ce95cc

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 visualizza la release e il lancio nella console Google Cloud. Puoi inoltre visualizzare la visualizzazione della pipeline, che mostra lo stato attuale della release.

1. Nella console Google Cloud, vai a Cloud Deploy Pagina Pipeline di distribuzione per visualizzare my-canary-demo-app-1 di distribuzione dei container.

   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 del deployment dell'app. Poiché c'è in una sola fase della pipeline, la visualizzazione mostra un solo nodo.

   

   La tua release sarà elencata nella scheda Uscite della sezione Pipeline di pubblicazione dettagli.

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.

   

   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 lo "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 Avanza per confermare.

Dopo alcuni minuti, l'implementazione è ora "stabile" fase di sviluppo e la del deployment dell'applicazione al 100%.

Esegui il deployment canary

Poiché la prima release ha saltato la fase canary, Ora creeremo un'altra release, che questa volta esegue una versione canary e deployment continuo.

1. Per creare un nuovo release, esegui questo comando dal deploy-canary-quickstart-gke, deploy-canary-quickstart-gke-gatewayapi o Directory 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:6063adf8f687702b4065151acddba6781c47bc602167eb9f3bec8aebc9ce95cc
   

   Dopo alcuni minuti viene creata un'implementazione. Questa volta viene avviata la fase canary. eseguito:

   

   Al termine della prima fase, l'implementazione è quella canary:

   

   Ciò significa che viene eseguito il deployment dell'applicazione al 50%. Per basato su serviceNetworking, ne viene eseguito il deployment dei pod. Per GKE basati su API Gateway Il traffico di Cloud Run è 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%.