Présentation

Google Cloud Deploy est un service géré qui automatise la livraison de vos applications dans une série d'environnements cibles selon une séquence de promotion définie. Lorsque vous souhaitez déployer votre application mise à jour, vous devez créer une version, dont le cycle de vie est géré par un pipeline de livraison.

Dans cet atelier, vous allez créer un pipeline de livraison à l'aide de Google Cloud Deploy. Vous créerez ensuite une version pour une application de base et promouvrez l'application via une série de cibles Google Kubernetes Engine (GKE).

L'exemple d'application est une application Web simple qui écoute un port, renvoie un code de réponse HTTP et ajoute une entrée de journal.

Objectifs

Dans cet atelier, vous allez apprendre à effectuer les tâches suivantes :

• Déployer une image de conteneur dans Google Cloud Artifact Registry à l'aide de Skaffold
• Créer un pipeline de livraison Google Cloud Deploy
• Créer une version pour le pipeline de livraison
• Promouvoir l'application via les cibles dans le pipeline de livraison

Préparation

Accéder à Qwiklabs

Pour chaque atelier, nous vous attribuons un nouveau projet Google Cloud et un nouvel ensemble de ressources pour une durée déterminée, sans frais.

1. Cliquez sur le bouton Démarrer l'atelier. Si l'atelier est payant, un pop-up s'affiche pour vous permettre de sélectionner un mode de paiement. Sur la gauche, vous trouverez le panneau Détails concernant l'atelier, qui contient les éléments suivants :

   • Le bouton Ouvrir la console Google Cloud
   • Le temps restant
   • Les identifiants temporaires que vous devez utiliser pour cet atelier
   • Des informations complémentaires vous permettant d'effectuer l'atelier

2. Cliquez sur Ouvrir la console Google Cloud (ou effectuez un clic droit et sélectionnez Ouvrir le lien dans la fenêtre de navigation privée si vous utilisez le navigateur Chrome).

   L'atelier lance les ressources, puis ouvre la page Se connecter dans un nouvel onglet.

   Conseil : Réorganisez les onglets dans des fenêtres distinctes, placées côte à côte.

   Remarque : Si la boîte de dialogue Sélectionner un compte s'affiche, cliquez sur Utiliser un autre compte.

3. Si nécessaire, copiez le nom d'utilisateur ci-dessous et collez-le dans la boîte de dialogue Se connecter.

   {{{user_0.username | "Username"}}}

   Vous trouverez également le nom d'utilisateur dans le panneau Détails concernant l'atelier.

4. Cliquez sur Suivant.

5. Copiez le mot de passe ci-dessous et collez-le dans la boîte de dialogue Bienvenue.

   {{{user_0.password | "Password"}}}

   Vous trouverez également le mot de passe dans le panneau Détails concernant l'atelier.

6. Cliquez sur Suivant.

   Important : Vous devez utiliser les identifiants fournis pour l'atelier. Ne saisissez pas ceux de votre compte Google Cloud. Remarque : Si vous utilisez votre propre compte Google Cloud pour cet atelier, des frais supplémentaires peuvent vous être facturés.

7. Accédez aux pages suivantes :

   • Acceptez les conditions d'utilisation.
   • N'ajoutez pas d'options de récupération ni d'authentification à deux facteurs (ce compte est temporaire).
   • Ne vous inscrivez pas à des essais sans frais.

Après quelques instants, la console Cloud s'ouvre dans cet onglet.

Remarque : Pour afficher un menu contenant la liste des produits et services Google Cloud, cliquez sur le menu de navigation en haut à gauche, ou saisissez le nom du service ou du produit dans le champ Recherche.

Une fois la connexion initiale effectuée, le tableau de bord du projet s'affiche.

Activer Google Cloud Shell

Google Cloud Shell est une machine virtuelle qui contient de nombreux outils pour les développeurs. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud.

Google Cloud Shell vous permet d'accéder à vos ressources Google Cloud grâce à une ligne de commande.

1. Dans la barre d'outils située en haut à droite dans la console Cloud, cliquez sur le bouton "Ouvrir Cloud Shell".

   

