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 créer deux dépôts Git :

• app : contient le code source de l'application
• env : contient les fichiers manifestes de déploiement Kubernetes

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
• Créer des dépôts GitHub
• Déclencher Cloud Build à partir de dépôts GitHub
• Automatiser les tests et publier une image de conteneur déployable via 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 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 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 et le numéro de votre projet 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 et le numéro de votre projet. Enregistrez-les en tant que variables PROJECT_ID et PROJECT_NUMBER :

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

Ensuite, vous allez préparer votre projet Google Cloud en activant les API nécessaires, en configurant Git dans Cloud Shell et en téléchargeant l'exemple de code utilisé plus tard dans l'atelier.

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 et GitHub dans Cloud Shell : curl -sS https://webi.sh/gh | sh gh auth login gh api user -q ".login" GITHUB_USERNAME=$(gh api user -q ".login") git config --global user.name "${GITHUB_USERNAME}" git config --global user.email "${USER_EMAIL}" echo ${GITHUB_USERNAME} echo ${USER_EMAIL}

Appuyez sur Entrée pour accepter les options par défaut. Lisez les instructions de l'outil CLI pour vous connecter à GitHub avec un navigateur Web. Si vous êtes connecté, votre nom d'utilisateur GitHub s'affiche.

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 : Créer les dépôts Git dans GitHub

GitHub est une plate-forme qui vous permet de stocker du code, de le partager et de collaborer à son écriture avec d'autres utilisateurs. Git est un système de contrôle des versions. Lorsque vous importez des fichiers dans GitHub, vous les stockez dans un "dépôt Git". Cela signifie que lorsque vous apportez des modifications (ou "commits") à vos fichiers dans GitHub, Git commence automatiquement à suivre et à gérer vos modifications. Pour en savoir plus, consultez À propos de GitHub et Git.

Dans cette tâche, vous allez créer les deux dépôts Git (hello-cloudbuild-app et hello-cloudbuild-env), puis initialiser hello-cloudbuild-app avec un exemple de code.

1. Dans Cloud Shell, exécutez la commande suivante pour créer les deux dépôts Git :

gh repo create hello-cloudbuild-app --private gh repo create hello-cloudbuild-env --private

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

cd ~ mkdir hello-cloudbuild-app gcloud storage cp -r gs://spls/gsp1077/gke-gitops-tutorial-cloudbuild/* hello-cloudbuild-app

3. Configurez le dépôt GitHub en tant que dépôt distant :

cd ~/hello-cloudbuild-app export REGION={{{project_0.default_region | "REGION"}}} sed -i "s/us-central1/$REGION/g" cloudbuild.yaml sed -i "s/us-central1/$REGION/g" cloudbuild-delivery.yaml sed -i "s/us-central1/$REGION/g" cloudbuild-trigger-cd.yaml sed -i "s/us-central1/$REGION/g" kubernetes.yaml.tpl PROJECT_ID=$(gcloud config get-value project) git init git config credential.helper gcloud.sh git remote add google https://github.com/${GITHUB_USERNAME}/hello-cloudbuild-app git branch -m master git add . && git commit -m "initial commit"

Le code que vous venez de cloner 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.7-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 un pipeline d'intégration continue (CI)

Dans cette tâche, vous allez configurer Cloud Build afin qu'il exécute automatiquement un petit test unitaire, qu'il génère l'image de conteneur, puis qu'il la transfère vers Artifact Registry. L'envoi d'un nouveau commit à des dépôts GitHub déclenche automatiquement ce pipeline.

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

1. Dans la barre de titre de la console, saisissez Déclencheurs Cloud Build dans le champ Recherche, puis cliquez sur Déclencheurs, Cloud Build dans les résultats de recherche.

2. Cliquez sur Créer un déclencheur.

3. Dans le champ Nom, saisissez hello-cloudbuild. Définissez le champ Région sur .

4. Définissez Événement sur Déployer sur une branche.

