GSP1077

Présentation

Cloud Build est un service qui exécute vos compilations sur Google Cloud. Il peut importer du code source, exécuter des compilations et bien plus encore.

Dans cet atelier, vous allez créer un pipeline d'intégration et de déploiement continus (CI/CD) qui compile automatiquement une image de conteneur à partir d'un code validé, stocke l'image dans Artifact Registry, met à jour un fichier manifeste Kubernetes dans un dépôt Git, puis déploie l'application sur Google Kubernetes Engine à l'aide de ce fichier manifeste.

Pour cet atelier, vous allez utiliser un dépôt Git hébergé sur un serveur Git Gitea dédié et auto-hébergé (git-server) :

• app : contient le code source de l'application (hello-cloudbuild-app)
• env : contient les fichiers manifestes de déploiement Kubernetes (hello-cloudbuild-env)

Lorsque vous envoyez une modification au dépôt app, le pipeline Cloud Build exécute des tests, compile une image de conteneur, puis envoie la modification vers Artifact Registry. Ensuite, Cloud Build met à jour le fichier manifeste de déploiement et l'envoie au dépôt env. Cette opération déclenche un autre pipeline Cloud Build qui applique le fichier manifeste au cluster GKE et, si l'opération réussit, le stocke dans une autre branche du dépôt env.

Les dépôts app et env sont séparés, car leur utilisation et leur cycle de vie diffèrent. Le dépôt app est dédié à une application spécifique et est principalement utilisé par des personnes réelles. Le dépôt env peut être partagé par plusieurs applications et est utilisé par des systèmes automatisés (comme Cloud Build). Le dépôt env peut contenir plusieurs branches, chacune d'entre elles correspondant à un environnement spécifique et faisant référence à une image de conteneur spécifique, ce qui n'est pas le cas avec le dépôt app.

Une fois cet atelier terminé, vous disposerez d'un système dans lequel vous pourrez facilement :

• distinguer les déploiements ayant abouti et échoué en consultant l'historique de Cloud Build ;
• accéder au fichier manifeste actuellement utilisé en consultant la branche de production du dépôt env ;
• effectuer un rollback vers une version précédente en exécutant à nouveau la compilation Cloud Build correspondante.

Objectifs

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

• Créer des clusters Kubernetes Engine
• Se connecter à un serveur Git dédié et initialiser des dépôts Git
• Exécuter des pipelines Cloud Build à partir de dépôts de code source
• Automatiser les tests et publier une image de conteneur déployable avec Cloud Build
• Gérer les ressources déployées dans un cluster Kubernetes Engine à l'aide de Cloud Build

Préparation

Avant de cliquer sur le bouton "Démarrer l'atelier"

Lisez ces instructions. Les ateliers sont minutés, et vous ne pouvez pas les mettre en pause. Le minuteur, qui démarre lorsque vous cliquez sur Démarrer l'atelier, indique combien de temps les ressources Google Cloud resteront accessibles.

Cet atelier pratique vous permet de suivre les activités dans un véritable environnement cloud, et non dans un environnement de simulation ou de démonstration. Des identifiants temporaires vous sont fournis pour vous permettre de vous connecter à Google Cloud le temps de l'atelier.

Pour réaliser cet atelier :

