DevOps : Construire un pipeline CI/CD avec Jenkins

Les méthodes DevOps telles que le CI/CD, notamment avec Jenkins sont de plus en plus appliquées au sein des entreprises de nos jours. En effet, ces concepts ne cessent de prendre de la place dans le monde de la création de solutions informatiques, surtout depuis l’avènement du Big Data. Pour preuve, il figure de nos jours parmi les métiers porteurs du Big Data, puisque les ingénieurs DevOps/Cloud sont de plus en plus recherchés.

Cependant, pour que le processus de production d’une solution puisse se dérouler parfaitement, il faut connaître toutes les manières de procéder afin de livrer une application performante dans un délai minimisé.

Dans ce tutoriel exhaustif, nous allons vous apprendre à maîtriser ces étapes afin que vous puissiez construire un pipeline CI/CD avec Jenkins. Mais tout d’abord, définissons le contexte et voyons quelques notions essentielles avant de débuter la pratique.

DevOps : Définition

Mis en contexte

Il faut savoir que la réalisation d’un projet nécessite l’intervention de deux équipes informatiques : l’équipe de développement et l’équipe opérationnelle. La première s’occupe de la création de la structure, du développement et des tests de la solution. La seconde équipe, quant à elle, se charge du déploiement, de la mise en production et de la maintenance de l’application.

Avant, ces deux entités travaillaient indépendamment, mais cette manière de procéder présente quelques inconvénients. On constate par exemple des problèmes de compatibilité entre l’environnement de développement et de production. En outre, le délai entre ces deux étapes est rallongé et la qualité du produit amoindrie.

Afin de pallier ces soucis, certains modes de travail doivent être modifiés. L’adoption de la méthode agile est la première solution suggérée, mais les besoins nécessitent d’autres approches, notamment le DevOps.

Qu’est-ce que le DevOps ?

Le DevOps est apparu en 2007 et a intéressé tout de suite les métiers concernés par le domaine de l’informatique. Ce mot est la fusion de deux mots et des deux principales phases de conception d’une solution : la partie développement et la partie opérationnelle. Comme son appellation le suggère, il repose sur le fait que ces deux équipes doivent collaborer ensemble afin de proposer une application plus performante dans un délai plus petit.

Avant tout, le DevOps est une culture à adopter par les intervenants, une culture de partage entre chaque membre de l’équipe. Il s’agit également de changer la vision en ce qui concerne le cycle de développement d’une solution, c’est-à-dire apporter et adopter une nouvelle manière de travailler.

Le DevOps consiste aussi à automatiser le maximum de tâches chronophages pour les travailleurs afin de minimiser le délai de mise en production. Plusieurs outils sont utilisés pour cela dans le but d’améliorer la qualité perçue par le client et de mesurer efficacement l’impact de la solution à travers des KPIs.

Le schéma ci-dessus montre le cycle de vie du mouvement DevOps. Il démontre la continuité de tout le processus de réalisation d’un projet informatique, c’est-à-dire que les équipes sont en contact permanent.

Cette image confirme également que de nombreuses tâches sont automatisées afin d’appliquer l’intégration continue (CI), le déploiement continu (CD) et le monitoring continu, nous allons détailler ces concepts juste après. Ces derniers sont la base de la méthode DevOps.

Pipeline CI/CD : Définition

Avant de définir ce qu’est un pipeline CI/CD, il est important de connaître individuellement chaque partie de ce terme.

Intégration continue

L’intégration continue est un processus mis en place par les développeurs. Il consiste à fusionner progressivement les codes d’un programme dans un emplacement partagé. Autrement dit, les développeurs effectuent des modifications sur le programme, les testent individuellement, puis envoient les codes sur un référentiel partagé afin qu’ils puissent justement être intégrés au reste du programme.

Ce processus offre de nombreux avantages, notamment la réduction des tâches lourdes à effectuer, car on procède étape par étape dans la réalisation de chaque fonctionnalité, ce qui réduit les risques de conflits. Il permet également à ce que plusieurs développeurs puissent travailler en même temps sur un seul et même projet.

En adoptant cette pratique, on identifie vite les problèmes et les différents bugs. Et dans le cas où l’on ne détecterait pas ces derniers au moment des tests unitaires, ils seront tout de même vite résolus grâce à ce processus.

Déploiement continu / Distribution continue

Comme vous pouvez le constater par le titre de cette section, CD peut être interprété de deux façons différentes. Cependant, dans tous les cas, il repose sur le travail effectuer en intégration continue, c’est-à-dire que le référentiel partagé est mis en place.