2. Cliquez sur Continuer.

Le provisionnement et la connexion à l'environnement prennent quelques instants. Une fois connecté, vous êtes en principe authentifié et le projet est défini sur votre ID_PROJET. Par exemple :

gcloud est l'outil de ligne de commande pour Google Cloud. Il est préinstallé sur Cloud Shell et permet la complétion par tabulation.

• Vous pouvez lister les noms des comptes actifs à l'aide de cette commande :

gcloud auth list

Résultat :

Credentialed accounts: - @.com (active)

Exemple de résultat :

Credentialed accounts: - google1623327_student@qwiklabs.net

• Vous pouvez lister les ID de projet à l'aide de cette commande :

gcloud config list project

Résultat :

[core] project =

Exemple de résultat :

[core] project = qwiklabs-gcp-44776a13dea667a6 Remarque : Pour consulter la documentation complète sur gcloud, accédez au guide de présentation de la gcloud CLI.

Tâche 1 : Créer trois clusters GKE

Dans cette tâche, vous allez créer les trois clusters GKE qui serviront de cibles pour le pipeline de livraison.

Ces clusters représenteront les trois cibles du pipeline de livraison :

• test
• préproduction
• production

1. Déclarez les variables d'environnement qui seront utilisées par les différentes commandes :

export PROJECT_ID=$(gcloud config get-value project) export REGION={{{ project_0.default_region | "REGION" }}} gcloud config set compute/region $REGION

2. Activez l'API Google Kubernetes Engine :

gcloud services enable \ container.googleapis.com \ clouddeploy.googleapis.com

3. Dans Cloud Shell, configurez la complétion par tabulation pour kubectl :

source <(kubectl completion bash)

4. Créez les trois clusters GKE :

gcloud container clusters create-auto test --async gcloud container clusters create-auto staging --async gcloud container clusters create-auto prod --async Remarque : L'option --async permet de provisionner les clusters en arrière-plan, tandis que l'utilisateur peut continuer à configurer d'autres éléments du pipeline.

5. Vérifiez l'état des trois clusters :

gcloud container clusters list --format="csv(name,status)" Remarque : Étant donné que nous utilisons l'option --async, cette commande permet d'obtenir l'état du déploiement des clusters.

Résultat

name,status prod,PROVISIONING staging,PROVISIONING test,RUNNING

La création des clusters peut prendre quelques minutes. Vous n'avez pas besoin d'attendre que les clusters soient prêts. Poursuivez l'atelier.

Cliquez sur Vérifier ma progression pour valider l'objectif. Créer trois clusters GKE

Tâche 2 : Préparer l'image de conteneur de l'application Web

Dans cette tâche, vous allez créer un dépôt dans Artifact Registry pour y stocker les images de conteneur de l'application Web.

1. Activez l'API Artifact Registry :

gcloud services enable artifactregistry.googleapis.com

2. Créez le dépôt de l'application Web dans lequel stocker les images de conteneur :

gcloud artifacts repositories create web-app \ --description="Image registry for sample web app" \ --repository-format=docker \ --location=$REGION

Cliquez sur Vérifier ma progression pour valider l'objectif. Créer le dépôt de l'application Web

Tâche 3 : Compiler les images de conteneur et les déployer dans Artifact Registry

Dans cette tâche, vous allez cloner le dépôt git contenant l'application Web et déployer les images de conteneur de l'application dans Artifact Registry.

Préparer la configuration de l'application

1. Clonez le dépôt de l'atelier dans votre répertoire d'accueil :

cd ~/ git clone https://github.com/GoogleCloudPlatform/cloud-deploy-tutorials.git cd cloud-deploy-tutorials git checkout c3cae80 --quiet cd tutorials/base

2. Créez la configuration skaffold.yaml :

envsubst < clouddeploy-config/skaffold.yaml.template > web/skaffold.yaml cat web/skaffold.yaml Remarque : La commande envsubst permet d'effectuer des opérations de recherche et de remplacement.

Le répertoire Web contient désormais le fichier de configuration skaffold.yaml, qui indique à Skaffold comment créer une image de conteneur pour votre application. Cette configuration décrit les éléments mentionnés ci-dessous.