• Vous devez avoir accès à un navigateur Internet standard (nous vous recommandons d'utiliser Chrome).

Remarque : Ouvrez une fenêtre de navigateur en mode incognito (recommandé) ou de navigation privée pour effectuer cet atelier. Vous éviterez ainsi les conflits entre votre compte personnel et le compte temporaire de participant, qui pourraient entraîner des frais supplémentaires facturés sur votre compte personnel.

• Vous disposez d'un temps limité. N'oubliez pas qu'une fois l'atelier commencé, vous ne pouvez pas le mettre en pause.

Remarque : Utilisez uniquement le compte de participant pour cet atelier. Si vous utilisez un autre compte Google Cloud, des frais peuvent être facturés à ce compte.

Démarrer l'atelier et se connecter à la console Google Cloud

1. Cliquez sur le bouton Démarrer l'atelier. Si l'atelier est payant, une boîte de dialogue s'affiche pour vous permettre de sélectionner un mode de paiement. Sur la droite, vous trouverez le panneau Préparation et accès à l'atelier, qui contient les éléments suivants :

   • Le bouton Ouvrir la console Google Cloud
   • Les identifiants temporaires (nom d'utilisateur et mot de passe) que vous devez utiliser pour cet atelier
   • Des informations complémentaires vous permettant d'effectuer l'atelier, si nécessaire

   Notez que le minuteur de l'atelier se trouve en haut de la page et indique le temps restant.

2. Cliquez sur Ouvrir la console Google Cloud (ou effectuez un clic droit et sélectionnez Ouvrir le lien dans une fenêtre en navigation privée si vous utilisez 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 Préparation et accès à 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 Préparation et accès à l'atelier.

6. Cliquez sur Suivant.

   Important : Vous devez utiliser les identifiants fournis pour l'atelier. N'utilisez pas les identifiants de votre compte Google Cloud. Remarque : Si vous utilisez votre propre compte Google Cloud pour cet atelier, des frais supplémentaires pourront 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 accéder aux produits et services Google Cloud, cliquez sur le menu de navigation ou saisissez le nom du service ou du produit dans le champ Recherche.

Activer Cloud Shell

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. Cloud Shell vous permet d'accéder via une ligne de commande à vos ressources Google Cloud.

1. Cliquez sur Activer Cloud Shell  en haut de la console Google Cloud.

2. Passez les fenêtres suivantes :

   • Accédez à la fenêtre d'informations de Cloud Shell.
   • Autorisez Cloud Shell à utiliser vos identifiants pour effectuer des appels d'API Google Cloud.

Une fois connecté, vous êtes en principe authentifié et le projet est défini sur votre ID_PROJET : . Le résultat contient une ligne qui déclare l'ID_PROJET pour cette session :

Your Cloud Platform project in this session is set to {{{project_0.project_id | "PROJECT_ID"}}}

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.

3. (Facultatif) Vous pouvez lister les noms des comptes actifs à l'aide de cette commande :

gcloud auth list

4. Cliquez sur Autoriser.

Résultat :

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Facultatif) Vous pouvez lister les ID de projet à l'aide de cette commande :

gcloud config list project

Résultat :

[core] project = {{{project_0.project_id | "PROJECT_ID"}}} Remarque : Pour consulter la documentation complète sur gcloud, dans Google Cloud, accédez au guide de présentation de la gcloud CLI.

Tâche 1 : Initialiser l'atelier

Dans cette tâche, vous allez configurer votre environnement :

• Importer l'ID du projet, le numéro du projet et l'adresse IP du serveur Git en tant que variables
• Activer les API pour GKE, Cloud Build, Secret Manager et Artifact Analysis
• Créer un dépôt Docker Artifact Registry
• Créer un cluster GKE pour déployer l'exemple d'application de cet atelier

1. Dans Cloud Shell, exécutez la commande suivante pour définir l'ID du projet, le numéro du projet, ainsi que la région :

export PROJECT_ID=$(gcloud config get-value project) export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format='value(projectNumber)') export REGION={{{ project_0.default_region }}} gcloud config set compute/region $REGION export GIT_SERVER_IP=$(gcloud compute instances describe git-server --zone={{{ project_0.default_zone }}} --format='get(networkInterfaces[0].accessConfigs[0].natIP)') echo "Git Server IP is: ${GIT_SERVER_IP}"

2. Exécutez la commande suivante pour activer les API pour GKE, Cloud Build, Secret Manager et Artifact Analysis :

gcloud services enable container.googleapis.com \ cloudbuild.googleapis.com \ secretmanager.googleapis.com \ containeranalysis.googleapis.com

3. Créez un dépôt Docker Artifact Registry nommé my-repository dans la région pour stocker vos images de conteneurs :

gcloud artifacts repositories create my-repository \ --repository-format=docker \ --location=$REGION

4. Créez un cluster GKE pour déployer l'exemple d'application de cet atelier :

gcloud container clusters create hello-cloudbuild --num-nodes 1 --region $REGION

5. Exécutez la commande suivante pour configurer Git dans Cloud Shell : git config --global user.name "giteaadmin" git config --global user.email "student@qwiklabs.net"

Cliquez sur Vérifier ma progression pour valider l'objectif. Activer les services, créer un dépôt Artifact Registry et le cluster GKE

Tâche 2 : Se connecter aux dépôts Git sur le serveur Git

Dans cette tâche, vous allez initialiser les deux dépôts Git (hello-cloudbuild-app et hello-cloudbuild-env) sur votre serveur Git dédié (git-server), puis y transmettre l'exemple de code initial.

1. Téléchargez l'exemple de code depuis Cloud Storage :

cd ~ git clone http://${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-app.git

Le code que vous avez cloné contient une simple application "Hello World" :

from flask import Flask app = Flask('hello-cloudbuild') @app.route('/') def hello(): return "Hello World!\n" if __name__ == '__main__': app.run(host = '0.0.0.0', port = 8080)

Tâche 3 : Créer une image de conteneur avec Cloud Build

Dans cette tâche, vous allez utiliser Cloud Build pour créer et stocker une image de conteneur à partir d'un Dockerfile existant.

Le code que vous avez cloné précédemment contient le Dockerfile :

FROM python:3.11-slim RUN pip install flask WORKDIR /app COPY app.py /app/app.py ENTRYPOINT ["python"] CMD ["/app/app.py"]

Vous pouvez utiliser ce Dockerfile pour créer une image de conteneur avec Cloud Build, puis la stocker dans Artifact Registry.

1. Dans Cloud Shell, créez une compilation Cloud Build basée sur le dernier commit à l'aide de la commande suivante :

cd ~/hello-cloudbuild-app COMMIT_ID="$(git rev-parse --short=7 HEAD)" gcloud builds submit --tag="${REGION}-docker.pkg.dev/${PROJECT_ID}/my-repository/hello-cloudbuild:${COMMIT_ID}" .

Cloud Build diffuse les journaux générés par la création de l'image de conteneur vers votre terminal lorsque vous exécutez cette commande.

2. Une fois la compilation terminée, dans la barre de titre de la console Google Cloud, saisissez Artifact Registry dans le champ Recherche, puis cliquez sur Artifact Registry dans les résultats de recherche. Vérifiez que votre nouvelle image de conteneur est bien disponible dans Artifact Registry. Cliquez sur my-repository pour afficher l'image hello-cloudbuild dans la liste Image.

Cliquez sur Vérifier ma progression pour valider l'objectif. Créer l'image de conteneur avec Cloud Build

Tâche 4 : Créer et exécuter le pipeline d'intégration continue (CI)

Dans cette tâche, vous allez configurer et utiliser Cloud Build pour exécuter automatiquement des tests unitaires, créer l'image de conteneur, puis la transférer vers Artifact Registry.

Le fichier cloudbuild.yaml, déjà inclus dans le code, correspond à sa configuration.

1. Validez vos modifications et transférez-les vers votre serveur Git :

cd ~/hello-cloudbuild-app git add . git commit -m "Trigger CI pipeline" git push http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-app.git main

2. Envoyez la compilation à Cloud Build à l'aide de la commande suivante :

gcloud builds submit --config=cloudbuild.yaml --substitutions=SHORT_SHA=$(git rev-parse --short=7 HEAD) .

3. Dans la console Google Cloud, recherchez Cloud Build, puis cliquez sur Historique dans le volet de gauche. Vous pouvez examiner le journal d'exécution de votre compilation CI.

Cliquez sur Vérifier ma progression pour valider l'objectif. Créer un pipeline d'intégration continue (CI)

Tâche 5 : Stocker le secret de la clé SSH dans Secret Manager

Dans cette étape, vous allez stocker un secret de clé privée dans Secret Manager et accorder à Cloud Build les autorisations nécessaires pour accéder à Secret Manager.

Créer une clé SSH et la stocker dans Secret Manager

1. Dans Cloud Shell, créez une clé SSH :

   mkdir -p ~/workingdir && cd ~/workingdir ssh-keygen -t rsa -b 4096 -N '' -f id_rsa -C "student@qwiklabs.net"

2. Stockez la clé SSH privée dans Secret Manager en exécutant la commande suivante dans Cloud Shell :

gcloud secrets create ssh_key_secret --data-file=$HOME/workingdir/id_rsa

Vous pouvez également suivre ces étapes dans la console Google Cloud : a. Commencez par télécharger id_rsa sur votre ordinateur : dans Cloud Shell, cliquez sur Plus () > Télécharger le fichier, saisissez workingdir/id_rsa, puis cliquez sur Télécharger. b. Recherchez Secret Manager, puis cliquez sur Secret Manager. c. Cliquez sur Créer un secret. d. Définissez le champ Nom sur ssh_key_secret. e. Sous Valeur du secret, sélectionnez Importer et importez le fichier id_rsa téléchargé. f. Cliquez sur Créer un secret.

Accorder au compte de service l'autorisation d'accéder à Secret Manager

Exécutez la commande suivante dans Cloud Shell pour autoriser le compte de service Compute Engine par défaut à accéder à Secret Manager :

PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format='value(projectNumber)') gcloud projects add-iam-policy-binding ${PROJECT_NUMBER} \ --member=serviceAccount:${PROJECT_NUMBER}-compute@developer.gserviceaccount.com \ --role=roles/secretmanager.secretAccessor