La distribution continue consiste à ce que l’équipe opérationnelle accède au référentiel partagé afin que l’application puisse être mise en production rapidement. L’objectif ici est donc de réduire l’écart entre les deux principales équipes DevOps afin d’accélérer la production de l’application et, par conséquent, le délai de disponibilité de cette dernière auprès des utilisateurs.

Le déploiement continu, quant à lui, fait référence à l’automatisation des étapes de mise en production d’une solution. En effet, en utilisant ce processus, l’intégration continue effectuée par les développeurs est directement transférée à l’environnement de production. Les modifications peuvent donc être visibles au niveau des clients plus rapidement.

Cependant, l’équipe opérationnelle gère cette mise à jour comme elle le souhaite, c’est-à-dire qu’elle peut décider du moment et de la circonstance de déploiement selon les critères qu’elle impose, malgré le fait que ce soit automatisé par la suite.

Ce processus permet aux opérationnels de se focaliser sur les tâches non automatisées et donc de réduire considérablement le délai entre le moment de la création de l’application et celui où les clients l’utilisent.

Qu’est-ce qu’un pipeline CI/CD ?

L’utilisation de ces deux processus ci-dessus aboutit à la création de ce que l’on appelle un pipeline CI/CD, mais qu’est-ce que c’est réellement ?

Un pipeline CI/CD est un ensemble d’étapes permettant de distribuer une nouvelle version d’une application. Ce pipeline repose sur l’automatisation afin que cette distribution puisse s’effectuer de manière rapide et efficace. Toute l’approche DevOps est donc réunie et utilisée en un seul pipeline. Les processus que nous venons de citer dans les sections précédentes sont intégrés dans un job et s’effectuent automatiquement au fur et à mesure que l’application évolue.

L’adoption de cette méthode a révolutionné le monde du développement et de la production de solutions, car chaque pôle se concentre plus sur l’aspect pratique de la création, mais plus sur les soucis d’intégration ou autres tâches chronophages.

Les étapes de la construction d’un pipeline CI/CD

La construction d’un pipeline CI/CD se constitue d’une suite d’étapes et d’instructions à suivre, comme on a pu le voir dans sa définition. On peut regrouper ces étapes dans plusieurs phases à savoir :

• Le développement de l’application : cela consiste à coder l’application suivant les environnements que les développeurs ont choisis ;
• Les différents tests qui permettent de s’assurer de la qualité et de la cohérence de chaque fonctionnalité ;
• L’intégration continue, c’est-à-dire le transfert du programme au référentiel partagé. Lors de cette étape, le livrable peut prendre différentes formes et peut impliquer plusieurs outils ;
• Le déploiement continu qui consiste à mettre en production l’application. L’environnement de déploiement peut également varier selon le besoin de l’entreprise ou de l’équipe opérationnelle. Et pareillement, cette étape peut impliquer plusieurs outils ;
• La validation et conformité qui peut contenir plusieurs autres étapes selon le besoin de l’entreprise. Par exemple, c’est lors de cette étape que l’on examine les images ou que l’on vérifie si toutes les mentions sont bien présentes.

Jenkins : l’outil ultime pour construire un pipeline CI/CD

Plusieurs outils permettent de créer un pipeline CI/CD tels que GitLab, GoCD, Travis CI, Screwdriver ou encore Spinnaker. Cependant, Jenkins reste le plus complet. Il est le meilleur dans ce domaine et par conséquent le plus utilisé.

Jenkins est, comme vous vous en doutez, un outil d’automatisation des processus d’intégration continue et de déploiement continu. C’est un outil open source écrit en Java qui est basé sur un projet nommé Hudson créé par Oracle et repris par la fondation Eclipse pour être ensuite abandonné.

Sa principale utilisation réside dans la création de pipelines CI/CD. Ainsi, il permet aux utilisateurs de se connecter sur des systèmes de gestion de codes sources tels que GitHub. On peut également utiliser des outils de conteneurisation comme Docker et Kubernetes avec Jenkins. D’autres opérations sont possibles et plusieurs plug-ins sont disponibles afin qu’il puisse prendre en charge de nombreux autres outils.

La création d’un pipeline Jenkins repose sur la création d’un fichier nommé Jenkinsfile. Il s’agit d’un fichier texte contenant toutes les étapes à suivre pour créer le pipeline. Généralement, il contient une partie déclarative et une partie script qui, elles, contiennent plusieurs étapes afin de rendre le pipeline CI/CD fonctionnel.

