Cette page a été traduite par l'API Cloud Translation.

Déployer une application sur une cible en mode Canary

Ce guide de démarrage rapide explique comment utiliser Cloud Deploy pour fournir un exemple d'application dans un déploiement Canary sur Google Kubernetes Engine ou Cloud Run. (Vous pouvez également exécuter un déploiement Canary sur GKE Enterprise, mais seuls GKE et Cloud Run y sont présentés. quickstart.)

Un déploiement Canary répartit le trafic entre une version déjà déployée du application et la nouvelle version. Cloud Run répartit le trafic en fonction des pourcentages configurés dans le pipeline de livraison. GKE déploie la nouvelle version sur une partie des pods. Ce se déploie à 50% d'abord, puis à 100%.

Dans ce guide de démarrage rapide, il n'y a qu'une seule cible (prod). Nous ne créons donc qu'un seul cluster GKE ou un seul service Cloud Run pour exécuter votre application.

Dans ce guide de démarrage rapide, vous allez :

Créez un cluster GKE ou définissez un cluster Cloud Run Google Cloud.

Vous pouvez également effectuer un déploiement Canary sur des clusters GKE Enterprise, mais ce guide de démarrage rapide utilise GKE et Cloud Run uniquement.
Créez une configuration Skaffold et un fichier manifeste Kubernetes pour spécifier l'image de conteneur (précompilée) à déployer.
Définissez votre pipeline de diffusion Cloud Deploy et votre cible de déploiement.
Appelez votre pipeline de livraison en créant une version, qui s'exécute automatiquement se déploie sur une cible.

Cette première version ignore la phase Canary.
Afficher le pipeline de livraison et la version dans la console Google Cloud
Créez une deuxième version, cette fois en exécutant l'étape Canary pour déployer l'application à 50 %.
Faites progresser la version à 100 %.

Avant de commencer

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.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage APIs.

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Make sure that billing is enabled for your Google Cloud project.

Enable the Cloud Deploy, Cloud Build, GKE, Cloud Run, and Cloud Storage APIs.

Enable the APIs

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Si la CLI est déjà installée, assurez-vous d'exécuter la dernière version version:

gcloud components update

Assurez-vous que le compte de service Compute Engine par défaut dispose des autorisations suffisantes.

Le compte de service dispose peut-être déjà des autorisations nécessaires. Ces étapes sont incluses pour les projets qui désactivent les attributions automatiques de rôles pour les comptes de service par défaut.

Commencez par ajouter le rôle 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"

Ajoutez le rôle de développeur pour votre environnement d'exécution spécifique.

Pour GKE et GKE avec 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"

Pour 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"

Ajoutez le rôle iam.serviceAccountUser, qui inclut l'autorisation actAs de déployer dans l'environnement d'exécution :

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

Créer votre environnement d'exécution

GKE

Créer un cluster GKE Autopilot cluster:

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

GKE + API Gateway

Créez un cluster GKE avec les paramètres recommandés pour l'utiliser avec Istio :

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

Obtenez les identifiants du cluster :

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

Installez les CRD de l'API Kubernetes Gateway si elles ne sont pas déjà présentes sur le cluster.

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

Activez l'implémentation du contrôleur de passerelle d'Istio en installant 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

Si vous utilisez Cloud Run, vous pouvez ignorer cette commande, vous n'avez rien à faire ici.

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.

Ouvrez une fenêtre de terminal.

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

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 cette de démarrage rapide, vous créez 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.

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

Ce fichier est un fichier Kubernetes simple manifest, qui s'applique au cluster pour déployer l'application.

GKE + API 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

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

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 un fichier de configuration de service Cloud Run, appliqué au moment du déploiement pour créer votre service Cloud Run.

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 unique cible:

GKE

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

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

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

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

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

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

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.
Vérifiez votre pipeline et vos cibles :

Dans la console Google Cloud, accédez à Cloud Deploy Page Pipelines de livraison pour afficher la liste des livraisons disponibles les pipelines de ML.

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 livraison définit le cycle de vie de sortie. Voir Architecture du service Cloud Deploy pour en savoir plus sur ce cycle de vie.

Pour créer une ressource release qui représente l'image de conteneur à déployer, exécutez la commande suivante à partir de deploy-canary-quickstart-gke, deploy-canary-quickstart-gke-gatewayapi ou deploy-canary-quickstart-run répertoire:

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

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.

Passons à la phase stable.

Avec cette première version, nous ignorons la phase Canary et effectuons le déploiement à 100% (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écuterez 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 sera 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.

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
Cliquez sur le nom de votre pipeline de livraison "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.
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 du 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 % :

Dans la visualisation du pipeline, cliquez sur Passer à la version stable.
Lorsque vous y êtes invité, cliquez sur Continuer pour confirmer.

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

pipeline de livraison en phase stable

Exécuter le déploiement Canary

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

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

Au bout de quelques minutes, un déploiement est créé, et cette fois, la phase Canary est exécutée :

pipeline de livraison commençant la phase Canary

Une fois la première phase de déploiement terminée, le déploiement est maintenant en phase Canary:

visualisation du pipeline de livraison dans la console Google Cloud, avec une application déployée à 50%

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

Cliquez sur Déploiement avancé, puis sur Déploiement avancé lorsque vous y êtes invité.

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

Effectuer un nettoyage

Pour éviter que les ressources utilisées sur cette page soient facturées sur votre compte Google Cloud, procédez comme suit :

Supprimez le cluster canary-quickstart-cluster (GKE uniquement):

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

Supprimez le service my-canary-run-service (Cloud Run uniquement):

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

Supprimez le pipeline de livraison, la cible et toutes les ressources de publication et de déploiement:
```
gcloud deploy delete --file=clouddeploy.yaml --force --region=us-central1 --project=PROJECT_ID
```
Supprimez les buckets Cloud Storage créés par Cloud Deploy.

L'un se termine par _clouddeploy et l'autre par [region].deploy-artifacts.[project].appspot.com.

uvrez la page du navigateur Cloud Storage

Voilà ! Vous avez terminé le guide de démarrage rapide.

Déployer une application sur une cible en mode Canary

Avant de commencer

Créer votre environnement d'exécution

GKE

GKE + API Gateway

Cloud Run

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

GKE

API GKE + Gateway

Cloud Run

GKE

API GKE + Gateway

Cloud Run

GKE

GKE + API Gateway

Cloud Run

Créer votre pipeline de diffusion et vos cibles

GKE

GKE + API Gateway

Cloud Run

Créer une version

GKE

GKE + API Gateway

Cloud Run

Passons à la phase stable.

Afficher la version dans la console Google Cloud

Avancer la phase de déploiement

Exécuter le déploiement Canary

GKE

GKE + API Gateway

Cloud Run

Effectuer un nettoyage

Étape suivante