Comment créer votre premier pipeline Jenkins ?

Un guide pas à pas pour créer le pipeline Jenkins

Pourquoi le pipeline Jenkins ?

La livraison continue (CD) est une partie essentielle du cycle de vie DevOps

Elle permet de s’assurer que les logiciels/applications créés par les développeurs sont toujours prêts pour la production. Pour ce faire, chaque fois que le code est mis à jour, il doit être construit, testé et déployé en continu. C’est là que Jenkins Pipeline entre en jeu

Dans le cadre du DevOps, l’intégration continue et la livraison continue (CI/CD) sont réalisées grâce au pipeline Jenkins. L’utilisation de Jenkins Pipeline pour la livraison continue permet de livrer le logiciel avec des versions plus rapides et plus fréquentes. Cela permet d’intégrer les retours d’expérience dans chaque nouvelle version

Qu’est-ce que le pipeline Jenkins ?

Le pipeline Jenkins est une combinaison de tâches permettant de livrer des logiciels en continu à l’aide de Jenkins

Je suppose que vous savez ce qu’est Jenkins. Si ce n’est pas le cas, consultez ce cours Udemy pour maîtriser Jenkins

Un pipeline Jenkins se compose de plusieurs états ou étapes, et ils sont exécutés dans une séquence l’un après l’autre. JenkinsFile est un simple fichier texte qui est utilisé pour créer un pipeline en tant que code dans Jenkins. Il contient du code en langage spécifique de domaine (DSL) Groovy, qui est simple à écrire et lisible par l’homme

Vous pouvez soit exécuter JenkinsFile séparément, soit exécuter le code du pipeline à partir de l’interface Web de Jenkins. Il y a deux façons de créer un pipeline avec Jenkins

• Déclaratif – une nouvelle façon de créer un pipeline Jenkins. Ici, vous écrivez du code groovy contenant des blocs de “pipeline”, qui est archivé dans un SCM (Source Code Management)
• Scripted – une façon d’écrire du code groovy où le code est défini à l’intérieur de blocs “node”.

Avant de commencer la démo, si vous n’avez pas installé Jenkins, installez-le d’abord. Assurez-vous que Jenkins est opérationnel sur votre système

Créez un pipeline Jenkins

Voici à quoi ressemble le flux d’un pipeline Jenkins, qui se compose de plusieurs étapes entre les développeurs qui créent un logiciel (codage) et le logiciel livré en production

Créons un pipeline déclaratif

Sur le tableau de bord Jenkins, cliquez sur New Item. Saisissez ensuite un nom d’élément, par exemple “First Pipeline” et sélectionnez le projet “Pipeline”. Cliquez ensuite sur OK

Cliquez sur l’onglet Pipeline comme indiqué dans l’image ci-dessous, et mettez votre code JenkinsFile (code Groovy) ici

