Déployer une application en mode Canary sur une cible

Préparer votre configuration Skaffold et votre fichier manifeste d'application

Cloud Deploy utilise Skaffold pour fournir les détails de ce que vous devez déployer et de la manière de le déployer correctement sur votre cible.

Dans ce guide de démarrage rapide, vous allez créer un fichier skaffold.yaml, qui identifie le fichier manifeste Kubernetes ou la configuration du service Cloud Run à déployer.

1. Ouvrez une fenêtre de terminal.

2. Créez un répertoire et accédez-y.

   GKE

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

   API GKE + 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. Créez un fichier nommé skaffold.yaml avec le contenu suivant :

   GKE

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

   API GKE + 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: {}
   

   Il s'agit d'une configuration Skaffold minimale qui identifie votre fichier manifeste. Pour ce guide de démarrage rapide, vous allez créer le fichier. Vous pouvez également laisser Cloud Deploy en créer une pour vous pour les applications simples hors production.

   Pour en savoir plus sur ce fichier, consultez la documentation de référence sur skaffold.yaml.

4. Créez le fichier manifeste de votre application.

   GKE

   Créez un fichier nommé kubernetes.yaml dans le répertoire deploy-canary-quickstart-gke avec le contenu suivant:

   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
   

   Il s'agit d'un fichier manifeste Kubernetes, qui est appliqué au cluster pour déployer l'application. Ce fichier manifeste inclut les ressources de service et de déploiement requises pour le déploiement canari, ainsi qu'un HTTPRoute et la ressource Gateway nécessaire pour utiliser l'API Gateway.

   L'image de conteneur à déployer est définie ici comme un espace réservé, my-app-image, qui est remplacé par l'image spécifique lorsque vous créez la version.

   API GKE + Gateway

   Créez un fichier nommé kubernetes.yaml dans le répertoire deploy-canary-quickstart-gke-gatewayapi avec le contenu suivant:

   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
   

   Il s'agit d'un fichier manifeste Kubernetes, qui est appliqué au cluster pour déployer l'application. Ce fichier manifeste inclut les ressources de service et de déploiement requises pour le déploiement canari, ainsi qu'un HTTPRoute et la ressource Gateway nécessaire pour utiliser l'API Gateway.

   L'image de conteneur à déployer est définie ici comme un espace réservé, my-app-image, qui est remplacé par l'image spécifique lorsque vous créez la version.

   Cloud Run

   Créez un fichier nommé run.yaml dans le répertoire deploy-canary-quickstart-run avec le contenu suivant:

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

   Ce fichier est une définition de service Cloud Run de base, qui est appliquée au moment du déploiement pour créer votre service dans Cloud Run. L'image de conteneur à déployer est définie ici comme un espace réservé, my-app-image, qui est remplacé par l'image spécifique lorsque vous créez la version.

Créer votre pipeline de diffusion et vos cibles

Vous pouvez définir votre pipeline de diffusion et vos cibles dans un même fichier ou dans des fichiers distincts. Dans ce guide de démarrage rapide, nous créons un fichier pour notre pipeline et notre seule cible:

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. Enregistrez votre pipeline et vos cibles auprès du service Cloud Deploy:

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

   Vous disposez désormais d'un pipeline avec une cible configurée pour une stratégie de déploiement Canary.

2. Vérifiez votre pipeline et vos cibles:

   Dans la console Google Cloud, accédez à la page Pipelines de diffusion de Cloud Deploy pour afficher la liste de vos pipelines de diffusion disponibles.

   Ouvrir la page Pipelines de diffusion

   Le pipeline de diffusion que vous venez de créer s'affiche, et la seule cible que vous avez configurée est listée dans la colonne Cibles.

   

Créer une version

Une version est la ressource Cloud Deploy centrale qui représente les modifications déployées. Le pipeline de diffusion définit le cycle de vie de cette version. Pour en savoir plus sur ce cycle de vie, consultez la section Architecture du service Cloud Deploy.

