GSP1077

Présentation

Dans cet atelier, vous allez créer un pipeline 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 :

• le dépôt de l'application ("app") qui contient le code source de l'application ;
• le dépôt de l'environnement ("env") qui contient les fichiers manifestes pour le 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 transfère cette image 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. Les principaux utilisateurs du dépôt "app" sont des personnes réelles, et ce dépôt est dédié à une application spécifique. Les principaux utilisateurs du dépôt "env" sont des systèmes automatisés (comme Cloud Build), et ce dépôt peut être partagé par plusieurs applications. Le dépôt "env" peut contenir plusieurs branches, chacune d'elles correspondant à un environnement spécifique (vous n'utiliserez que l'environnement de production dans cet atelier) 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 dans Cloud Source Repositories
• Déclencher une compilation Cloud Build à partir de Cloud Source Repositories
• 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 vous-même les activités dans un véritable environnement cloud, et non dans un environnement de simulation ou de démonstration. Nous vous fournissons des identifiants temporaires pour 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/navigation privée pour effectuer cet atelier. Vous éviterez ainsi les conflits entre votre compte personnel et le temporaire étudiant, qui pourraient entraîner des frais supplémentaires facturés sur votre compte personnel.

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

Remarque : Si vous possédez déjà votre propre compte ou projet Google Cloud, veillez à ne pas l'utiliser pour réaliser cet atelier afin d'éviter que des frais supplémentaires ne vous soient facturés.

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, 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
   • 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. 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 inclus dans le panneau Détails concernant l'atelier et collez-le dans la boîte de dialogue Se connecter. Cliquez sur Suivant.

4. Copiez le mot de passe inclus dans le panneau Détails concernant l'atelier et collez-le dans la boîte de dialogue de bienvenue. Cliquez sur Suivant.

   Important : Vous devez utiliser les identifiants fournis dans le panneau de gauche. Ne saisissez pas vos identifiants Google Cloud Skills Boost. Remarque : Si vous utilisez votre propre compte Google Cloud pour cet atelier, des frais supplémentaires peuvent vous être facturés.

5. 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 aux essais offerts.

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

Remarque : Vous pouvez afficher le menu qui contient la liste des produits et services Google Cloud en cliquant sur le menu de navigation en haut à gauche.

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.

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 YOUR_PROJECT_ID (VOTRE_ID_PROJET) pour cette session :

Your Cloud Platform project in this session is set to YOUR_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.

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

gcloud auth list

3. Cliquez sur Autoriser.

4. Vous devez à présent obtenir le résultat suivant :

Résultat :

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net 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 = <ID_Projet>

Exemple de résultat :

[core] project = qwiklabs-gcp-44776a13dea667a6 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

1. Dans Cloud Shell, définissez 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

Dans la tâche suivante, 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, Cloud Source Repositories et Container Analysis :

gcloud services enable container.googleapis.com \ cloudbuild.googleapis.com \ sourcerepo.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. Si vous n'avez jamais utilisé Git dans Cloud Shell, configurez-le en indiquant votre nom et votre adresse e-mail. Git les utilisera pour vous identifier en tant qu'auteur des commits que vous allez créer dans Cloud Shell (si vous n'avez pas de compte GitHub, vous pouvez simplement saisir vos informations actuelles ; vous n'avez pas besoin de compte pour cet atelier) :

git config --global user.email "vous@example.com" git config --global user.name "Votre nom"

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 Cloud Source Repositories

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 :

gcloud source repos create hello-cloudbuild-app gcloud source repos create hello-cloudbuild-env

2. Clonez l'exemple de code depuis GitHub :

cd ~ git clone https://github.com/GoogleCloudPlatform/gke-gitops-tutorial-cloudbuild hello-cloudbuild-app

3. Configurez Cloud Source Repositories 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 remote add google "https://source.developers.google.com/p/${PROJECT_ID}/r/hello-cloudbuild-app"

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)

Cliquez sur Vérifier ma progression pour valider l'objectif. Créer les dépôts Git

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

Le code que vous avez cloné contient déjà le Dockerfile suivant :

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, accédez à Artifact Registry > Dépôts dans la console Cloud pour vérifier que votre image de conteneur est bien disponible dans Artifact Registry. Cliquez sur my-repository.

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 à Cloud Source Repositories déclenche automatiquement ce pipeline. Le fichier cloudbuild.yaml (déjà inclus dans le code) correspond à sa configuration.