pipeline {
 agent any
 stages {
 stage('Build') {
 steps {
 echo 'Hi, GeekFlare. Starting to build the App.'
 }
 }
 stage('Test') {
 steps {
 input('Do you want to proceed?')
 }
 }
 stage('Deploy') {
 parallel {
 stage('Deploy start ') {
 steps {
 echo "Start the deploy ..."
 } 
                         


                 


}
 stage('Deploying now') {
 agent {
 docker {
 reuseNode true
 image 'nginx'
 }
 }
                            
 steps {
 echo "Docker Created"
 }
 }
 }
 }
 stage('Prod') {
 steps { xml-p

Laissez-moi vous expliquer les blocs ci-dessus

• Le bloc pipeline comprend toutes les instructions pour construire, tester et livrer un logiciel. C’est le composant clé d’un pipeline Jenkins.
• Un agent est chargé d’exécuter le pipeline sur un nœud et d’allouer un espace de travail au pipeline.
• Une étape est un bloc qui contient des étapes pour construire, tester et déployer l’application. Les étapes sont utilisées pour visualiser les processus du pipeline Jenkins.
• Une étape est une tâche unique à exécuter, par exemple, créer un répertoire, exécuter une image docker, supprimer un fichier, etc.

Le code Groovy ci-dessus, je l’utilise pour le JenkinsFile. Tout agent disponible est assigné au pipeline. Ensuite, je définis l’étape Build et j’exécute une simple étape echo. Ensuite, j’ai défini l’étape Test où l’étape demande si vous voulez continuer ou non. Après cela, j’ai créé une étape Deploy, qui contient deux autres étapes fonctionnant en parallèle. Deploy start stage a une étape avec la commande echo, et Deploying now a une étape qui tire une image docker de Nginx sur le noeud. Enfin, il y a une étape Prod avec une simple étape echo

Le pipeline expliqué ci-dessus a des étapes qui ont des étapes simples pour que vous compreniez comment il fonctionne. Une fois que vous avez appris à créer un pipeline, vous pouvez ajouter plus de complexité et créer des pipelines complexes

Une fois que vous avez le code dans l’onglet Pipeline, cliquez sur Appliquer et Enregistrer. Enfin, cliquez sur Build Now pour commencer à construire le pipeline Jenkins que vous venez de créer

Voici à quoi ressemblera l’interface utilisateur lorsque le pipeline sera exécuté. Si vous avez suivi toutes les étapes correctement, votre construction sera réussie, et une couleur bleue apparaîtra pour la construction (#27). S’il y a des erreurs dans la compilation, la couleur de la compilation (#27) sera rouge

Cliquez maintenant sur le build #27 et ensuite sur Console Output pour vérifier ce qui s’est passé exactement dans le back-end lors de l’exécution

Voici à quoi ressemblera la sortie qui se terminera par un message de SUCCES

Success Console Output

Démarré par l'utilisateur geekflare
Exécuté au niveau Durability : MAX_SURVIVABILITY
[Pipeline] Début du pipeline
[Pipeline] node
Exécuté sur Jenkins dans /var/lib/jenkins/workspace/First Pipeline
[Pipeline] {
[Pipeline] stage
[Pipeline] { (Build)
[Pipeline] echo
Hi, GeekFlare. Nous commençons à construire l'application.
[Pipeline] }
[Pipeline] // stage
[Pipeline] stage
[Pipeline] { (Test)
[Pipeline] input
Voulez-vous continuer ?
Continuer ou abandonner
Approuvé par geekflare
[Pipeline] }
[Pipeline] // étape
[Pipeline] étape
[Pipeline] { (Déploiement)
[Pipeline] parallèle
[Pipeline] { (Branche : Début du déploiement)
[Pipeline] { (Branche : Déploiement en cours)
[Ligne de conduite] étape
[Ligne de conduite] { (Début du déploiement)
[Ligne de conduite] étape
[Ligne de conduite] { (Déploiement en cours)
[Ligne de conduite] getContext
[Ligne de conduite] isUnix
[Ligne de conduite] sh
[Ligne de conduite] echo
Commencez le déploiement ..
[Pipeline] }
 docker inspect -f . nginx
[Pipeline] // stage
[Pipeline] }

Erreur : No such object : nginx
[Pipeline] isUnix
[Pipeline] sh
 docker pull nginx
Using default tag : latest
latest : Pulling from library/nginx
8d691f585fa8 : Pulling fs layer
5b07f4e08ad0 : Pulling fs layer
abc291867bca : Extraction de la couche fs
abc291867bca : Vérification de la somme de contrôle
abc291867bca : Téléchargement complet
5b07f4e08ad0 : Vérification de la somme de contrôle
5b07f4e08ad0 : Téléchargement complet
8d691f585fa8 : Vérification de la somme de contrôle
8d691f585fa8 : Téléchargement complet
8d691f585fa8 : Extraction complète
5b07f4e08ad0 : Extraction complète
abc291867bca : Pull terminé
Digest : sha256:922c815aa4df050d4df476e92daed4231f466acc8ee90e0e774951b0fd7195a4
Status : Téléchargement d'une image plus récente pour nginx:latest
[Pipeline] withDockerContainer
Jenkins ne semble pas fonctionner à l'intérieur d'un conteneur
$ docker run -t -d -u 125 :131 -w "/var/lib/jenkins/workspace/First Pipeline" -v "/var/lib/jenkins/workspace/First Pipeline:/var/lib/jenkins/workspace/First Pipeline:rw,z" -v "/var/lib/jenkins/workspace/First Pipeline@tmp:/var/lib/jenkins/workspace/First Pipeline@tmp :rw,z" -e ******** -e ******** -e ******** -e ******** -e ******** -e ******** -e ******** -e ******** -e ******** -e ******** -e ******** -e ******** -e ******** -e ******** -e ******** -e ******** -e ******** -e ******** -e ******** -e ******** -e ******** -e ******** -e ******** -e ******** nginx cat
$ docker top 3141793b98f315dc90a57d810068b8eedb6f62debafb9040de06635b558f2943 -eo pid,comm
[Pipeline] {
[Pipeline] echo
Docker Created
[Pipeline] }
$ docker stop --time=1 3141793b98f315dc90a57d810068b8eedb6f62debafb9040de06635b558f2943
$ docker rm -f 3141793b98f315dc90a57d810068b8eedb6f62debafb9040de06635b558f2943
[Pipeline] // withDockerContainer
[Pipeline] }
[Pipeline] // stage
[Pipeline] }
[Pipeline] // parallel
[Pipeline] }
[Pipeline] // étape
[Pipeline] étape
[Pipeline] { (Prod)
[Pipeline] echo
App is Prod Ready
[Pipeline] }
[Pipeline] // étape
[Pipeline] }
[Pipeline] // node
[Pipeline] Fin du pipeline
Fini : SUCCESS

Le pipeline Jenkins ci-dessus a créé une image docker de Nginx. Vous pouvez le vérifier en exécutant la commande ci-dessous. Vous pouvez voir que l’image docker de Nginx est également listée

geekflare@chef-geekflare:~$ docker image ls
REPOSITORY TAG IMAGE ID CREATED SIZE

nginx

latest 540a289bab6c il y a 2 semaines 126MB

httpd

latest 7d85cc3b2d80 il y a 2 mois 154MB
redis latest f7302e4ab3a8 il y a 2 mois 98.2MB
geekflare_mongodb latest 095d17727ca0 il y a 3 mois 325MB

Conclusion

J’espère que cela vous a donné une idée des avantages du pipeline Jenkins et de la façon dont vous pouvez en créer un. Il s’agit d’une simple démonstration, et la meilleure façon d’apprendre est d’essayer de construire des pipelines complexes.