Pour créer une ressource release représentant l'image de conteneur à déployer, exécutez la commande suivante à partir du répertoire deploy-canary-quickstart-gke, deploy-canary-quickstart-gke-gatewayapi ou deploy-canary-quickstart-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=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:4a856b6f1c3ce723a456ddc2adfbb794cbfba93f727e2d96fcf6540bd0d6fff4

Notez l'option --images=, que vous utilisez pour remplacer l'espace réservé (my-app-image) dans le fichier manifeste ou la définition de service par l'image spécifique qualifiée SHA. Google vous recommande de créer des modèles pour vos fichiers manifestes de cette manière et d'utiliser des noms d'images qualifiés par SHA lors de la création de la version.

Lorsque vous créez une version, Cloud Deploy crée également automatiquement une ressource de déploiement pour la déployer immédiatement sur votre seule cible, prod.

Nous passons à la phase stable.

Avec cette première version, nous ignorons la phase Canary et déployons à 100% (phase stable). En effet, l'application n'a pas été déployée précédemment. Il n'est donc pas possible de calculer 50% des pods (pour GKE) ni la répartition du trafic pour le service (pour Cloud Run). Les pods (GKE) ou les révisions (Cloud Run) n'existent pas encore.

Après avoir ignoré la phase Canary, nous sommes maintenant prêts à commencer la phase stable, qui porte le trafic à 100%. Ensuite, nous allons créer une autre version qui exécutera le canari.

Dans un cas concret, vous exécutez généralement un déploiement canari lorsque votre application est déjà en cours d'exécution. Par conséquent, cette phase d'élagage est rare.

Afficher la version dans la console Google Cloud

Maintenant que vous avez créé la première version, le déploiement est créé. Vous pouvez consulter la version et le déploiement dans la console Google Cloud. Vous pouvez également afficher la visualisation du pipeline, qui indique l'état actuel de la version.

1. Dans la console Google Cloud, accédez à la page Pipelines de diffusion de Cloud Deploy pour afficher votre pipeline de diffusion my-canary-demo-app-1.

   Ouvrir la page Pipelines de diffusion

2. Cliquez sur le nom de votre pipeline de diffusion "my-canary-demo-app-1".

   La visualisation du pipeline indique l'état de déploiement de l'application. Comme il n'y a qu'une seule étape dans le pipeline, la visualisation n'affiche qu'un seul nœud.

   

   Votre version est répertoriée dans l'onglet Versions sous Détails du pipeline de diffusion.

3. Cliquez sur le nom de la version, test-release-001.

   Vos déploiements s'affichent sous Déploiements. Vous pouvez cliquer sur un déploiement pour afficher ses détails, y compris le journal de déploiement.

   

   Notez que l'état de déploiement est "En attente de progression" et que la cible affichée dans la visualisation du pipeline comporte un lien vers "Passer à la version stable".

Avancer la phase de déploiement

Après la première version, la phase Canary a été ignorée, et le déploiement attend le début de la phase "stable", qui déploie l'application à 100%:

1. Dans la visualisation du pipeline, cliquez sur Passer à la version stable.

2. Lorsque vous y êtes invité, cliquez sur Advance pour confirmer.

Après quelques minutes, le déploiement est maintenant en phase "stable" et l'application est déployée à 100%.

Exécuter le déploiement Canary

Étant donné que la première version a sauté la phase Canary, nous allons maintenant créer une autre version, qui exécute cette fois un déploiement Canary.

1. Pour créer un release, exécutez la commande suivante à partir du répertoire deploy-canary-quickstart-gke, deploy-canary-quickstart-gke-gatewayapi ou 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
   

   Après quelques minutes, un déploiement est créé, et cette fois, la phase Canary est exécutée:

   

   Une fois la première phase de déploiement terminée, le déploiement passe à la phase Canary:

   

   Cela signifie que l'application est désormais déployée à 50%. Pour GKE basé sur serviceNetworking, il est déployé sur la moitié de vos pods. Pour le trafic GKE et Cloud Run basé sur l'API Gateway, 50 % est alloué.

2. Cliquez sur Démarrer le déploiement, puis sur Continuer lorsque vous y êtes invité.

   Le déploiement passe alors à la phase "stable", déployant l'application à 100%.