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éer 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 'Bonjour, GeekFlare. Commencez à construire l'application.'
}
}
stage('Test') {
étapes {
input('Voulez-vous continuer?')
}
}
stage('Deploy') {
parallèle {
stage('Deploy start') {
étapes {
echo "Démarrer le déploiement..."
}
}
stage('Deploying now') {
agent {
docker {
reuseNode true
image 'nginx'
}
}
steps {
echo "Docker Created"
}
}
}
}
stage('Prod') {
steps {
echo "L'application est prête"
}
}
}
}Permettez-moi d’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 à effectuer, 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.
Sortie de la console de succès
Démarré par l'utilisateur geekflare
Exécuté au niveau Durabilité : MAX_SURVIVABILITY
[Pipeline] Début du pipeline
nœud [Pipeline]
Exécution sur Jenkins dans /var/lib/jenkins/workspace/Premier pipeline
[Pipeline] {
[Pipeline] stage
pipeline] { [Pipeline] stage { (Build)
[Pipeline] echo
Bonjour, GeekFlare. Nous commençons à construire l'application.
[Pipeline] }
[Pipeline] // étape
[Pipeline] étape
[Pipeline] { (Test)
[Pipeline] input
Voulez-vous continuer ?
Poursuivre ou abandonner
Approuvé par geekflare
[Pipeline] }
[Pipeline] // étape
[Pipeline] étape
[Pipeline] { (Déploiement)
[Pipeline] parallèle
[Pipeline] { (Branche : Déploiement début )
[Pipeline] { (Branche : Déployer maintenant) { (Branche : Déploiement en cours)
[Ligne de conduite] étape
[Pipeline] { (Branch : Deploy start ) [Pipeline] { (Branch : Deploying now) { (Début du déploiement)
[Pipeline] étape
[Pipeline] [Pipeline] { (Déployer maintenant) { (Déployer maintenant)
[Ligne de conduite] getContext
[Pipeline] isUnix
[Pipeline] sh
[Pipeline] echo
Lancez le déploiement ...
[Pipeline] }
docker inspect -f . nginx
[Pipeline] // stage
[Pipeline] }
Erreur : Aucun objet de ce type : nginx
[Pipeline] isUnix
[Pipeline] sh
docker pull nginx
Utilisation de la balise par défaut : latest
dernier : Extraction de la bibliothèque/nginx
8d691f585fa8 : Extraction de la couche fs
5b07f4e08ad0 : Extraction de la couche fs
abc291867bca : Extraction de la couche fs
abc291867bca : Vérification de la somme de contrôle
abc291867bca : Téléchargement terminé
5b07f4e08ad0 : Vérification de la somme de contrôle
5b07f4e08ad0 : Téléchargement terminé
8d691f585fa8 : Vérification de la somme de contrôle
8d691f585fa8 : Téléchargement terminé
8d691f585fa8 : Pull terminé
5b07f4e08ad0 : Extraction terminée
abc291867bca : Extraction terminée
Digest: sha256:922c815aa4df050d4df476e92daed4231f466acc8ee90e0e774951b0fd7195a4
Statut : 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 ******** -e ******** -e ******** -e nginx cat
$ docker top 3141793b98f315dc90a57d810068b8eedb6f62debafb9040de06635b558f2943 -eo pid,comm
[Pipeline] {
[Pipeline] echo
Docker Créé
[Pipeline] { [Pipeline] echo Docker Created [Pipeline] echo Docker Created [Pipeline] }
$ docker stop --time=1 3141793b98f315dc90a57d810068b8eedb6f62debafb9040de06635b558f2943
$ docker rm -f 3141793b98f315dc90a57d810068b8eedb6f62debafb9040de06635b558f2943
[Pipeline] // withDockerContainer
[Pipeline] // withDockerContainer }
[Pipeline] // withDockerContainer [Pipeline] } [Pipeline] // stage
[Pipeline] // stage }
[Pipeline] // parallèle
[Pipeline] // parallèle }
[Pipeline] // parallèle [Pipeline] } // étape
[Pipeline] étape
[Pipeline] { (Prod)
[Pipeline] echo
L'application est Prod Ready
[Pipeline] { (Prod) }
[Pipeline] // étape
[Pipeline] }
[Pipeline] // nœud
[Pipeline] // nœud Fin du pipeline
Fini : SUCCESSLe 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
DÉPÔT TAG IMAGE ID CRÉÉ TAILLE
nginx latest 540a289bab6c il y a 2 semaines 126MB
httpd latest 7d85cc3b2d80 il y a 2 mois 154MB
redis dernier f7302e4ab3a8 il y a 2 mois 98.2MB
geekflare_mongodb dernier 095d17727ca0 il y a 3 mois 325MBConclusion
J’espère que cela vous a donné une idée des avantages du pipeline Jenkins et de la manière 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.