1. Dans la console Cloud, accédez à Cloud Build > Déclencheurs.
2. Cliquez sur Créer un déclencheur.
3. Dans le champ "Nom", saisissez hello-cloudbuild.
4. Sous Événement, sélectionnez Déployer sur une branche.
5. Sous Source, sélectionnez le dépôt hello-cloudbuild-app et la branche .* (n'importe quelle branche).
6. Sous Configuration de la compilation, sélectionnez Fichier de configuration Cloud Build.
7. Dans le champ Emplacement du fichier de configuration Cloud Build, saisissez cloudbuild.yaml après la barre oblique (/).
8. Cliquez sur Créer.

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

9. 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

10. Dans la console Cloud, accédez à Cloud Build > Tableau de bord.

11. 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 : Créer un environnement de test et un pipeline CD

Cloud Build est également utilisé 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 :

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. Pour l'instant, le dépôt ne contient aucun fichier.

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

cd ~ gcloud source repos clone hello-cloudbuild-env cd ~/hello-cloudbuild-env git checkout -b production

3. Vous devez ensuite copier le fichier cloudbuild-delivery.yaml disponible dans le dépôt hello-cloudbuild-app et valider la modification :

cd ~/hello-cloudbuild-env cp ~/hello-cloudbuild-app/cloudbuild-delivery.yaml ~/hello-cloudbuild-env/cloudbuild.yaml git add . git commit -m "Create cloudbuild.yaml for deployment"

Le fichier cloudbuild-delivery.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.

4. Créez une branche candidate, puis transférez les deux branches vers Cloud Source Repositories pour qu'elles soient accessibles :

git checkout -b candidate git push origin production git push origin candidate

5. Accordez le rôle IAM "Rédacteur de dépôt source" au compte de service Cloud Build pour le dépôt hello-cloudbuild-env :

PROJECT_NUMBER="$(gcloud projects describe ${PROJECT_ID} \ --format='get(projectNumber)')" cat >/tmp/hello-cloudbuild-env-policy.yaml <<EOF bindings: - members: - serviceAccount:${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com role: roles/source.writer EOF gcloud source repos set-iam-policy \ hello-cloudbuild-env /tmp/hello-cloudbuild-env-policy.yaml

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

1. Dans la console Cloud, accédez à Cloud Build > Déclencheurs.
2. Cliquez sur Créer un déclencheur.
3. Dans le champ "Nom", saisissez hello-cloudbuild-deploy.
4. Sous Événement, sélectionnez Déployer sur une branche.
5. Sous Source, sélectionnez le dépôt hello-cloudbuild-env et la branche ^candidate$.
6. Sous Configuration de la compilation, sélectionnez Fichier de configuration Cloud Build.
7. Dans le champ Emplacement du fichier de configuration Cloud Build, saisissez cloudbuild.yaml après la barre oblique (/).
8. Cliquez sur Créer.

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.

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

cd ~/hello-cloudbuild-app cp cloudbuild-trigger-cd.yaml cloudbuild.yaml

Le fichier cloudbuild-trigger-cd.yaml est une version étendue du fichier cloudbuild.yaml. Il ajoute les étapes mentionnées ci-dessous, qui permettent de générer le nouveau fichier manifeste Kubernetes et de déclencher le pipeline de livraison continue.

Ce pipeline utilise un simple script sed pour générer le modèle de manifeste. En situation réelle, vous pouvez plutôt utiliser un outil dédié comme Kustomize ou Skaffold. Ces outils offrent un plus grand contrôle sur la génération des modèles de manifeste.

2. Validez les modifications et déployez-les sur Cloud Source Repositories :

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 6 : Examiner le pipeline Cloud Build

1. Dans la console Cloud, accédez à Cloud Build > Tableau de bord.
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 son nom pour suivre son exécution et examiner ses journaux.

Tâche 7 : Tester le pipeline complet

Le pipeline CI/CD complet est maintenant configuré. Testez-le d'un bout à l'autre.

1. Dans la console Cloud, accédez à Kubernetes Engine > Passerelles, services et entrées.

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 Cloud Source Repositories :

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 8 : 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 console Cloud, accédez à Cloud Build > Tableau de bord.
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 : 26 janvier 2024

Dernier test de l'atelier : 19 janvier 2024

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