Cliquez sur Vérifier ma progression pour valider l'objectif. Stocker le secret de la clé SSH dans Secret Manager

Tâche 6 : Créer un environnement de test et un pipeline CD

Vous pouvez également utiliser Cloud Build pour le pipeline de livraison continue. Le pipeline s'exécute chaque fois qu'un commit est envoyé à la branche candidate du dépôt hello-cloudbuild-env. Le pipeline applique la nouvelle version du fichier manifeste au cluster Kubernetes et, si l'opération réussit, il copie le fichier manifeste dans la branche de production. Ce processus a les propriétés suivantes :

• La branche candidate correspond à l'historique des tentatives de déploiement.
• La branche de production correspond à l'historique des déploiements réussis.
• Dans Cloud Build, une vue permet d'identifier les déploiements qui ont abouti et ceux qui ont échoué.
• Vous pouvez effectuer un rollback vers n'importe quel déploiement précédent en exécutant à nouveau la compilation correspondante dans Cloud Build. Lors d'un rollback, la branche de production est également mise à jour afin de refléter fidèlement l'historique des déploiements.

Vous allez ensuite modifier le pipeline d'intégration continue pour mettre à jour la branche candidate du dépôt hello-cloudbuild-env, ce qui déclenchera le pipeline de livraison continue.