5. Sous Source, pour Dépôt, cliquez sur Associer un nouveau dépôt.

   a. Sélectionnez GitHub (application GitHub Cloud Build). Cliquez sur Continuer.

   b. Authentifiez-vous auprès de votre dépôt source à l'aide de votre nom d'utilisateur et de votre mot de passe.

   c. Si le pop-up "L'application GitHub n'est installée sur aucun de vos dépôts" s'affiche, suivez ces étapes.

   i. Cliquez sur "Installer Google Cloud Build". Installez l'application GitHub Cloud Build dans votre compte personnel. Autorisez l'installation à l'aide de votre compte GitHub. ii. Sous "Repository access" (Accès aux dépôts), choisissez "Only select repositories" (Uniquement certains dépôts). Cliquez sur le menu "Select the repositories" (Sélectionner les dépôts), puis sélectionnez "${GITHUB_USERNAME}/hello-cloudbuild-app" et "${GITHUB_USERNAME}/hello-cloudbuild-env". iii. Cliquez sur "Installer".

   d. Sélectionnez ${GITHUB_USERNAME}/hello-cloudbuild-app pour le dépôt. Cliquez sur OK.

   e. Cochez la case Je comprends que le contenu GitHub pour les dépôts sélectionnés….

   f. Cliquez sur Se connecter.

6. Si l'application GitHub Cloud Build est déjà installée dans votre compte, vous pouvez modifier les dépôts sur GitHub.

   a. Sous Repository access (Accès aux dépôts), sélectionnez Only select repositories (Uniquement certains dépôts). Cliquez sur le menu Select repositories (Sélectionner les dépôts), puis sélectionnez les dépôts "$${GITHUB_USERNAME}/hello-cloudbuild-app" et "$${GITHUB_USERNAME}/hello-cloudbuild-env".

   b. Cliquez sur Enregistrer.

7. Sur la page "Déclencheur", dans la liste des dépôts, cliquez sur ${GITHUB_USERNAME}/hello-cloudbuild-app.