Les outils associés à Jenkins pour la création d’un pipeline CI/CD

On peut utiliser Jenkins avec plusieurs outils comme en témoignent les nombreux plug-ins que l’on peut y installer comme extensions. Mais en général, pour construire un pipeline CI/CD fonctionnel, les différents types d’outils suivants sont nécessaires.

Les gestionnaires de codes sources

Les gestionnaires de codes sources permettent à Jenkins et aux autres membres de l’équipe de développement d’accéder aux codes sources de l’application. Il existe plusieurs gestionnaires, mais Git reste le meilleur et le plus utilisé d’entre eux.

C’est un gestionnaire de codes sources open source créé par Linus Torvalds et dont le principal contributeur est Junio C Hamano. Il permet de stocker les programmes sur un serveur dédié sur lequel tous les contributeurs peuvent accéder. Il sert également à gérer l’évolution de l’arborescence du projet en intégrant les modifications apportées par chaque développeur.

Les outils d’automatisation de compilation

Les outils d’automatisation de compilation permettent de déployer l’application qui vient d’être codée. Ces outils ne sont pas utiles pour les applications écrites avec certains langages tels que JavaScript. Cependant, pour les langages compilés comme Java, ils sont vraiment utiles.

En intégration continue, le plus utilisé d’entre eux est Maven. Il s’agit d’un outil géré par Apache Software Foundation permettant de créer un fichier jar pour distribuer un ensemble de classes Java.

Les serveurs d’applications

Les serveurs vont servir d’emplacement de stockage pour l’application à gérer. Il peut s’agir d’un serveur web, d’une machine locale ou d’une machine virtuelle.

Les outils tels que Docker et Kubernetes peuvent également être considérés comme des serveurs d’applications. En effet, ces derniers permettent de stocker, de gérer et de lancer les applications sous forme de conteneurs.

Les outils de tests

On peut également effectuer les tests dans un pipeline Jenkins. Cette étape, comme on l’a vu un peu plus haut, permet de valider chaque fonctionnalité et de s’assurer que l’application livrée est bien fonctionnelle.

Certains langages disposent d’outils compatibles avec Jenkins afin d’effectuer ces tests tels que JUnit et PowerMok pour Java ou encore Pytest et Tox pour Python.

Pourquoi utiliser Jenkins ?

Comme nous l’avons mentionné un peu plus haut, il existe plusieurs outils permettant d’implémenter des pipelines CI/CD. Mais pourquoi Jenkins sort du lot, pourquoi le choisir ? En effet, Jenkins offre plusieurs avantages intéressants à savoir :

• Jenkins est open source et gratuit. On peut donc en disposer pour tout type de projet, que ce soit dans le monde professionnel ou en apprentissage ;
• Sa communauté est très active. Vous pouvez donc compter sur elle en cas de problèmes ;
• On peut l’installer de plusieurs façons et, quelle que soit la manière que l’on choisit, cela se fait très simplement ;
• Il est également multiplateforme, c’est-à-dire qu’il fonctionne autant sur Windows, Linux ou macOS ;
• Jenkins dispose d’une interface sur laquelle on peut facilement gérer chaque fonctionnalité d’un pipeline ;
• Il permet d’effectuer l’intégration et le déploiement continus de manière automatique ;
• En cas de problème que niveau de chaque étape, Jenkins va vous prévenir à travers les logs que l’on peut consulter au niveau de l’interface ;
• Il est compatible avec la plupart des plateformes de développement, de test et de déploiement. En plus, une multitude de plug-ins sont disponibles sur Jenkins afin de faciliter la création du pipeline CI/CD. Et si vous ne trouvez pas le plug-in dont vous avez besoin, vous pouvez le créer vous-même.

Tutoriel : construire un pipeline CI/CD avec Jenkins de A à Z

Dans cette partie, nous allons voir toutes les étapes à suivre afin de construire un pipeline CI/CD fonctionnel avec Jenkins.

Installer Docker et Kubernetes

Docker et Kubernetes font partie des prérequis pour ce tutoriel. Il faut donc les installer sur votre machine. Pour ce faire, nous vous invitons à consulter leurs tutoriels respectifs sur notre blog. Cliquez ici :Maitrisez la conteneurisation d’application avec Docker pour installer Docker et ici : Maîtrisez le déploiement et l’orchestration d’applications avec Kubernetes pour Kubernetes, ou plus précisément Minikube que nous allons utiliser dans ce tutoriel vu que nous sommes en local.