La section "build" configure :

• les deux images de conteneur qui seront compilées (artefacts) ;
• le projet Google Cloud Build utilisé pour compiler les images.

La section deploy configure les fichiers manifestes Kubernetes nécessaires pour déployer la charge de travail sur un cluster.

La configuration portForward permet de définir le service Kubernetes pour le déploiement.

Résultat

apiVersion: skaffold/v2beta7 kind: Config build: artifacts: - image: leeroy-web context: leeroy-web - image: leeroy-app context: leeroy-app googleCloudBuild: projectId: {{project-id}} deploy: kubectl: manifests: - leeroy-web/kubernetes/* - leeroy-app/kubernetes/* portForward: - resourceType: deployment resourceName: leeroy-web port: 8080 localPort: 9000 Remarque : Pour afficher les fichiers, utilisez vi, emacs, nano ou l'éditeur de code Cloud Shell en cliquant sur l'icône Ouvrir l'éditeur dans Cloud Shell.

Compiler l'application Web

L'outil Skaffold gérera l'envoi du codebase à Cloud Build.

1. Activez l'API Cloud Build :

gcloud services enable cloudbuild.googleapis.com

2. Exécutez la commande Skaffold pour compiler l'application et déployer l'image de conteneur dans le dépôt Artifact Registry que vous avez créé précédemment :

cd web skaffold build --interactive=false \ --default-repo $REGION-docker.pkg.dev/$PROJECT_ID/web-app \ --file-output artifacts.json cd ..

3. Une fois l'exécution de skaffold build terminée, recherchez les images de conteneur dans Artifact Registry :

gcloud artifacts docker images list \ $REGION-docker.pkg.dev/$PROJECT_ID/web-app \ --include-tags \ --format yaml

Le paramètre YAML --format renvoie le résultat au format YAML pour qu'il soit lisible. Il doit se présenter comme suit :

Résultat

--- createTime: '2024-09-11T02:07:54.995807Z' package: us-central1-docker.pkg.dev/{{project-id}}/web-app/leeroy-app tags: '9181623' updateTime: '2024-09-11T02:07:54.995807Z' version: sha256:6af6a0a72d13dd6597c0fc0191f697e2da2c3892d1bf8e87a3df8d96612e1495 --- createTime: '2024-09-11T02:07:53.629263Z' package: us-central1-docker.pkg.dev/{{project-id}}/web-app/leeroy-web tags: '9181623' updateTime: '2024-09-11T02:07:53.629263Z' version: sha256:a0179673d1876f205875b223557c83162e56e91c5e3313f5e99465a224adb6c9

Par défaut, Skaffold définit le tag d'une image sur son tag git associé s'il est disponible. Vous trouverez des informations similaires dans le fichier artifacts.json créé par la commande Skaffold.

Skaffold génère le fichier web/artifacts.json qui contient des détails sur les images déployées :

cat web/artifacts.json | jq

Résultat

{ "builds": [ { "imageName": "leeroy-web", "tag": "us-central1-docker.pkg.dev/{{project-id}}/web-app/leeroy-web:9181623@sha256:a0179673d1876f205875b223557c83162e56e91c5e3313f5e99465a224adb6c9" }, { "imageName": "leeroy-app", "tag": "us-central1-docker.pkg.dev/{{project-id}}/web-app/leeroy-app:9181623@sha256:6af6a0a72d13dd6597c0fc0191f697e2da2c3892d1bf8e87a3df8d96612e1495" } ]

Cliquez sur Vérifier ma progression pour valider l'objectif. Compiler les images de conteneur et les déployer dans Artifact Registry

Tâche 4 : Créer le pipeline de livraison

Dans cette tâche, vous allez configurer le pipeline de livraison. Il promouvra les applications du test vers la préproduction et de la préproduction vers la production.

1. Activez l'API Google Cloud Deploy :

gcloud services enable clouddeploy.googleapis.com

2. Créez la ressource de pipeline de livraison à l'aide du fichier delivery-pipeline.yaml :

gcloud config set deploy/region $REGION cp clouddeploy-config/delivery-pipeline.yaml.template clouddeploy-config/delivery-pipeline.yaml gcloud deploy apply --file=clouddeploy-config/delivery-pipeline.yaml

3. Vérifiez que vous avez créé le pipeline de livraison :

gcloud deploy delivery-pipelines describe web-app

Le pipeline de livraison sera semblable au résultat suivant :

Résultat

Unable to get target test Unable to get target staging Unable to get target prod Delivery Pipeline: createTime: '2024-09-11T14:03:18.294884547Z' description: web-app delivery pipeline etag: 2539eacd7f5c256d name: projects/{{project-id}}/locations/us-central1/deliveryPipelines/web-app serialPipeline: stages: - targetId: test - targetId: staging - targetId: prod uid: eb0601aa03ac4b088d74c6a5f13f36ae updateTime: '2024-09-11T14:03:18.680753520Z' Targets: []

Regardez les trois premières lignes du résultat. Le pipeline de livraison référence actuellement trois environnements cibles qui n'ont pas encore été créés. Dans la prochaine tâche, vous allez créer ces cibles.

Cliquez sur Vérifier ma progression pour valider l'objectif. Créer le pipeline de livraison

Tâche 5 : Configurer les cibles de déploiement

Trois cibles seront créées pour le pipeline de livraison, une pour chacun des clusters GKE.

Vérifier que les clusters sont prêts

Les trois clusters GKE devraient désormais être en cours d'exécution, mais il est utile de le vérifier.

• Exécutez la commande suivante pour connaître l'état des clusters :

gcloud container clusters list --format="csv(name,status)"

Les trois clusters doivent être à l'état RUNNING, comme indiqué dans le résultat ci-dessous. Dans le cas contraire, relancez la commande ci-dessus jusqu'à ce qu'ils passent à l'état RUNNING.

Résultat

name,status prod,RUNNING staging,RUNNING test,RUNNING

Une fois que tous les clusters sont à l'état RUNNING, passez à la suite de l'atelier.

Créer un contexte pour chaque cluster

Exécutez les commandes ci-dessous pour obtenir les identifiants de chaque cluster et créer un contexte kubectl facile à utiliser pour référencer les clusters ultérieurement :

CONTEXTS=("test" "staging" "prod") for CONTEXT in ${CONTEXTS[@]} do gcloud container clusters get-credentials ${CONTEXT} --region ${REGION} kubectl config rename-context gke_${PROJECT_ID}_${REGION}_${CONTEXT} ${CONTEXT} done

Créer un espace de noms dans chaque cluster

Exécutez les commandes ci-dessous pour créer un espace de noms Kubernetes (web-app) dans chacun des trois clusters :

for CONTEXT in ${CONTEXTS[@]} do kubectl --context ${CONTEXT} apply -f kubernetes-config/web-app-namespace.yaml done

L'application sera déployée dans l'espace de noms (web-app).

Créer les cibles du pipeline de livraison

1. Envoyez une définition pour chaque cible :

for CONTEXT in ${CONTEXTS[@]} do envsubst < clouddeploy-config/target-$CONTEXT.yaml.template > clouddeploy-config/target-$CONTEXT.yaml gcloud deploy apply --file clouddeploy-config/target-$CONTEXT.yaml done

Les cibles sont décrites dans un fichier YAML. Chaque cible configure les informations de cluster appropriées pour elle. Les configurations des cibles de test et de préproduction sont essentiellement les mêmes.

2. Affichez les détails de la cible de test :

cat clouddeploy-config/target-test.yaml

Résultat

apiVersion: deploy.cloud.google.com/v1beta1 kind: Target metadata: name: test description: test cluster gke: cluster: projects/{{project-id}}/locations/us-central1/clusters/test

La cible de production est légèrement différente, car elle nécessite une approbation (voir le paramètre requireApproval dans le résultat) avant qu'une version puisse être promue vers le cluster.

3. Affichez les détails de la cible de production :

cat clouddeploy-config/target-prod.yaml

Résultat

apiVersion: deploy.cloud.google.com/v1beta1 kind: Target metadata: name: prod description: prod cluster requireApproval: true gke: cluster: projects/{{project-id}}/locations/us-central1/clusters/prod

4. Vérifiez que vous avez créé les trois cibles (test, préproduction, production) :

gcloud deploy targets list

Vous avez désormais créé toutes les cibles Google Cloud Deploy pour le pipeline de livraison.

Cliquez sur Vérifier ma progression pour valider l'objectif. Configurer les cibles de déploiement

Tâche 6 : Créer une version

Dans cette tâche, vous allez créer une version de l'application.

Une version Google Cloud Deploy est une version spécifique d'une ou de plusieurs images de conteneur associées à un pipeline de livraison spécifique. Une fois qu'une version est créée, vous pouvez la promouvoir via plusieurs cibles (séquence de promotion). De plus, si vous créez une version, votre application s'affiche à l'aide de Skaffold, et le résultat est enregistré en tant que référence à un moment précis. Cette référence sera utilisée pendant toute la durée de la version.

Comme il s'agit de la première version de votre application, vous la nommerez web-app-001.

1. Exécutez la commande suivante pour créer la version :

gcloud deploy releases create web-app-001 \ --delivery-pipeline web-app \ --build-artifacts web/artifacts.json \ --source web/

Le paramètre --build-artifacts référence le fichier artifacts.json que Skaffold a créé précédemment. Le paramètre --source parameter référence le répertoire source de l'application où se trouve skaffold.yaml.

Lorsqu'une version est créée, elle est également déployée automatiquement sur la première cible du pipeline (sauf si une approbation est requise, ce que nous verrons plus tard dans cet atelier).

2. Pour vérifier que vous avez déployé votre application sur la cible de test, exécutez la commande suivante :

gcloud deploy rollouts list \ --delivery-pipeline web-app \ --release web-app-001

Résultat

--- approvalState: DOES_NOT_NEED_APPROVAL createTime: '2024-09-11T14:05:21.961604Z' deployEndTime: '2024-09-11T14:06:35.278604Z' deployStartTime: '2024-09-11T14:06:22.420091744Z' deployingBuild: projects/{{project-id}}/locations/us-central1/builds/4815b788-ec5e-4185-9141-a5b57c71b001 enqueueTime: '2024-09-11T14:06:21.760830Z' etag: 5cb7b6c342b5f29b name: projects/{{project-id}}/locations/us-central1/deliveryPipelines/web-app/releases/web-app-001/rollouts/web-app-001-to-test-0001 state: SUCCEEDED targetId: test uid: cccd9525d3a0414fa60b2771036841d9

Le premier déploiement d'une version prend plusieurs minutes, car Google Cloud Deploy affiche les fichiers manifestes pour toutes les cibles lorsque la version est créée. Le cluster GKE peut également mettre quelques minutes à fournir les ressources nécessaires au déploiement.

Si vous ne voyez pas state: SUCCEEDED dans le résultat de la commande précédente, veuillez patienter et réexécuter régulièrement la commande jusqu'à ce que le déploiement soit terminé.

3. Exécutez les commandes suivantes pour vérifier que vous avez déployé votre application sur le cluster GKE :

kubectx test kubectl get all -n web-app

Sortie

NAME READY STATUS RESTARTS AGE pod/leeroy-app-5547cf9d9b-rgc2l 1/1 Running 0 3m27s pod/leeroy-web-6768b49c46-w7vt9 1/1 Running 0 3m27s NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE service/leeroy-app ClusterIP None <none> 50051/TCP 3m28s NAME READY UP-TO-DATE AVAILABLE AGE deployment.apps/leeroy-app 1/1 1 1 3m28s deployment.apps/leeroy-web 1/1 1 1 3m28s NAME DESIRED CURRENT READY AGE replicaset.apps/leeroy-app-5547cf9d9b 1 1 1 3m28s replicaset.apps/leeroy-web-6768b49c46 1 1 1 3m28s Remarque : La commande kubectx permet de passer facilement d'un contexte à un autre.

Cliquez sur Vérifier ma progression pour valider l'objectif. Créer une version

Tâche 7 : Promouvoir l'application vers la préproduction

Dans cette tâche, vous allez promouvoir l'application du test à la préproduction.

1. Promouvez l'application vers la préproduction :

gcloud deploy releases promote \ --delivery-pipeline web-app \ --release web-app-001

Vous serez invité à continuer avant le début de la promotion.

• Appuyez sur Entrée pour accepter la valeur par défaut (Y = oui).

2. Pour vérifier que vous avez déployé votre application sur la cible de préproduction, exécutez la commande suivante :

gcloud deploy rollouts list \ --delivery-pipeline web-app \ --release web-app-001

Examiner le résultat

Recherchez la section targetId: staging. Comme tout à l'heure, si vous ne voyez pas state: SUCCEEDED dans le résultat de la commande précédente, veuillez patienter et réexécuter régulièrement la commande jusqu'à ce que le déploiement soit terminé.

Résultat

--- approvalState: DOES_NOT_NEED_APPROVAL createTime: '2024-09-11T02:19:32.539468Z' deployEndTime: '2024-09-11T02:19:45.970949Z' deployStartTime: '2024-09-11T02:19:33.111948770Z' deployingBuild: projects/743805075658/locations/us-central1/builds/2316517c-3a2f-4cd3-80ad-6d133b653746 etag: 1109b802ff586df5 name: projects/{{project-id}}/locations/us-central1/deliveryPipelines/web-app/releases/web-app-001/rollouts/web-app-001-to-staging-0001 state: SUCCEEDED targetId: staging uid: 80a35a5f044844708d2050f8c556e07e

Cliquez sur Vérifier ma progression pour valider l'objectif. Promouvoir l'application vers la préproduction

Tâche 8 : Promouvoir l'application vers la production

Dans cette tâche, vous allez promouvoir à nouveau l'application, mais aussi donner votre approbation.

1. Promouvez l'application vers la cible de production :

gcloud deploy releases promote \ --delivery-pipeline web-app \ --release web-app-001

Vous serez invité à continuer avant le début de la promotion.

• Appuyez sur Entrée pour accepter la valeur par défaut (Y = oui).

2. Pour consulter l'état de la cible de production, exécutez la commande suivante :

gcloud deploy rollouts list \ --delivery-pipeline web-app \ --release web-app-001

Dans le résultat, vous constaterez qu'approvalState a la valeur NEEDS_APPROVAL et que l'état est PENDING_APPROVAL.

Résultat

--- approvalState: NEEDS_APPROVAL createTime: '2024-09-11T14:12:07.466989Z' etag: 6e9303e5a1b04084 name: projects/{{project-id}}/locations/us-central1/deliveryPipelines/web-app/releases/web-app-001/rollouts/web-app-001-to-prod-0001 state: PENDING_APPROVAL targetId: prod uid: a5c7d6007fee4d80904d49142581aaa7

3. Approuvez le déploiement à l'aide de la commande suivante :

gcloud deploy rollouts approve web-app-001-to-prod-0001 \ --delivery-pipeline web-app \ --release web-app-001

Vous serez invité à approuver le déploiement avant le début de la promotion.

• Appuyez sur Entrée pour accepter la valeur par défaut (Y = oui).

4. Pour vérifier que vous avez déployé votre application sur la cible de production, exécutez la commande suivante :

gcloud deploy rollouts list \ --delivery-pipeline web-app \ --release web-app-001

Comme pour les déploiements précédents, localisez l'entrée de la cible (targetId: prod) et vérifiez que le déploiement est terminé (state: SUCCEEDED). Réexécutez régulièrement la commande jusqu'à ce que le déploiement soit terminé.

5. Utilisez kubectl pour vérifier l'état de l'application déployée :

kubectx prod kubectl get all -n web-app

Cliquez sur Vérifier ma progression pour valider l'objectif. Promouvoir l'application vers la production

Félicitations !

Vous pouvez désormais créer des pipelines de livraison continue à l'aide de Cloud Deploy.

Copyright 2025 Google LLC Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms de société et de produit peuvent être des marques des sociétés auxquelles ils sont associés.