8. Pour Branche, saisissez .* (n'importe quelle branche).

9. Dans la section Configuration, définissez le Type sur Fichier de configuration Cloud Build.

10. Dans le champ Emplacement, saisissez cloudbuild.yaml après la barre oblique (/).

11. Définissez Compte de service sur le Compte de service Compute Engine par défaut.

12. Cliquez sur Créer.

Une fois le déclencheur créé, revenez à Cloud Shell. Vous devez maintenant envoyer le code de l'application aux dépôts GitHub pour déclencher le pipeline CI dans Cloud Build.

13. Pour lancer ce déclencheur, exécutez la commande suivante :

cd ~/hello-cloudbuild-app git add . git commit -m "Type Any Commit Message here" git push google master

14. Dans le volet de gauche, cliquez sur Tableau de bord.

15. Vous devriez constater qu'une compilation est en cours d'exécution ou s'est achevée récemment. Vous pouvez cliquer sur son nom pour suivre son exécution et examiner ses journaux.

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

Tâche 5 : Accéder à GitHub à partir d'une compilation via des clés SSH

Dans cette étape, vous allez utiliser Secret Manager avec Cloud Build pour accéder à des dépôts GitHub privés.

Créer une clé SSH

1. Dans Cloud Shell, accédez au répertoire d'accueil.

   cd ~

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

   mkdir workingdir cd workingdir

3. Créez une clé SSH GitHub et remplacez [your-github-email] par votre adresse e-mail GitHub personnelle :

   ssh-keygen -t rsa -b 4096 -N '' -f id_github -C [your-github-email]

Cette étape crée deux fichiers, id_github et id_github.pub.

4. Dans la barre d'actions de Cloud Shell, cliquez sur Plus (), puis sur Télécharger > Afficher/Masquer l'explorateur de fichiers. Sélectionnez le menu déroulant et le dossier workingdir pour télécharger le fichier id_github sur votre ordinateur local.

Stocker la clé SSH privée dans Secret Manager

1. Dans la barre de titre de la console, saisissez Secret Manager, puis cliquez sur Secret Manager dans les résultats de recherche.

2. Cliquez sur Créer un secret.

3. Définissez le champ Nom sur ssh_key_secret.

4. Définissez Valeur du secret sur Importer et importez votre fichier id_github.

5. Conservez les valeurs par défaut des autres paramètres.

6. Cliquez sur Créer un secret.

Le fichier id_github est alors importé dans Secret Manager.

Ajouter la clé SSH publique aux clés de déploiement de votre dépôt privé

1. Connectez-vous à votre compte GitHub personnel.

2. Dans l'angle supérieur droit, cliquez sur votre photo de profil, puis sur Your profile (Votre profil).

3. Sur la page de votre profil, cliquez sur Repositories (Dépôts), puis sur le dépôt hello-cloudbuild-env.

4. Dans votre dépôt, cliquez sur Settings (Paramètres).

5. Dans le volet de gauche, cliquez sur Deploy Keys (Clés de déploiement), puis sur Add deploy key (Ajouter une clé de déploiement).

6. Indiquez le titre SSH_KEY et collez votre clé SSH publique, que vous trouverez dans workingdir/id_github.pub depuis Cloud Shell.

7. Sélectionnez Allow write access (Autoriser l'accès en écriture) pour que cette clé dispose d'un accès en écriture au dépôt. Une clé de déploiement disposant d'un accès en écriture permet au déploiement d'envoyer des modifications vers le dépôt.

8. Cliquez sur Add key (Ajouter la clé).

9. Supprimez la clé SSH de votre disque :

   rm id_github*

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

Saisissez la commande suivante pour accorder au compte de service l'accès à Secret Manager :

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. Accéder à GitHub à partir d'une compilation via des clés SSH

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 réussis et en échec.
• 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 Identity and Access Management "Développeur sur Kubernetes Engine".

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

cd ~ 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.

Pour commencer, vous devez cloner le dépôt hello-cloudbuild-env et créer la branche de production, qui est encore vide.

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

mkdir hello-cloudbuild-env gcloud storage cp -r gs://spls/gsp1077/gke-gitops-tutorial-cloudbuild/* hello-cloudbuild-env cd hello-cloudbuild-env export REGION={{{project_0.default_region | "REGION"}}} sed -i "s/us-central1/$REGION/g" cloudbuild.yaml sed -i "s/us-central1/$REGION/g" cloudbuild-delivery.yaml sed -i "s/us-central1/$REGION/g" cloudbuild-trigger-cd.yaml sed -i "s/us-central1/$REGION/g" kubernetes.yaml.tpl

3. Pour que Cloud Build se connecte à GitHub, vous devez ajouter la clé SSH publique au fichier known_hosts dans l'environnement de compilation de Cloud Build. Dans votre répertoire hello-cloudbuild-env, créez un fichier nommé known_hosts.github, ajoutez-y la clé SSH publique et accordez les autorisations nécessaires à ce fichier :

cd ~/hello-cloudbuild-env ssh-keyscan -t rsa github.com > known_hosts.github chmod +x known_hosts.github git init git config credential.helper gcloud.sh git remote add google https://github.com/${GITHUB_USERNAME}/hello-cloudbuild-env git branch -m master git add . && git commit -m "initial commit" git push google master cd ~/hello-cloudbuild-env git checkout -b production

4. Ensuite, remplacez le fichier cloudbuild.yaml disponible dans le dépôt hello-cloudbuild-env et validez la modification :

cd ~/hello-cloudbuild-env

5. Remplacez le fichier cloudbuild.yaml du dépôt hello-cloudbuild-env par le code ci-dessous. Remplacez {GITHUB-USERNAME} par votre nom d'utilisateur GitHub personnel :

# 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. # [START cloudbuild-delivery] 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' # Access the id_github file from Secret Manager, and setup SSH - name: 'gcr.io/cloud-builders/git' secretEnv: ['SSH_KEY'] entrypoint: 'bash' args: - -c - | echo "$$SSH_KEY" >> /root/.ssh/id_rsa chmod 400 /root/.ssh/id_rsa cp known_hosts.github /root/.ssh/known_hosts volumes: - name: 'ssh' path: /root/.ssh # Clone the repository - name: 'gcr.io/cloud-builders/git' args: - clone - --recurse-submodules - git@github.com:${GITHUB-USERNAME}/hello-cloudbuild-env.git volumes: - name: ssh path: /root/.ssh # This step copies the applied manifest to the production branch # The COMMIT_SHA variable is automatically # replaced by Cloud Build. - name: 'gcr.io/cloud-builders/gcloud' id: Copy to production branch entrypoint: /bin/sh args: - '-c' - | set -x && \ cd hello-cloudbuild-env && \ git config user.email $(gcloud auth list --filter=status:ACTIVE --format='value(account)') sed "s/GOOGLE_CLOUD_PROJECT/${PROJECT_ID}/g" kubernetes.yaml.tpl | \ git fetch origin production && \ # Switch to the production branch and copy the kubernetes.yaml file from the candidate branch git checkout production && \ git checkout $COMMIT_SHA kubernetes.yaml && \ # Commit the kubernetes.yaml file with a descriptive commit message git commit -m "Manifest from commit $COMMIT_SHA $(git log --format=%B -n 1 $COMMIT_SHA)" && \ # Push the changes back to Cloud Source Repository git push origin production volumes: - name: ssh path: /root/.ssh availableSecrets: secretManager: - versionName: projects/${PROJECT_NUMBER}/secrets/ssh_key_secret/versions/1 env: 'SSH_KEY' # [END cloudbuild-delivery] options: logging: CLOUD_LOGGING_ONLY git add . git commit -m "Create cloudbuild.yaml for deployment"

Le fichier cloudbuild.yaml décrit le processus de déploiement qui doit être exécuté dans Cloud Build. Ce processus comporte deux étapes :

• Cloud Build applique le fichier manifeste au cluster GKE.
• Si l'opération réussit, Cloud Build copie le fichier manifeste sur la branche de production.

6. Créez une branche candidate, puis transférez les deux branches vers GitHub pour qu'elles soient accessibles :

git checkout -b candidate git push google production git push google candidate

Créer le déclencheur pour le pipeline de livraison continue

1. Dans la barre de titre de la console, saisissez Déclencheurs Cloud Build, puis cliquez sur Déclencheurs, Cloud Build.

2. Cliquez sur Créer un déclencheur.

3. Définissez le Nom sur hello-cloudbuild-deploy. Définissez le champ Région sur .

4. Sous Événement, sélectionnez Déployer sur une branche.

5. Sous Source, pour Dépôt, cliquez sur Associer un nouveau dépôt.

   a. Sélectionnez GitHub (application GitHub Cloud Build). Cliquez sur Continuer.

   b. Authentifiez-vous auprès de votre dépôt source à l'aide de votre nom d'utilisateur et de votre mot de passe GitHub.

   c. Sélectionnez le dépôt ${GITHUB_USERNAME}/hello-cloudbuild-env. Cliquez sur OK.

   d. Cochez la case Je comprends que le contenu GitHub pour les dépôts sélectionnés….

   e. Cliquez sur Se connecter.

6. Sous Dépôt, sélectionnez ${GITHUB_USERNAME}/hello-cloudbuild-env.

7. Sous Source, sélectionnez la branche ^candidate$.

8. Sous Configuration de la compilation, sélectionnez Fichier de configuration Cloud Build.

9. Dans le champ Emplacement du fichier de configuration Cloud Build, saisissez cloudbuild.yaml après la barre oblique (/).

10. Définissez Compte de service sur le compte de service Compute Engine par défaut.

11. Cliquez sur Créer.

12. Dans votre répertoire hello-cloudbuild-app, créez un fichier nommé known_hosts.github, ajoutez-y la clé SSH publique et accordez les autorisations nécessaires à ce fichier :

cd ~/hello-cloudbuild-app ssh-keyscan -t rsa github.com > known_hosts.github chmod +x known_hosts.github git add . git commit -m "Adding known_host file." git push google master

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

Maintenant, vous allez ajouter certaines étapes au pipeline d'intégration continue pour qu'il génère une nouvelle version du fichier manifeste Kubernetes, puis l'envoie au dépôt hello-cloudbuild-env afin de déclencher le pipeline de livraison continue.

• Copiez la version étendue du fichier cloudbuild.yaml pour le dépôt app :

cd ~/hello-cloudbuild-app

Le fichier cloudbuild.yaml ajoute les étapes qui permettent de générer le nouveau fichier manifeste Kubernetes et de déclencher le pipeline de livraison continue.

Configurer la compilation

1. Remplacez le fichier cloudbuild.yaml du dépôt hello-cloudbuild-app par le code ci-dessous. Remplacez ${GITHUB_USERNAME} par votre nom d'utilisateur GitHub :

# 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. # [START cloudbuild] steps: # This step runs the unit tests on the app - name: 'python:3.7-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 # The PROJECT_ID and SHORT_SHA variables are automatically # replaced by Cloud Build. - 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' # [END cloudbuild] # Access the id_github file from Secret Manager, and setup SSH - name: 'gcr.io/cloud-builders/git' secretEnv: ['SSH_KEY'] entrypoint: 'bash' args: - -c - | echo "$$SSH_KEY" >> /root/.ssh/id_rsa chmod 400 /root/.ssh/id_rsa cp known_hosts.github /root/.ssh/known_hosts volumes: - name: 'ssh' path: /root/.ssh # Clone the repository - name: 'gcr.io/cloud-builders/git' args: - clone - --recurse-submodules - git@github.com:${GITHUB-USERNAME}/hello-cloudbuild-env.git volumes: - name: ssh path: /root/.ssh # [START cloudbuild-trigger-cd] # This step clones the hello-cloudbuild-env repository - name: 'gcr.io/cloud-builders/gcloud' id: Change directory entrypoint: /bin/sh args: - '-c' - | cd hello-cloudbuild-env && \ git checkout candidate && \ git config user.email $(gcloud auth list --filter=status:ACTIVE --format='value(account)') volumes: - name: ssh path: /root/.ssh # 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 volumes: - name: ssh path: /root/.ssh # This step pushes the manifest back to hello-cloudbuild-env - 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 volumes: - name: ssh path: /root/.ssh availableSecrets: secretManager: - versionName: projects/${PROJECT_NUMBER}/secrets/ssh_key_secret/versions/1 env: 'SSH_KEY' # [END cloudbuild-trigger-cd] options: logging: CLOUD_LOGGING_ONLY Remarque : Ce pipeline utilise une simple commande sed pour générer le fichier manifeste à partir du modèle. En situation réelle, il peut être judicieux d'utiliser un outil dédié comme Kustomize ou Skaffold, car ils offrent un plus grand contrôle sur la génération des fichiers manifestes à partir des modèles.

2. Validez les modifications et déployez-les sur GitHub :

cd ~/hello-cloudbuild-app git add cloudbuild.yaml git commit -m "Trigger CD pipeline" git push google master

Cette opération déclenche le pipeline d'intégration continue dans Cloud Build.

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, toujours sur la page Cloud Build, cliquez sur Tableau de bord dans le volet de gauche.
2. Cliquez sur le déclencheur hello-cloudbuild-app pour suivre son exécution et examiner ses journaux. La dernière étape de ce pipeline consiste à envoyer le nouveau fichier manifeste au dépôt hello-cloudbuild-env, ce qui déclenche le pipeline de livraison continue.
3. Revenez au tableau de bord principal.
4. Vous devriez constater qu'une compilation est en cours d'exécution ou s'est achevée récemment pour le dépôt hello-cloudbuild-env.

Vous pouvez cliquer sur le nom de la compilation pour suivre son exécution et examiner ses journaux.

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 dans les dépôts GitHub :

git add app.py test_app.py git commit -m "Hello Cloud Build" git push google master

5. Cette opération déclenche le pipeline CI/CD complet.

Attendez quelques minutes, puis rechargez 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 Tableau de bord est sélectionné dans le volet de gauche.
2. Cliquez sur le lien Tout afficher sous Historique de compilation pour le dépôt hello-cloudbuild-env.
3. Cliquez sur la deuxième compilation la plus récente disponible.
4. 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 : 19 février 2025

Dernier test de l'atelier : 19 février 2025

Copyright 2025 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.