GSP051

Présentation

Dans cet atelier, vous allez apprendre à configurer un pipeline de livraison continue à l'aide de Jenkins dans Kubernetes Engine. Jenkins est le serveur d'automatisation incontournable pour les développeurs qui doivent intégrer régulièrement du code dans un dépôt partagé. La solution que vous allez créer dans cet atelier est semblable au diagramme suivant :

Dans le Cloud Architecture Center, consultez Jenkins sur Kubernetes Engine pour en savoir plus sur l'exécution de Jenkins dans Kubernetes.

Points abordés

Dans cet atelier, vous allez apprendre à exécuter Jenkins dans Kubernetes en effectuant les tâches suivantes :

• Provisionner une application Jenkins dans un cluster Kubernetes Engine
• Configurer une application Jenkins avec le gestionnaire de paquets Helm
• Explorer les fonctionnalités d'une application Jenkins
• Créer et utiliser un pipeline Jenkins

Conditions préalables

Cet atelier est d'un niveau avancé. Pour le suivre, vous devez au moins connaître les principes de base de la programmation shell, de Kubernetes et de Jenkins. Les ateliers suivants vous aideront à être rapidement opérationnel :

• Présentation de Docker
• Hello Node Kubernetes
• Gestion des déploiements avec Kubernetes Engine
• Configurer Jenkins sur Kubernetes Engine

Une fois que vous êtes prêt, faites défiler la page pour en savoir plus sur Kubernetes, Jenkins et la livraison continue.

Qu'est-ce que Kubernetes Engine ?

Kubernetes Engine est la version Google Cloud hébergée de Kubernetes, un puissant gestionnaire de clusters et système d'orchestration pour les conteneurs. Kubernetes est un projet Open Source qui peut être exécuté sur de nombreux environnements différents : des ordinateurs portables aux clusters multinœuds haute disponibilité, en passant par des machines virtuelles et des solutions Bare Metal. Comme indiqué précédemment, les applications Kubernetes sont basées sur des conteneurs. Ce sont des applications légères comprenant toutes les dépendances et bibliothèques nécessaires à leur exécution. Grâce à cette structure sous-jacente, les applications Kubernetes sont hautement disponibles, sécurisées et faciles à déployer. C'est le framework idéal pour les développeurs cloud.

Qu'est-ce que Jenkins ?

Jenkins est un serveur d'automatisation Open Source qui vous permet d'orchestrer en souplesse vos pipelines de compilation, de test et de déploiement. Avec Jenkins, les développeurs peuvent itérer rapidement des projets sans avoir à se soucier des frais supplémentaires parfois associés à la livraison continue.

Qu'est-ce que la livraison continue/le déploiement continu ?

Comparé à un déploiement standard basé sur des machines virtuelles (VM), le déploiement de Jenkins dans Kubernetes Engine offre des avantages considérables dans le cadre de la configuration d'un pipeline de livraison continue.

Lorsque votre processus de compilation utilise des conteneurs, un même hôte virtuel peut exécuter des jobs sur plusieurs systèmes d'exploitation. Kubernetes Engine fournit des exécuteurs de build éphémères qui sont utilisés uniquement en cas d'exécution active des builds, ce qui libère des ressources pour les autres tâches du cluster telles que les traitements par lot. L'autre avantage des exécuteurs de build éphémères est la rapidité, car ils se lancent en quelques secondes.

En outre, Kubernetes Engine inclut l'équilibreur de charge mondial de Google, qui vous offre la possibilité d'automatiser le routage du trafic Web vers vos instances. L'équilibreur de charge gère la terminaison SSL et utilise une adresse IP globale configurée avec le réseau backbone de Google. Associé à votre interface Web, cet équilibreur de charge permet de toujours guider les utilisateurs le plus rapidement possible vers une instance d'application.

Maintenant que vous en avez appris un peu plus sur Kubernetes, sur Jenkins et sur la façon dont ils interagissent dans un pipeline CD, découvrons comment créer un pipeline de ce type.

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 : Télécharger le code source

Dans cette tâche, vous allez télécharger le code source utilisé pour cet atelier.

1. Pour commencer, ouvrez une nouvelle session dans Cloud Shell et exécutez la commande suivante pour définir votre zone sur  :

gcloud config set compute/zone {{{project_0.default_zone}}}