Autoriser Cloud Build à accéder à GKE

Pour déployer l'application dans votre cluster Kubernetes, Cloud Build doit disposer du rôle "Développeur sur Kubernetes Engine".

1. Dans Cloud Shell, exécutez la commande suivante :

PROJECT_NUMBER="$(gcloud projects describe ${PROJECT_ID} --format='get(projectNumber)')" gcloud projects add-iam-policy-binding ${PROJECT_NUMBER} \ --member=serviceAccount:${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com \ --role=roles/container.developer

Vous devez initialiser le dépôt hello-cloudbuild-env avec deux branches (production et candidate) et un fichier de configuration Cloud Build décrivant le processus de déploiement.

2. Dans Cloud Shell, téléchargez l'exemple de code depuis Cloud Storage :

cd ~ git clone http://${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-env.git

3. Dans Cloud Shell, remplacez le contenu de cloudbuild.yaml dans le dépôt hello-cloudbuild-env en exécutant la commande suivante :

cd ~/hello-cloudbuild-env cat <<'EOF' > cloudbuild.yaml # Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. substitutions: _COMMIT_SHA: 'v1.0' steps: # This step deploys the new version of our container image # in the hello-cloudbuild Kubernetes Engine cluster. - name: 'gcr.io/cloud-builders/kubectl' id: Deploy args: - 'apply' - '-f' - 'kubernetes.yaml' env: - 'CLOUDSDK_COMPUTE_REGION={{{ project_0.default_region }}}' - 'CLOUDSDK_CONTAINER_CLUSTER=hello-cloudbuild' # This step copies the applied manifest to the production branch - name: 'gcr.io/cloud-builders/gcloud' id: Copy to production branch entrypoint: /bin/sh args: - '-c' - | set -x && \ git clone -b production http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-env.git prod_repo && \ cd prod_repo && \ git config user.email "student@qwiklabs.net" && \ git config user.name "Cloud Build" && \ cp ../kubernetes.yaml kubernetes.yaml && \ git add kubernetes.yaml && \ git commit -m "Deployed manifest from commit $_COMMIT_SHA" && \ git push origin production options: logging: CLOUD_LOGGING_ONLY EOF sed -i "s/\${GIT_SERVER_IP}/$GIT_SERVER_IP/g" cloudbuild.yaml

Validez la modification et déployez-la sur hello-cloudbuild-env :

cd ~/hello-cloudbuild-env git checkout candidate git add cloudbuild.yaml git commit -m "Create cloudbuild.yaml for deployment" git push http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-env.git candidate

Modifier le pipeline d'intégration continue afin de déclencher le pipeline de livraison continue

Mettez ensuite à jour le pipeline d'intégration continue dans hello-cloudbuild-app pour générer une nouvelle version du fichier manifeste Kubernetes et l'envoyer vers hello-cloudbuild-env afin de déclencher le pipeline de CD.

1. Dans Cloud Shell, remplacez le fichier cloudbuild.yaml dans hello-cloudbuild-app et renseignez l'adresse IP de votre serveur Git en exécutant les commandes suivantes :

cd ~/hello-cloudbuild-app cat <<'EOF' > cloudbuild.yaml # Copyright 2018 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. substitutions: _SHORT_SHA: 'v1.0' _COMMIT_SHA: 'v1.0' steps: # This step runs the unit tests on the app - name: 'python:3.11-slim' id: Test entrypoint: /bin/sh args: - -c - 'pip install flask && python test_app.py -v' # This step builds the container image. - name: 'gcr.io/cloud-builders/docker' id: Build args: - 'build' - '-t' - '{{{ project_0.default_region }}}-docker.pkg.dev/$PROJECT_ID/my-repository/hello-cloudbuild:$_SHORT_SHA' - '.' # This step pushes the image to Artifact Registry - name: 'gcr.io/cloud-builders/docker' id: Push args: - 'push' - '{{{ project_0.default_region }}}-docker.pkg.dev/$PROJECT_ID/my-repository/hello-cloudbuild:$_SHORT_SHA' # This step clones the hello-cloudbuild-env repository - name: 'gcr.io/cloud-builders/gcloud' id: Clone env repo entrypoint: /bin/sh args: - '-c' - | git clone http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-env.git && \ cd hello-cloudbuild-env && \ git checkout candidate && \ git config user.email "student@qwiklabs.net" && \ git config user.name "Cloud Build" # This step generates the new manifest - name: 'gcr.io/cloud-builders/gcloud' id: Generate manifest entrypoint: /bin/sh args: - '-c' - | sed "s/GOOGLE_CLOUD_PROJECT/${PROJECT_ID}/g" kubernetes.yaml.tpl | \ sed "s/COMMIT_SHA/${_SHORT_SHA}/g" > hello-cloudbuild-env/kubernetes.yaml # This step pushes the manifest back to hello-cloudbuild-env candidate branch - name: 'gcr.io/cloud-builders/gcloud' id: Push manifest entrypoint: /bin/sh args: - '-c' - | set -x && \ cd hello-cloudbuild-env && \ git add kubernetes.yaml && \ git commit -m "Deploying image {{{ project_0.default_region }}}-docker.pkg.dev/$PROJECT_ID/my-repository/hello-cloudbuild:${_SHORT_SHA} Built from commit ${_COMMIT_SHA} of repository hello-cloudbuild-app Author: $(git log --format='%an <%ae>' -n 1 HEAD)" && \ git push origin candidate options: logging: CLOUD_LOGGING_ONLY EOF sed -i "s/\${GIT_SERVER_IP}/$GIT_SERVER_IP/g" cloudbuild.yaml

2. Validez les modifications, déployez-les sur le serveur Git et envoyez la compilation du pipeline :

cd ~/hello-cloudbuild-app git add cloudbuild.yaml git commit -m "Trigger CD pipeline" git push http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-app.git main gcloud builds submit --config=cloudbuild.yaml --substitutions=_SHORT_SHA=$(git rev-parse --short=7 HEAD),_COMMIT_SHA=$(git rev-parse HEAD) .

Cette opération déclenche le pipeline d'intégration continue dans Cloud Build, qui crée l'image de l'application et transfère un nouveau fichier manifeste kubernetes.yaml vers votre dépôt hello-cloudbuild-env.

3. Récupérez le fichier manifeste généré dans hello-cloudbuild-env et déclenchez la compilation de déploiement de la livraison continue (CD) :

cd ~/hello-cloudbuild-env git pull http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-env.git candidate gcloud builds submit --config=cloudbuild.yaml --substitutions=_COMMIT_SHA=$(git rev-parse HEAD) .

Cliquez sur Vérifier ma progression pour valider l'objectif. Créer un environnement de test et un pipeline CD

Tâche 7 : Examiner le pipeline Cloud Build

Dans cette tâche, vous allez examiner le pipeline Cloud Build dans la console.

1. Dans la console, accédez à Cloud Build > Historique.
2. Cliquez sur la compilation la plus récente pour suivre son exécution et examiner ses journaux.
3. Vérifiez que toutes les étapes du pipeline de compilation ont été exécutées avec succès.

Tâche 8 : Tester le pipeline complet

Vous avez maintenant configuré le pipeline CI/CD complet. Dans cette tâche, vous allez effectuer un test de bout en bout.

1. Dans la console, dans le menu de navigation (), cliquez sur Kubernetes Engine > Passerelles, services et entrées > Services.

La liste ne doit contenir qu'un seul service : hello-cloudbuild. Ce service a été créé par la compilation de livraison continue qui vient de s'exécuter.

2. Cliquez sur le point de terminaison associé au service hello-cloudbuild. Vous devriez voir la mention "Hello World!". Si le point de terminaison n'apparaît pas ou si vous constatez une erreur de l'équilibreur de charge, patientez quelques minutes afin que l'équilibreur de charge puisse terminer son initialisation. Si nécessaire, cliquez sur Actualiser pour mettre à jour la page.

3. Dans Cloud Shell, remplacez "Hello World" par "Hello Cloud Build" dans l'application et dans le test unitaire :

cd ~/hello-cloudbuild-app sed -i 's/Hello World/Hello Cloud Build/g' app.py sed -i 's/Hello World/Hello Cloud Build/g' test_app.py

4. Validez la modification et déployez-la sur le serveur Git, puis envoyez la compilation CI :

git add app.py test_app.py git commit -m "Hello Cloud Build" git push http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-app.git main gcloud builds submit --config=cloudbuild.yaml --substitutions=_SHORT_SHA=$(git rev-parse --short=7 HEAD),_COMMIT_SHA=$(git rev-parse HEAD) .

5. Récupérez le fichier manifeste mis à jour dans hello-cloudbuild-env et envoyez la compilation du pipeline de déploiement pour déployer la nouvelle version de l'application :

cd ~/hello-cloudbuild-env git pull http://giteaadmin:GiteaPassword123@${GIT_SERVER_IP}:3000/giteaadmin/hello-cloudbuild-env.git candidate gcloud builds submit --config=cloudbuild.yaml --substitutions=_COMMIT_SHA=$(git rev-parse HEAD) .

Attendez quelques minutes, puis actualisez l'application dans votre navigateur. Vous devriez maintenant voir la mention "Hello Cloud Build!".

Tâche 9 : Tester le rollback

Dans cette tâche, vous allez effectuer un rollback vers la version de l'application qui affiche le message "Hello World!".

1. Dans la barre de titre de la console, saisissez Tableau de bord Cloud Build dans le champ Recherche, puis cliquez sur Cloud Build dans les résultats de recherche. Assurez-vous que Historique est sélectionné dans le volet de gauche.
2. Cliquez sur l'avant-dernière compilation disponible dans l'historique de compilation.
3. Cliquez sur Recompiler.

Une fois la compilation terminée, rechargez l'application dans votre navigateur. Vous devriez maintenant voir à nouveau le message "Hello World!".

Félicitations !

Vous pouvez désormais utiliser Cloud Build pour créer des pipelines d'intégration continue et effectuer un rollback avec GKE sur Google Cloud.

Formations et certifications Google Cloud

Les formations et certifications Google Cloud vous aident à tirer pleinement parti des technologies Google Cloud. Nos cours portent sur les compétences techniques et les bonnes pratiques à suivre pour être rapidement opérationnel et poursuivre votre apprentissage. Nous proposons des formations pour tous les niveaux, à la demande, en salle et à distance, pour nous adapter aux emplois du temps de chacun. Les certifications vous permettent de valider et de démontrer vos compétences et votre expérience en matière de technologies Google Cloud.

Dernière mise à jour du manuel : 20 juillet 2026

Dernier test de l'atelier : 20 juillet 2026

Copyright 2026 Google LLC. Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms d'entreprises et de produits peuvent être des marques des entreprises auxquelles ils sont associés.