Une fois que vous terminez l’installation de ces deux outils, vous pouvez passer à l’étape suivante.

Installer Jenkins

Il existe plusieurs moyens d’installer Jenkins, nous vous invitons à tous les consulter sur leur site officiel. Dans ce tutoriel, nous allons l’installer en le déployant dans un cluster Kubernetes. Il existe également plusieurs manières d’effectuer ce déploiement, mais ici, nous allons utiliser un fichier YAML pour cela.

Note : Dans cette partie, nous allons utiliser le système d’exploitation Windows 10. Cependant, le procédé reste le même pour les autres OS.

Démarrer Minikube

Pour débuter, nous allons lancer Minikube en exécutant la commande suivante :

minikube start --vm-driver=hyperv

Dans l’idéal, il faut spécifier la ressource nécessaire (qui est de 4Go) avec le paramètre –memory pour que Jenkins puisse s’exécuter correctement. En effet, il est assez gourmand, donc il vaut mieux ajouter ce mot-clé pour éviter les mauvaises surprises. Dans ce cas, la commande à exécuter sera ceci :

minikube start --vm-driver=hyperv --memory 4028

Le mot-clé –vm-driver est également important afin d’indiquer à Minikube l’hyperviseur à utiliser lors de l’exécution.

On peut vérifier si Minikube est bien en marche en tapant la commande suivante :

minikube status

Créer un namespace

Cette étape permet de fournir un meilleur contrôle lors de l’intégration continue et du déploiement continu. Pour ce faire, nous allons taper la commande suivante :

kubectl create namespace jenkins

Pour vérifier que l’on a bien créé le namespace, nous allons lister les namespaces existants avec la commande suivante :

Comme nous pouvons le constater, l’espace de nom est bien là.

Déployer Jenkins

Maintenant, nous allons créer le fichier YAML qui va nous servir à installer Jenkins dans le cluster Minikube. Nous allons créer pour cela le fichier dans un dossier que nous avons préalablement créé, puis nous allons coller ces instructions dans ce fichier :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: jenkins
spec:
  replicas: 1
  selector:
    matchLabels:
      app: jenkins
  template:
    metadata:
      labels:
        app: jenkins
    spec:
      containers:
      - name: jenkins
        image: jenkins/jenkins:lts-jdk11
        ports:
        - containerPort: 8080
        volumeMounts:
        - name: jenkins-home
          mountPath: /var/jenkins_home
      volumes:
      - name: jenkins-home
        emptyDir: { }

Pour créer le déploiement de Jenkins, nous allons exécuter la commande suivante :

kubectl create -f jenkins-deployment.yaml -n jenkins

Si l’on souhaite vérifier que l’on a bien créé le déploiement, nous allons afficher la liste des déploiements existants dans le namespace jenkins avec la commande ci-dessous :

kubectl get deployments -n jenkins

Créer un service pour Jenkins

À ce stade, le déploiement de Jenkins n’est accessible qu’à l’intérieur du cluster. Pour remédier à cela, nous allons créer un service. Un service permettra à Jenkins d’être accessible de l’extérieur grâce à l’attribution d’un NodePort qui servira à exposer notre déploiement.

Pour ce faire, nous allons créer un autre fichier nommé jenkins-service.yaml et coller les instructions suivantes à l’intérieur de ce fichier :

apiVersion: v1
kind: Service
metadata:
  name: jenkins
spec:
  type: NodePort
  ports:
  - port: 8080
    targetPort: 8080
  selector:
    app: jenkins

Maintenant, nous allons créer le service à l’aide de la commande suivante :

kubectl create -f jenkins-service.yaml -n jenkins

Pour vérifier si tout s’est bien passé, nous allons afficher les services existants avec cette commande :

kubectl get services -n jenkins

Accéder à Jenkins

En théorie, Jenkins est maintenant installé sur votre machine. Pour vérifier cela, nous allons accéder à Jenkins Dashboard. Pour ce faire, nous allons récupérer l’IP à consulter avec la commande suivante :

minikube ip

On peut désormais accéder à l’interface de Jenkins Dashboard en utilisant cet IP et le port mentionné par la commande ci-dessus à savoir 172.22.205.156:30559

Comme vous pouvez le constater, il nous demande un mot de passe administrateur afin de finaliser notre installation. Pour obtenir ce mot de passe, nous allons tout d’abord chercher le nom du pod de Jenkins à l’aide de la commande suivante :

kubectl get pods -n jenkins