2. Ensuite, copiez l'exemple de code de l'atelier :

gsutil cp gs://spls/gsp051/continuous-deployment-on-kubernetes.zip . unzip continuous-deployment-on-kubernetes.zip

3. Accédez maintenant au bon répertoire :

cd continuous-deployment-on-kubernetes

Tâche 2 : Provisionner Jenkins

Vous allez créer un cluster Kubernetes et autoriser Jenkins à accéder au dépôt GitHub et à Google Container Registry.

Créer un cluster Kubernetes

1. Exécutez la commande suivante pour provisionner un cluster Kubernetes :

gcloud container clusters create jenkins-cd \ --num-nodes 2 \ --machine-type e2-standard-2 \ --scopes "https://www.googleapis.com/auth/source.read_write,cloud-platform"

Cette étape peut prendre plusieurs minutes. Les niveaux d'accès supplémentaires autorisent l'accès de Jenkins au dépôt GitHub et à Google Container Registry.

Cliquez sur Vérifier ma progression pour valider la tâche exécutée. Si vous avez réussi à créer le cluster Kubernetes, vous verrez une note d'évaluation s'afficher.

Créer un cluster Kubernetes (zone : )

2. Avant de poursuivre, vérifiez que votre cluster est en cours d'exécution à l'aide de la commande suivante :

gcloud container clusters list

Récupérer les identifiants du cluster

1. Récupérez les identifiants de votre cluster :

gcloud container clusters get-credentials jenkins-cd

2. Ces identifiants permettent à Kubernetes Engine d'accéder au cluster que vous venez de provisionner. Vérifiez que vous pouvez vous y connecter en exécutant la commande suivante :

kubectl cluster-info

Tâche 3 : Configurer Helm

Helm est un gestionnaire de paquets qui facilite la configuration et le déploiement des applications Kubernetes. Après avoir installé Jenkins, vous pourrez configurer votre pipeline CI/CD.

Dans cette tâche, vous allez utiliser Helm pour installer Jenkins à partir du dépôt des charts.

1. Ajoutez le dépôt de charts de la version stable de Helm :

helm repo add jenkins https://charts.jenkins.io

2. Vérifiez que le dépôt est à jour :

helm repo update

Tâche 4 : Installer et configurer Jenkins

Lors de l'installation de Jenkins, vous pouvez utiliser un fichier values comme modèle pour fournir les valeurs de configuration nécessaires.

Vous allez utiliser un fichier values personnalisé pour configurer automatiquement votre cloud Kubernetes et ajouter les plug-ins nécessaires suivants :

• Kubernetes:latest
• Workflow-multibranch:latest
• Git:latest
• Configuration-as-code:latest
• Google-oauth-plugin:latest
• Google-source-plugin:latest
• Google-storage-plugin:latest

Cela permet à Jenkins de se connecter à votre cluster et à votre projet Google Cloud.

1. Dans la CLI Helm, déployez le chart avec vos paramètres de configuration :

helm install cd jenkins/jenkins -f jenkins/values.yaml --wait

Cette commande peut prendre quelques minutes pour s'exécuter.

Cliquez sur Vérifier ma progression pour valider la tâche exécutée. Si vous avez réussi à configurer un chart Jenkins, vous verrez une note d'évaluation s'afficher.

Configurer et installer Jenkins

