GSP051

Aperçu

Dans cet atelier, vous allez apprendre à configurer un pipeline de livraison continue en exécutant 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 illustrée dans le diagramme suivant :

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

Points abordés

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

• Provisionner une application Jenkins dans un cluster Kubernetes Engine
• Configurer votre 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 global de Google, qui vous offre la possibilité d'automatiser le routage du trafic Web vers vos instances. L'équilibreur de charge traite 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 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 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 gratuits.

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

Remarque : Pour afficher un menu contenant la liste des produits et services Google Cloud, cliquez sur le menu de navigation en haut à gauche.

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

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

Créer un cluster Kubernetes

1. À présent, 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 champs d'application supplémentaires autorisent l'accès de Jenkins à Cloud Source Repositories et à Google Container Registry.

Tester la tâche terminée

Cliquez sur Vérifier ma progression pour vérifier la tâche exécutée. Si le cluster Kubernetes a correctement été créé, vous recevrez une note d'évaluation.

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

3. Ensuite, récupérez les identifiants de votre cluster :

gcloud container clusters get-credentials jenkins-cd

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

Dans cet atelier, vous allez installer Jenkins à partir du dépôt Charts à l'aide de Helm. Helm est un gestionnaire de paquets qui facilite la configuration et le déploiement des applications Kubernetes. Une fois Jenkins installé, vous pourrez créer votre pipeline CI/CD.

1. Ajoutez le dépôt de chart 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 : Configurer et installer Jenkins

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

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 permettra à Jenkins d'associer votre cluster à votre projet GCP.

1. Via 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.

Tester la tâche terminée

Cliquez sur Vérifier ma progression pour vérifier la tâche exécutée. Si le chart Jenkins a correctement été configuré, vous recevrez une note d'évaluation.

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 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 nos nœuds de construction soient automatiquement lancés 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

1. Le chart Jenkins crée automatiquement un mot de passe administrateur à votre intention. 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 Jenkins, cliquez sur le bouton Aperçu sur le Web dans Cloud Shell, puis sur Prévisualiser sur le port 8080 :

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 : Comprendre l'application

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 un certain 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

Tester la tâche terminée

Cliquez sur Vérifier ma progression pour vérifier la tâche exécutée. Si les déploiements ont correctement été créés, vous recevrez une note d'évaluation.

Créer les 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 les versions 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

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

gcloud source repos create default

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

Tester la tâche terminée

Cliquez sur Vérifier ma progression pour vérifier la tâche exécutée. Si vous avez réussi à créer le dépôt source, vous recevez une note d'évaluation.

Créer un dépôt 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://source.developers.google.com/p/$DEVSHELL_PROJECT_ID/r/default

4. Définissez le nom d'utilisateur et l'adresse e-mail pour vos commits Git. Remplacez [EMAIL_ADDRESS] par votre adresse e-mail Git et [USERNAME] par votre nom d'utilisateur Git :

git config --global user.email "[EMAIL_ADDRESS]" git config --global user.name "[USERNAME]"

5. 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. Les identifiants du compte de service de votre cluster permettront à Jenkins de télécharger le code à partir de Cloud Source Repositories.

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 des métadonnées) depuis le menu déroulant Kind (Genre), puis cliquez sur Create (Créer).

Les identifiants globaux ont été ajoutés. Le nom associé aux identifiants correspond à l'ID de projet qui se trouve dans la section DÉTAILS DE CONNEXION de l'atelier.

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. Cliquez sur Kubernetes Cloud Details (Détails du cloud Kubernetes).
7. Dans le champ Jenkins URL (URL de Jenkins), saisissez http://cd-jenkins:8080.
8. Dans le champ Jenkins tunnel (Tunnel Jenkins), saisissez cd-jenkins-agent:50000.
9. 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 de Cloud Source Repositories dans le champ Project Repository (Dépôt du projet). Remplacez [PROJECT_ID] par votre ID de projet :

https://source.developers.google.com/p/[PROJECT_ID]/r/default

5. Dans le menu déroulant Credentials (Identifiants), sélectionnez le nom des identifiants que vous avez créés lors de l'ajout de votre compte de service aux étapes précédentes.

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. La configuration du job doit se présenter comme suit :

8. Cliquez sur Save (Enregistrer) en conservant les valeurs par défaut des autres options.

Une fois que vous avez suivi cette procédure, un job nommé 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és, vous pouvez transférer la branche en question vers le serveur Git et laisser à Jenkins le soin de déployer votre environnement.

• 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'identifiant 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 : Lancer le déploiement

1. Validez et déployez vos modifications :

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

Vous lancerez 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 à présent 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é.

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 qu'une partie du trafic est acheminée par votre nouvelle version. 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 en appuyant sur Ctrl+C.

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

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 toute notre flotte 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é.

2. Lorsqu'il a terminé (ce qui peut prendre quelques minutes), vous pouvez vérifier l'URL du service pour vous assurer que tout le trafic est acheminé par votre nouvelle 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. 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 à ces exercices pratiques, vous devriez être en mesure d'exploiter ces outils dans vos propres activités DevOps.

Terminer votre quête

Cet atelier d'auto-formation fait partie des quêtes Kubernetes in the Google Cloud, Cloud Architecture et DevOps Essentials. Une quête est une série d'ateliers associés qui constituent un parcours de formation. Si vous terminez une quête, vous obtenez un badge attestant de votre réussite. Vous pouvez rendre publics les badges que vous recevez et ajouter leur lien dans votre CV en ligne ou sur vos comptes de réseaux sociaux. Inscrivez-vous à n'importe quelle quête contenant cet atelier pour obtenir immédiatement les crédits associés. Découvrez toutes les quêtes disponibles dans le catalogue Google Cloud Skills Boost.

Atelier suivant

Continuez sur votre lancée en suivant l'atelier Hello Node Kubernetes ou l'un des ateliers Google Cloud Skills Boost suivants :

• Orchestrer le cloud avec Kubernetes
• Gestion des déploiements avec Kubernetes Engine

É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 : 20 septembre 2023

Dernier test de l'atelier : 20 septembre 2023

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.