Une fois que nous avons le nom, nous allons explorer les logs de ce pod en exécutant la commande suivante :

kubectl logs jenkins-789c9b6b84-hzhlf -n jenkins

où jenkins-789c9b6b84-hzhlf est le nom du pod que nous avons trouvé précédemment.

Le mot de passe que nous recherchons se trouve dans le résultat obtenu à l’aide de cette commande. Il est facilement trouvable, car il se situe entre trois lignes d’étoile (“ * “).

Entrez ce mot de passe sur le champ adéquat et le tour est joué

Comme on peut le voir sur cette capture, il nous suggère d’installer les plug-ins indispensables. Vous pouvez effectuer cela à votre convenance.

Une fois que vous avez choisi l’option que vous souhaitez, il va vous demander d’entrer des informations telles qu’un nom d’utilisateur, un mot de passe, votre nom ainsi qu’une adresse email. Cependant, vous pouvez juste continuer en tant qu’administrateur.

Après cette étape, il vous demande de confirmer l’URL à utiliser pour accéder à Jenkins.

Et voilà, Jenkins est prêt à être utilisé.

Préparer notre projet

Le projet sur lequel nous allons effectuer l’intégration et le déploiement continu se trouve sur ce lien :

https://github.com/rhmanou/Jenkins-Test

Une fois que la page de ce lien s’ouvre, il faut effectuer un Fork du répertoire sur votre propre compte GitHub.

Maintenant que le projet est disponible sur votre compte, vous pouvez effectuer les modifications que vous souhaitez. Par exemple, amusez-vous à changer le contenu de la page HTML.

Il faut savoir que ce projet est une simple application Java Spring Boot dont le but est d’afficher une page HTML avec juste un paragraphe.

Dans ce tutoriel nous allons :

• Cloner ce projet dans notre pipeline ;
• Lancer un build avec Maven ;
• Et conteneuriser l’application avec Docker.

Tout cela se fera à l’intérieur de Jenkins qui l’on va déployer dans un cluster Kubernetes en utilisant Minikube.

Configurer Jenkins

Avant de nous lancer dans la création du pipeline, il faut que l’on effectue quelques configurations au niveau de Jenkins.

Ajouter des plug-ins

Quelques plug-ins relatifs aux configurations que l’on vient d’effectuer sont également nécessaires. Pour les installer, il faut aller dans Administrer Jenkins puis dans Gestion des plug-ins. Situons-nous au niveau des plug-ins disponibles et tapons le nom du plug-in que l’on souhaite installer dans la barre de recherche.

Pour ce tutoriel, nous avons besoin des plug-ins Kubernetes CLI, Maven Integration plug-in et Docker. Pour commencer l’installation, nous devons cliquer sur l’un des deux boutons situés en bas à gauche.

Note : après chaque installation terminée, vous pouvez redémarrer Jenkins en cochant la case prévue à cet effet.

Configurer JDK, Maven et Docker

Tout d’abord, il faut configurer JDK, Maven et Docker. Pour ce faire, nous allons cliquer sur Administrer Jenkins puis sur Configuration globale des outils.

Nous allons commencer par le JDK en nous plaçant au niveau de la partie dédiée à cela. Donner un nom à la configuration puis cliquer sur Install automatically. Le fait de cliquer sur ce dernier va ouvrir un formulaire sur lequel nous allons indiquer la version que l’on veut installer. Dès que l’on finit de remplir, nous allons cliquer sur Enregistrer afin de valider notre configuration.

Note : il existe plusieurs autres manières de configurer JDK sur Jenkins. Sur celle que nous venons d’effectuer, il faut noter que nous avons besoin d’un compte Oracle. Cependant, pour une installation de Jenkins basée sur une image Docker par exemple, vous n’aurez qu’à spécifier le chemin sur lequel JDK est installé sur votre conteneur, mentionner qu’il s’agit de JAVA_HOME, et le tour est joué.

L’étape à suivre est assez similaire pour Maven. On entre un nom et on coche sur Install automatically. Ensuite on choisit l’option Install from Apache et la version qui nous convient. Il faut noter que cette version doit être la même que celle que l’on mentionne dans Jenkinsfile. Nous allons voir l’entièreté du contenu de ce fichier plus tard.

Nous avons également besoin de configurer Docker pour qu’il puisse fonctionner à l’intérieur de notre pipeline. L’étape à suivre reste également la même.

Configurer le fournisseur cloud Docker