2. Une fois l'exécution de la commande terminée, vérifiez que le pod Jenkins passe à l'état Running (En cours d'exécution) et que l'état du conteneur est "READY" (Prêt) :

kubectl get pods

Exemple de résultat :

NAME READY STATUS RESTARTS AGE cd-jenkins-7c786475dd-vbhg4 2/2 Running 0 1m

3. Configurez le compte de service Jenkins pour pouvoir le déployer dans le cluster :

kubectl create clusterrolebinding jenkins-deploy --clusterrole=cluster-admin --serviceaccount=default:cd-jenkins

Vous devez obtenir le résultat suivant :

clusterrolebinding.rbac.authorization.k8s.io/jenkins-deploy created

4. Exécutez la commande suivante à partir de Cloud Shell pour configurer le transfert de port vers l'interface utilisateur de Jenkins :

export POD_NAME=$(kubectl get pods --namespace default -l "app.kubernetes.io/component=jenkins-master" -l "app.kubernetes.io/instance=cd" -o jsonpath="{.items[0].metadata.name}") kubectl port-forward $POD_NAME 8080:8080 >> /dev/null &

5. À présent, vérifiez que le service Jenkins a bien été créé :

kubectl get svc

Exemple de résultat :

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE cd-jenkins 10.35.249.67 8080/TCP 3h cd-jenkins-agent 10.35.248.1 50000/TCP 3h kubernetes 10.35.240.1 443/TCP 9h

Vous utilisez le plug-in Kubernetes afin que les nœuds de compilation se lancent automatiquement si nécessaire lorsque le maître Jenkins les demande. Une fois leur travail terminé, ces nœuds sont arrêtés automatiquement et leurs ressources sont restituées au pool de ressources du cluster.

Notez que ce service expose les ports 8080 et 50000 à tous les pods correspondant au sélecteur (selector). Cela expose les ports d'enregistrement de l'interface utilisateur Web et du compilateur/de l'agent Jenkins dans le cluster Kubernetes. De plus, le service jenkins-ui est exposé via une adresse IP de cluster, et donc inaccessible depuis l'extérieur du cluster.

Tâche 5 : Se connecter à Jenkins

Récupérez le mot de passe administrateur et connectez-vous à l'interface de Jenkins.

1. Le chart Jenkins crée automatiquement un mot de passe administrateur pour vous. Pour le récupérer, exécutez la commande suivante :

printf $(kubectl get secret cd-jenkins -o jsonpath="{.data.jenkins-admin-password}" | base64 --decode);echo

2. Pour accéder à l'interface utilisateur de Jenkins, cliquez sur Aperçu sur le Web () > Prévisualiser sur le port 8080 dans la barre d'actions de Cloud Shell :

3. Si vous y êtes invité, connectez-vous avec le nom d'utilisateur admin et le mot de passe généré automatiquement.

Jenkins est maintenant configuré dans votre cluster Kubernetes. Il gérera les pipelines CI/CD automatisés que vous allez créer dans les sections qui suivent.

Tâche 6 : Analyser l'application

Dans cette tâche, vous allez déployer l'exemple d'application gceme dans votre pipeline de déploiement continu. Cette application est codée en langage Go et se situe dans le répertoire sample-app du dépôt. Lorsque vous exécutez le binaire gceme sur une instance Compute Engine, l'application affiche les métadonnées de cette dernière dans une fiche info.

L'application s'apparente à un microservice proposant deux modes de fonctionnement.

• En mode backend : gceme écoute le port 8080 et renvoie les métadonnées de l'instance Compute Engine au format JSON.
• En mode interface : gceme interroge le service backend gceme et affiche dans l'interface utilisateur le fichier JSON ainsi obtenu.

Tâche 7 : Déployer l'application

Vous allez déployer l'application dans deux environnements différents :

• Production : site en ligne auquel vos utilisateurs accèdent.
• Canary : site de moindre capacité recevant seulement une partie du trafic utilisateur. Cet environnement vous permet de valider votre logiciel avec du trafic en ligne, avant de le publier pour l'ensemble des utilisateurs.

1. Dans Google Cloud Shell, accédez au répertoire de l'exemple d'application :

cd sample-app

2. Créez l'espace de noms Kubernetes afin d'isoler logiquement le déploiement :

kubectl create ns production

3. Créez les déploiements de production et Canary, ainsi que les services, à l'aide de commandes kubectl apply :

kubectl apply -f k8s/production -n production kubectl apply -f k8s/canary -n production kubectl apply -f k8s/services -n production

Cliquez sur Vérifier ma progression pour valider la tâche exécutée. Si vous avez réussi à créer les déploiements, vous verrez une note d'évaluation s'afficher.

Créer des déploiements de production et Canary

Par défaut, seule une instance répliquée de l'interface est déployée. Avec la commande kubectl scale, assurez-vous qu'au moins quatre instances répliquées s'exécutent en permanence.

4. Pour augmenter la capacité des interfaces dans l'environnement de production, exécutez la commande suivante :

kubectl scale deployment gceme-frontend-production -n production --replicas 4

5. À présent, vérifiez que cinq pods s'exécutent pour l'interface, quatre pour le trafic de production et un pour la version Canary (les modifications apportées à la version Canary ne toucheront qu'un utilisateur sur cinq, soit 20 % des utilisateurs) :

kubectl get pods -n production -l app=gceme -l role=frontend

6. Vérifiez aussi que vous avez deux pods pour le backend, un pour l'environnement de production et un pour l'environnement Canary :

kubectl get pods -n production -l app=gceme -l role=backend

7. Récupérez l'adresse IP externe des services de production :

kubectl get service gceme-frontend -n production Remarque : Il peut s'écouler plusieurs minutes avant que l'adresse IP externe de l'équilibreur de charge apparaisse.

Exemple de résultat :

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE gceme-frontend LoadBalancer 10.79.241.131 104.196.110.46 80/TCP 5h

Collez l'adresse IP externe dans un navigateur pour afficher la fiche info, qui se présente comme suit :

8. À présent, enregistrez l'adresse IP de l'équilibreur de charge du service d'interface dans une variable d'environnement afin de pouvoir l'utiliser ultérieurement :

export FRONTEND_SERVICE_IP=$(kubectl get -o jsonpath="{.status.loadBalancer.ingress[0].ip}" --namespace=production services gceme-frontend)

9. Afin de vérifier que les deux services fonctionnent, ouvrez l'adresse IP externe de l'interface dans votre navigateur.

10. Vérifiez la version du service à l'aide de la commande suivante (qui devrait renvoyer 1.0.0) :

curl http://$FRONTEND_SERVICE_IP/version

Vous venez de déployer l'exemple d'application. Vous allez maintenant configurer un pipeline pour déployer vos modifications de manière continue et fiable.

Tâche 8 : Créer le pipeline Jenkins

Dans cette tâche, vous allez créer le pipeline Jenkins en suivant ces étapes :

• Créer un dépôt pour héberger le code source
• Ajouter des identifiants pour donner à Jenkins accès au dépôt de code
• Configurer un cloud Jenkins pour Kubernetes
• Authentifier Jenkins auprès du dépôt privé GitHub
• Créer le job Jenkins

Créer un dépôt pour héberger le code source de l'exemple d'application

1. Créez une copie de l'exemple d'application gceme et déployez-la dans un dépôt GitHub :

Dans Cloud Shell, exécutez les commandes suivantes pour configurer Git et GitHub :

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 dans le résultat de la commande pour vous connecter à GitHub avec un navigateur Web.

Une fois que vous êtes connecté, votre nom d'utilisateur GitHub s'affiche dans le résultat de Cloud Shell.

gh repo create default --private

Vous pouvez ignorer l'avertissement, car ce dépôt ne vous sera pas facturé.

git init

2. Initialisez le répertoire de l'exemple d'application comme son propre dépôt Git :

git config credential.helper gcloud.sh

3. Exécutez la commande suivante :

git remote add origin https://github.com/${GITHUB_USERNAME}/default

4. Ajoutez les fichiers, validez-les et déployez-les :

git add . git commit -m "Initial commit" git push origin master

Ajouter les identifiants du compte de service

Configurez vos identifiants de sorte que Jenkins puisse accéder au dépôt de code. Jenkins utilise les identifiants du compte de service de votre cluster pour télécharger le code à partir du dépôt GitHub.

1. Dans l'interface utilisateur Jenkins, cliquez sur Manage Jenkins (Gérer Jenkins) dans le menu de navigation de gauche, puis sur Security > Credentials (Sécurité > Identifiants).

2. Cliquez sur System (Système).

3. Cliquez sur Global credentials (unrestricted) (Identifiants globaux (illimités)).

4. Cliquez sur Add Credentials (Ajouter des identifiants) en haut à droite.

5. Sélectionnez Google Service Account from metadata (Compte de service Google à partir de métadonnées) dans le menu déroulant Kind (Genre).

6. Dans le champ ID, saisissez l'ID du projet, puis cliquez sur Create (Créer).

Remarque : L'ID du projet se trouve dans la section "DÉTAILS DE CONNEXION" de l'atelier.

Les identifiants globaux ont été ajoutés.

Configurer un cloud Jenkins pour Kubernetes

1. Dans l'interface utilisateur Jenkins, sélectionnez Manage Jenkins > Nodes (Gérer Jenkins > Nœuds).
2. Cliquez sur Clouds dans le volet de navigation de gauche.
3. Cliquez sur New cloud (Nouveau cloud).
4. Dans Cloud name (Nom du cloud), saisissez le nom de votre choix, puis sélectionnez Kubernetes en tant que Type.
5. Cliquez sur Create (Créer).
6. Dans le champ Jenkins URL (URL de Jenkins), saisissez http://cd-jenkins:8080.
7. Dans le champ Jenkins tunnel (Tunnel Jenkins), saisissez cd-jenkins-agent:50000.
8. Cliquez sur Save (Enregistrer).

Authentifier Jenkins auprès d'un dépôt privé GitHub à l'aide d'une clé SSH

Pour authentifier Jenkins auprès d'un dépôt privé GitHub à l'aide d'une clé SSH, procédez comme suit :

a. Générer la clé SSH

1. Créez une clé SSH GitHub et remplacez "your-github-email" par votre adresse e-mail GitHub :

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

2. Pour télécharger la clé privée (id_github) et la clé publique (id_github.pub) depuis votre ordinateur local, cliquez sur Plus () dans la barre d'actions de Cloud Shell, puis sélectionnez le dossier continuous-deployment-on-kubernetes/sample-app.

b. Ajouter la clé publique à GitHub

Après avoir généré la clé SSH, vous devez ajouter la clé publique à GitHub afin que Jenkins puisse accéder à vos dépôts.

1. Accédez à votre compte GitHub. Cliquez sur votre profil GitHub, puis accédez à Settings (Paramètres).

2. Dans le menu latéral, sélectionnez SSH and GPG keys (Clés SSH et GPG).

3. Cliquez sur New SSH key (Nouvelle clé SSH).

4. Saisissez SSH_KEY_LAB comme titre.

5. Dans le champ "Key" (Clé), collez le contenu de votre clé publique (id_github.pub) téléchargée à partir du chemin d'accès ~/continuous-deployment-on-kubernetes/sample-app/id_github.pub. Vous pouvez également ajouter un nom descriptif dans le champ "Title" (Titre).

6. Cliquez sur Add SSH key (Ajouter la clé SSH).

c. Configurer Jenkins pour utiliser la clé SSH

1. Accédez à Jenkins, puis sélectionnez Manage Jenkins (Gérer Jenkins) dans le tableau de bord principal.

2. Sélectionnez l'option Credentials (Identifiants).

3. Sous Stores scoped to Jenkins (Magasins limités à Jenkins), cliquez sur System (Système).

4. Cliquez sur Global credentials (unrestricted) (Identifiants globaux (illimités)).

5. Cliquez sur Add Credentials (Ajouter des identifiants).

6. Dans le menu déroulant Kind (Genre), sélectionnez SSH Username with private key (Nom d'utilisateur SSH avec clé privée).

7. Dans le champ "ID", saisissez _ssh_key.

8. Dans le champ Username (Nom d'utilisateur), saisissez [votre nom d'utilisateur GitHub].

9. Sélectionnez Enter directly (Saisir directement) pour la clé privée, puis cliquez sur Add (Ajouter). Collez le contenu du fichier id_github (téléchargé à partir de ~/continuous-deployment-on-kubernetes/sample-app/id_github).

10. Cliquez sur Create (Créer).

d. Ajouter la clé SSH publique aux hôtes connus

Dans Cloud Shell, créez un fichier nommé known_hosts.github et ajoutez-y la clé SSH publique.

ssh-keyscan -t rsa github.com > known_hosts.github chmod +x known_hosts.github cat known_hosts.github Remarque : Si des erreurs s'affichent dans Cloud Shell, appuyez sur CTRL+C, puis exécutez la commande ci-dessus.

e. Configurer une clé d'hôte connu

1. Dans le panneau de gauche, cliquez sur Dashboard > Manage Jenkins (Tableau de bord > Gérer Jenkins).

2. Sous Security (Sécurité), cliquez sur Security (Sécurité).

3. Sous Git Host Key Verification Configuration (Configuration de la validation des clés d'hôte Git), sélectionnez Manually provided keys (Clés fournies manuellement) dans le menu déroulant Host Key Verification Strategy (Stratégie de validation des clés d'hôte).

4. Collez le contenu du fichier known hosts.github dans Approved Host Keys (Clés d'hôte approuvées).

5. Cliquez sur Save (Enregistrer).

Créer le job Jenkins

Dans l'interface utilisateur Jenkins, suivez les étapes ci-dessous pour configurer un job de pipeline.

1. Cliquez sur Dashboard > New Item (Tableau de bord > Nouvel élément) dans le panneau de gauche.

2. Nommez le projet sample-app, puis choisissez l'option Multibranch Pipeline (Pipeline multibranche) et cliquez sur OK.

3. Sur la page suivante, dans la section Branch Sources (Sources des branches), sélectionnez Git dans le menu déroulant Add Source (Ajouter une source).

4. Collez l'adresse HTTPS clone URL (URL de clone HTTPS) du dépôt sample-app dans le champ Project Repository (Dépôt du projet). Remplacez ${GITHUB_USERNAME} par votre nom d'utilisateur GitHub :

git@github.com:${GITHUB_USERNAME}/default.git

5. Dans le menu Credentials (Identifiants), sélectionnez le nom github credentials (identifiants GitHub).

6. Sous la section Scan Multibranch Pipeline Triggers (Analyser les déclencheurs du pipeline multibranche), cochez la case Periodically if not otherwise run (Périodiquement, s'il ne s'exécute pas autrement), puis définissez la valeur Interval (Intervalle) sur 1 minute.

7. Conservez les valeurs par défaut des autres options, puis cliquez sur Save (Enregistrer).

Une fois que vous avez suivi cette procédure, une tâche nommée Branch indexing (Indexation des branches) s'exécute. Il s'agit d'un métajob qui identifie les branches de votre dépôt et vérifie qu'aucune modification n'a été introduite dans les branches existantes. Si vous cliquez sur "sample-app" en haut à gauche, le job master s'affiche.

Remarque : Il se peut que la première exécution du job maître échoue tant que vous n'aurez pas apporté les quelques modifications de code demandées à l'étape suivante.

Vous venez de créer un pipeline Jenkins. Vous allez maintenant créer l'environnement de développement pour l'intégration continue.

Tâche 9 : Créer l'environnement de développement

Les branches de développement représentent un ensemble d'environnements dans lesquels vos développeurs testent les modifications qu'ils apportent au code avant qu'elles ne soient intégrées sur le site en ligne. Ces environnements sont des versions réduites de votre application, mais vous devez les déployer avec les mêmes mécanismes que l'environnement en ligne.

Créer une branche de développement

Pour créer un environnement de développement à partir d'une branche de fonctionnalité, vous pouvez transférer la branche en question vers le serveur Git et laisser Jenkins déployer votre environnement.

Remarque : Si des erreurs s'affichent dans Cloud Shell, appuyez sur CTRL+C, puis exécutez la commande ci-dessous.

• Créez une branche de développement et déployez-la sur le serveur Git :

git checkout -b new-feature

Modifier la définition du pipeline

Le code du fichier Jenkinsfile qui définit ce pipeline utilise la syntaxe Groovy de pipeline Jenkins. L'ensemble d'un pipeline de compilation peut ainsi être défini dans un seul fichier Jenkinsfile qui accompagne votre code source. Les pipelines offrent des fonctionnalités extrêmement utiles telles que le chargement en parallèle, et ils requièrent l'approbation manuelle de l'utilisateur.

Pour que le pipeline fonctionne comme prévu, vous devez indiquer l'ID de votre projet dans le fichier Jenkinsfile.

1. Ouvrez le fichier Jenkinsfile dans l'éditeur de votre terminal, par exemple vi :

vi Jenkinsfile

2. Lancez l'éditeur :

i

3. Ajoutez la valeur PROJECT_ID dans REPLACE_WITH_YOUR_PROJECT_ID. La valeur PROJECT_ID correspond à l'ID de votre projet, qui se trouve dans la section DÉTAILS DE CONNEXION de l'atelier. Vous pouvez également exécuter gcloud config get-value project pour y accéder.

4. Définissez la valeur CLUSTER_ZONE sur . Pour obtenir cette valeur, exécutez la commande suivante : gcloud config get compute/zone.

PROJECT = "REPLACE_WITH_YOUR_PROJECT_ID" APP_NAME = "gceme" FE_SVC_NAME = "${APP_NAME}-frontend" CLUSTER = "jenkins-cd" CLUSTER_ZONE = "{{{project_0.default_zone}}}" IMAGE_TAG = "gcr.io/${PROJECT}/${APP_NAME}:${env.BRANCH_NAME}.${env.BUILD_NUMBER}" JENKINS_CRED = "${PROJECT}"

5. Pour enregistrer le fichier Jenkinsfile, appuyez sur la touche ÉCHAP, puis (si vous utilisez vi) saisissez :

:wq

Modifier le site

Pour illustrer un changement dans l'application, vous allez faire passer la couleur des fiches gceme du bleu à l'orange.

1. Ouvrez html.go :

vi html.go

2. Lancez l'éditeur :

i

3. Remplacez les deux occurrences de <div class="card blue"> par ce qui suit :

<div class="card orange">

4. Pour enregistrer le fichier html.go, appuyez sur ÉCHAP, puis saisissez :

:wq

5. Ouvrez le fichier main.go :

vi main.go

6. Lancez l'éditeur :

i

7. La version est définie sur cette ligne :

const version string = "1.0.0"

Modifiez-la comme suit :

const version string = "2.0.0"

8. Enregistrez à nouveau le fichier main.go. Pour ce faire, appuyez sur ÉCHAP, puis saisissez :

:wq

Tâche 10 : Démarrer le déploiement

Dans cette tâche, vous allez déployer votre environnement de développement.

1. Validez et publiez vos modifications :

git add Jenkinsfile html.go main.go git commit -m "Version 2.0.0" git push origin new-feature

Vous lancez ainsi une compilation de votre environnement de développement.

Une fois la modification déployée dans le dépôt Git, accédez à l'interface utilisateur Jenkins. Celle-ci indique que votre compilation a été lancée pour la branche new-feature. La prise en compte des modifications peut demander jusqu'à une minute.

2. Lorsque la compilation s'exécute, cliquez sur la flèche vers le bas à côté de build (compilation) dans le menu de navigation de gauche, puis sélectionnez Console output (Résultat de la console) :

3. Attendez quelques minutes pour voir apparaître les premiers messages kubectl --namespace=new-feature apply... dans le résultat de la compilation. La branche new-feature est maintenant déployée dans votre cluster.

Remarque : Dans un scénario de développement, vous n'utiliseriez pas d'équilibreur de charge public. Vous pouvez sécuriser votre application avec le proxy kubectl. Ce proxy s'authentifie auprès de l'API Kubernetes et traite les demandes envoyées de votre machine locale au service dans le cluster sans exposer votre service à Internet.

Si vous n'avez rien vu apparaître dans Build Executor, ne vous inquiétez pas. Il suffit d'accéder à la page d'accueil Jenkins > sample app. Vérifiez que le nouveau pipeline new-feature a été créé.

4. Une fois ces opérations effectuées, lancez le proxy en arrière-plan :

kubectl proxy &

5. S'il se bloque, appuyez sur CTRL+C pour quitter. Pour vérifier que votre application est accessible, envoyez une requête à localhost et laissez le proxy kubectl la transférer à votre service :

curl \ http://localhost:8001/api/v1/namespaces/new-feature/services/gceme-frontend:80/proxy/version

Vous recevrez en réponse "2.0.0", ce qui correspond à la version en cours d'exécution.

Il se peut que vous receviez une erreur semblable à celle-ci :

{ "kind": "Status", "apiVersion": "v1", "metadata": { }, "status": "Failure", "message": "no endpoints available for service \"gceme-frontend:80\"", "reason": "ServiceUnavailable", "code": 503

6. Cela signifie que votre point de terminaison de l'interface ne s'est pas encore propagé. Patientez un peu et essayez de réexécuter la commande curl. Continuez lorsque vous obtenez le résultat suivant :

2.0.0

Vous venez de configurer l'environnement de développement. Vous allez maintenant exploiter les connaissances acquises durant le module précédent et déployer une version Canary pour tester une nouvelle fonctionnalité.

Cliquez sur Vérifier ma progression pour valider la tâche exécutée. Si vous avez réussi à lancer la compilation de la branche new-feature, vous verrez une note d'évaluation s'afficher.

Lancer une compilation de la branche new-feature

Tâche 11 : Déployer une version Canary

Vous avez vérifié que votre application exécute le dernier code de l'environnement de développement. Vous allez maintenant déployer ce code dans l'environnement Canary.

1. Créez une branche Canary et déployez-la sur le serveur Git :

git checkout -b canary git push origin canary

2. Dans Jenkins, vous devriez voir que le pipeline Canary a démarré. Lorsqu'il a terminé, vous pouvez vérifier l'URL du service pour vous assurer que votre nouvelle version livre une partie du trafic. Environ une requête sur cinq (sans ordre particulier) doit renvoyer la version 2.0.0.

export FRONTEND_SERVICE_IP=$(kubectl get -o \ jsonpath="{.status.loadBalancer.ingress[0].ip}" --namespace=production services gceme-frontend) while true; do curl http://$FRONTEND_SERVICE_IP/version; sleep 1; done

3. Si la version 1.0.0 apparaît systématiquement, essayez de réexécuter les commandes ci-dessus. Après avoir vérifié que tout fonctionne, arrêtez les commandes en appuyant sur CTRL+C.

Et voilà ! Vous avez déployé une version Canary. Vous allez maintenant déployer la nouvelle version en production.

Cliquez sur Vérifier ma progression pour valider la tâche exécutée. Si vous avez réussi à déployer la version Canary, vous verrez une note d'évaluation s'afficher.

Déployer une version Canary

Tâche 12 : Déployer en production

Maintenant que notre version Canary est publiée et que nous n'avons reçu aucune réclamation de client, nous pouvons déployer tout notre parc de production.

1. Créez une branche Canary et déployez-la sur le serveur Git :

git checkout master git merge canary git push origin master

Dans Jenkins, vous devriez voir que le pipeline maître a démarré.

Cliquez sur Vérifier ma progression pour valider la tâche exécutée. Si vous avez réussi à lancer le pipeline maître, vous verrez une note d'évaluation s'afficher.

Déployer en production

2. Une fois l'opération terminée (ce qui peut prendre quelques minutes), vous pouvez vérifier l'URL du service pour vous assurer que c'est bien la nouvelle version 2.0.0 qui livre la totalité du trafic.

export FRONTEND_SERVICE_IP=$(kubectl get -o \ jsonpath="{.status.loadBalancer.ingress[0].ip}" --namespace=production services gceme-frontend) while true; do curl http://$FRONTEND_SERVICE_IP/version; sleep 1; done

3. Comme précédemment, si vous voyez la version 1.0.0 apparaître, essayez de réexécuter les commandes ci-dessus. Pour les arrêter, appuyez sur CTRL+C.

Exemple de résultat :

gcpstaging9854_student@qwiklabs-gcp-df93aba9e6ea114a:~/continuous-deployment-on-kubernetes/sample-app$ while true; do curl http://$FRONTEND_SERVICE_IP/version; sleep 1; done 2.0.0 2.0.0 2.0.0 2.0.0 2.0.0 2.0.0 ^C

Vous pouvez aussi accéder au site sur lequel l'application gceme présente les fiches d'information. La couleur de la fiche est passée du bleu à l'orange.

4. Voici à nouveau la commande permettant d'obtenir l'adresse IP externe. Copiez l'adresse IP externe dans un nouvel onglet pour afficher la fiche info :

kubectl get service gceme-frontend -n production

Exemple de résultat :

Tâche 13 : Tester vos connaissances

Voici quelques questions à choix multiples qui vous permettront de mieux maîtriser les concepts abordés lors de cet atelier. Répondez-y du mieux que vous le pouvez.

Vous avez terminé.

Excellent travail ! Vous venez de déployer votre application en production.

Félicitations !

Notre atelier pratique sur le déploiement et l'utilisation de Jenkins dans Kubernetes Engine en vue de créer un pipeline de livraison continue/déploiement continu se termine ici. Vous avez eu l'occasion de déployer un outil DevOps important dans Kubernetes Engine et de le configurer pour l'utiliser en production. Vous avez travaillé avec l'outil de ligne de commande kubectl et avec des configurations de déploiement dans des fichiers YAML, et vous savez un peu mieux comment créer des pipelines Jenkins pour un processus de développement/déploiement. Grâce à cette expérience pratique, vous devriez être en mesure d'exploiter ces outils dans vos propres activités DevOps.

Étapes suivantes et informations supplémentaires

• Pour plus d'informations, consultez cet article sur la solution Jenkins dans Kubernetes Engine.
• Découvrez comment activer la livraison continue dans Kubernetes Engine avec Jenkins.
• Vous trouverez davantage d'informations sur les solutions et guides DevOps dans la documentation de Google Cloud.
• Échangez avec la communauté Jenkins.

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 : 10 juin 2025

Dernier test de l'atelier : 10 juin 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.