Cette étape sert à établir la connexion entre le cluster sur lequel est installé Jenkins et le Docker installé localement. L’accès à cette configuration varie selon la version de Jenkins dont on dispose. Pour les plus récentes, elle se trouve dans Administrer Jenkins > Administrer Noeuds et Cloud > Configurer Cloud.

Pour le remplissage du formulaire, il faut entrer l’URL à partir duquel est accessible votre instance locale de Docker. Afin de l’obtenir sous Windows, vous pouvez aller dans le répertoire C:\Windows\System32\drivers\etc\hosts et de regarder au niveau des lignes ajoutées par Docker lors de son installation. En ce qui concerne le port, celui-ci est visible au niveau des paramètres de Docker Desktop. Dans la plupart des cas, ce port est 2375.

Note : il faut également attribuer l’adresse IP dans le fichier host et le port avec la commande suivante afin d’établir la connexion :

netsh interface portproxy add v4tov4 listenport=2375 listenaddress=[IP] connectaddress=127.0.0.1 connectport=2375

Créer le pipeline

Une fois que notre environnement est en place, nous pouvons commencer la création du pipeline CI/CD avec Jenkins, alors, commençons !

Revenons au niveau du tableau de bord et cliquons sur Nouveau Item.

Une nouvelle fenêtre va apparaître à l’issue de cela. Sur cette dernière, nous allons saisir le nom que l’on souhaite donner à notre pipeline, cliquer sur Pipeline puis sur OK.

Cela va nous mener vers une nouvelle fenêtre. Dans Général, choisissons l’option GitHub project pour spécifier que notre projet de base se situe dans un répertoire GitHub. Il nous demande ensuite d’insérer le lien du projet. Nous allons prendre le lien mentionné sur votre navigateur lorsque l’on se trouve sur le répertoire de notre propre compte GitHub pour remplir cela.

Un peu plus bas, nous avons un autre formulaire pour la définition du pipeline que nous devons également remplir. Sur le champ Définition, choisissons l’option Pipeline script from SCM pour spécifier que notre Jenkinsfile se trouve à l’intérieur du répertoire GitHub. Puis, il faut réinsérer le lien que nous avons mis précédemment. Une fois que tout est rempli, nous terminons la création du pipeline en cliquant sur Sauver.

Examinons un peu ce Jenkinsfile.

Comme vous pouvez le constater, on voit tout d’abord des lignes d’initialisation des variables qui seront utiles au cours de l’exécution du pipeline. Il faut noter que le mot clé tool permet de relier la variable avec la configuration que l’on a effectuée un peu plus haut. Le nom mentionné après ce mot-clé doit correspondre au nom que l’on a donné lors de cette configuration.

Il y a également plusieurs étapes appelées stages qui servent à exécuter le pipeline. Le premier stage va cloner le répertoire GitHub au sein de notre environnement Jenkins. Le second stage permet de lancer un build de l’application en utilisant Maven.

Dans le troisième stage, on crée l’image docker de l’application pour l’exécuter en tant que conteneur dans le dernier stage. Lors de ce build, nous avons spécifié l’hôte à contacter avec le mot-clé -H. Cet hôte doit être le même que l’on a mentionné lors de la configuration du cloud Docker. Le Dockerfile utilisé pour la création de l’image se trouve aussi dans le répertoire du projet. Ce dernier va permettre d’exécuter le fichier jar obtenu lors du build de l’application avec Maven dans un conteneur Docker. Voici le contenu du Dockerfile en question :

Le quatrième stage, quant à lui, va servir à exécuter l’image précédemment créée. Il est également important de ne pas oublier de spécifier l’hôte à contacter.

Lancer le pipeline

Maintenant que l’on vient de créer le pipeline, on peut procéder à son exécution. Pour ce faire, il suffit de cliquer sur le nom du pipeline sur le dashboard puis sur Lancer un build.

Une fois que le build se termine, voici ce que vous devriez voir :

Cela veut dire que le pipeline est en cours d’exécution. Donc, si vous accédez à l’IP et le port que l’on a mentionné dans le Dockerfile à savoir localhost:2222, notre application devrait s’ouvrir.

Voilà, nous arrivons à la fin de ce tutoriel sur la manière d’utiliser Jenkins. Vous pouvez maintenant installer Jenkins dans un cluster Kubernetes, créer un pipeline et exécuter un conteneur Docker à l’intérieur de ce dernier.

Si vous souhaitez en apprendre davantage sur le DevOps et le Big Data, vous pouvez parcourir notre blog. Nous vous invitons également à télécharger gratuitement notre formation sur Spark avec Scala.