Créer et exécuter un Pipeline Jenkins de base

Introduction

Bienvenue dans ce laboratoire consacré aux fondamentaux des Pipelines Jenkins. Jenkins Pipeline est une fonctionnalité puissante qui vous permet de définir l'intégralité de votre processus de construction, de test et de déploiement sous forme de code. Cette définition est stockée dans un fichier texte appelé Jenkinsfile, généralement versionné aux côtés du code source de votre application. Cette pratique est connue sous le nom de "Pipeline-as-Code".

Dans ce laboratoire, vous vous concentrerez sur la syntaxe du Pipeline Déclaratif, qui offre une approche structurée et conviviale pour créer des pipelines. À la fin de ce laboratoire, vous serez capable de :

Créer un nouveau projet de type Pipeline dans l'interface web de Jenkins.
Écrire un Jenkinsfile de base en utilisant la syntaxe déclarative.
Configurer un projet pour utiliser un Jenkinsfile provenant d'un dépôt Git local.
Exécuter un pipeline et inspecter sa sortie.
Organiser un pipeline en plusieurs étapes (stages).
Utiliser des variables d'environnement pour gérer la configuration.

Une instance Jenkins est déjà en cours d'exécution dans un conteneur pour vous. Commençons.

Créer un projet de Pipeline dans Jenkins

Votre première étape consiste à créer un nouveau projet de Pipeline dans Jenkins. Ce type de projet est spécifiquement conçu pour exécuter des pipelines définis dans un Jenkinsfile.

Ouvrez le navigateur Firefox depuis l'interface du bureau. Le navigateur s'ouvrira automatiquement sur http://localhost:8080, vous n'avez donc pas besoin de saisir l'URL manuellement. Aucune connexion n'est requise.
Sur le tableau de bord Jenkins, cliquez sur New Item dans le menu de gauche.
Dans le champ Enter an item name, saisissez my-first-pipeline.
Sélectionnez Pipeline dans la liste des types de projets.
Cliquez sur le bouton OK en bas de la page.

Créer un projet de Pipeline

Vous serez redirigé vers la page de configuration du projet. Pour l'instant, laissez les paramètres tels quels. Faites défiler vers le bas et cliquez sur Save.

Vous avez maintenant créé un projet de Pipeline vide. À l'étape suivante, vous créerez un Jenkinsfile et configurerez ce projet pour l'utiliser.

Configurer le SCM pour utiliser un dépôt Git local

Vous allez maintenant configurer votre projet Jenkins pour récupérer sa définition de pipeline depuis un dépôt Git local hébergé à l'intérieur du conteneur Jenkins. Cela permet de rendre le laboratoire indépendant de la disponibilité du réseau externe tout en utilisant le flux de travail réel Pipeline script from SCM.

Le dépôt de démonstration est situé à l'adresse : git://localhost/pipeline-demo.git

Examinons le Jenkinsfile que Jenkins chargera depuis ce dépôt :

pipeline {
    agent any
    environment {
        DEPLOY_TARGET = 'staging'
    }
    stages {
        stage('Build') {
            steps {
                echo 'Building the application...'
                sh 'echo "Compiling source code..."'
            }
        }
        stage('Test') {
            steps {
                echo 'Testing the application...'
                sh 'echo "Running unit tests..."'
            }
        }
        stage('Deploy') {
            steps {
                echo "Deploying the application to ${env.DEPLOY_TARGET}..."
                sh 'echo "Application deployed successfully!"'
            }
        }
    }
}

Ce script de Pipeline Déclaratif inclut plusieurs étapes et illustre des concepts clés :

pipeline { ... } : Le bloc principal qui définit l'ensemble du pipeline.
agent any : Indique à Jenkins d'exécuter ce pipeline sur n'importe quel agent disponible.
environment { ... } : Définit des variables d'environnement utilisables tout au long du pipeline.
stages { ... } : Un conteneur pour toutes les étapes du pipeline.
stage('...') { ... } : Définit des étapes spécifiques. Les étapes aident à visualiser le flux de travail.
steps { ... } : Contient les commandes réelles à exécuter dans une étape.
echo '...' : Une étape qui affiche un message dans le journal de construction.
sh '...' : Une étape qui exécute des commandes shell.

Configurez maintenant votre projet Jenkins pour utiliser ce dépôt :

Revenez à l'interface Jenkins dans votre navigateur et accédez à la page du projet my-first-pipeline.
Cliquez sur Configure dans le menu de gauche.
Faites défiler jusqu'à la section Pipeline.
Changez le menu déroulant Definition de "Pipeline script" à Pipeline script from SCM.
Dans le menu déroulant SCM qui apparaît, sélectionnez Git.
Dans le champ Repository URL, saisissez : git://localhost/pipeline-demo.git
Dans le champ Script Path, saisissez : Jenkinsfile
Cliquez sur Save.

Configuration du Pipeline SCM

Votre projet est maintenant configuré pour exécuter le pipeline défini dans le dépôt Git local.

Exécuter le pipeline et vérifier la sortie

Une fois votre projet configuré, il est temps d'exécuter le pipeline et de le voir en action.

Sur la page du projet my-first-pipeline, cliquez sur Build Now dans le menu de gauche.
Une nouvelle construction sera planifiée et apparaîtra dans le panneau Build History sur la gauche. Sous l'historique, la Stage View affichera l'étape "Build" en cours d'exécution, puis passera au vert une fois terminée.
Pour voir la sortie détaillée, cliquez sur le numéro de build (par exemple, #1) dans l'historique des builds.
Sur la page de résumé du build, cliquez sur Console Output dans le menu de gauche.
Parcourez le journal. Vous y trouverez les messages de vos étapes de pipeline, confirmant que votre pipeline s'est exécuté avec succès.

...
[Pipeline] { (Build)
[Pipeline] echo
Building the application...
[Pipeline] sh
+ echo Compiling source code...
Compiling source code...
[Pipeline] } // stage
[Pipeline] { (Test)
[Pipeline] echo
Testing the application...
[Pipeline] sh
+ echo Running unit tests...
Running unit tests...
[Pipeline] } // stage
[Pipeline] { (Deploy)
[Pipeline] echo
Deploying the application to staging...
[Pipeline] sh
+ echo Application deployed successfully!
Application deployed successfully!
[Pipeline] } // stage
...
Finished: SUCCESS

Vous avez exécuté avec succès votre premier pipeline et vérifié sa sortie. Remarquez comment le pipeline a automatiquement exécuté les trois étapes (Build, Test, Deploy) définies dans le Jenkinsfile du dépôt.

Comprendre les étapes multiples dans le pipeline

Les pipelines réels sont composés de plusieurs étapes, telles que la construction, le test et le déploiement d'une application. Le Jenkinsfile du dépôt local inclut déjà ces étapes distinctes, illustrant ce concept important.

Examinons comment le pipeline est structuré avec plusieurs étapes :

stages {
    stage('Build') {
        steps {
            echo 'Building the application...'
            sh 'echo "Compiling source code..."'
        }
    }
    stage('Test') {
        steps {
            echo 'Testing the application...'
            sh 'echo "Running unit tests..."'
        }
    }
    stage('Deploy') {
        steps {
            echo "Deploying the application to ${env.DEPLOY_TARGET}..."
            sh 'echo "Application deployed successfully!"'
        }
    }
}

Revenez à l'interface Jenkins pour le projet my-first-pipeline et cliquez sur Build Now pour exécuter à nouveau le pipeline si vous ne l'avez pas déjà fait.
Observez la Stage View sur le tableau de bord du projet. Vous verrez trois colonnes représentant vos étapes "Build", "Test" et "Deploy". Jenkins visualise la progression au fur et à mesure que le build passe par chacune d'elles.
Cliquez sur n'importe quelle étape dans la Stage View pour voir les journaux détaillés de cette étape spécifique.
Remarquez comment chaque étape s'exécute séquentiellement - Jenkins attend qu'une étape se termine avec succès avant de passer à la suivante.

En structurant votre pipeline avec des étapes, vous créez un flux de travail clair et maintenable, facile à surveiller. Chaque étape représente une phase logique de votre processus CI/CD, ce qui permet d'identifier facilement où surviennent les problèmes et de visualiser la progression de vos builds.

Comprendre les variables d'environnement dans un pipeline

Dans cette dernière étape, vous allez découvrir les variables d'environnement. La directive environment vous permet de définir des variables utilisables tout au long de votre pipeline, ce qui est idéal pour gérer les paramètres de configuration sans les coder en dur dans vos étapes.

Le Jenkinsfile du dépôt local illustre déjà ce concept avec une variable d'environnement qui spécifie une cible de déploiement.

Examinons comment les variables d'environnement sont définies et utilisées :

pipeline {
    agent any
    environment {
        DEPLOY_TARGET = 'staging'
    }
    stages {
        // ... autres étapes ...
        stage('Deploy') {
            steps {
                echo "Deploying the application to ${env.DEPLOY_TARGET}..."
                sh 'echo "Application deployed successfully!"'
            }
        }
    }
}

Points clés sur les variables d'environnement dans les Pipelines Jenkins :

Le bloc environment { ... } définit des variables disponibles dans tout le pipeline.
Les variables sont accessibles via la syntaxe ${env.VARIABLE_NAME}.
Il est crucial d'utiliser des guillemets doubles (") pour les chaînes avec interpolation de variables, car l'interpolation de variables Groovy ne fonctionne qu'à l'intérieur de chaînes entre guillemets doubles.
Les variables d'environnement rendent vos pipelines plus flexibles et plus faciles à maintenir.

Si ce n'est pas déjà fait, déclenchez un nouveau build dans Jenkins en cliquant sur Build Now.
Une fois le build terminé, vérifiez la Console Output. Dans le journal de l'étape "Deploy", vous verrez que la variable a été correctement substituée :

...
[Pipeline] { (Deploy)
[Pipeline] echo
Deploying the application to staging...
[Pipeline] sh
+ echo Application deployed successfully!
Application deployed successfully!
[Pipeline] } // stage
...
Finished: SUCCESS

Remarquez comment la valeur staging de la variable d'environnement DEPLOY_TARGET a été automatiquement substituée dans l'instruction echo.

Les variables d'environnement sont essentielles pour créer des pipelines flexibles qui peuvent être facilement configurés pour différents environnements (développement, staging, production) sans modifier le code du pipeline lui-même.

Résumé

Félicitations ! Vous avez terminé avec succès cette introduction aux Pipelines Jenkins. Vous avez appris les concepts fondamentaux de la définition d'un flux de travail CI/CD sous forme de code.

Dans ce laboratoire, vous avez appris à :

Créer un projet de Pipeline dans l'interface Jenkins.
Configurer un projet pour utiliser un Jenkinsfile provenant d'un dépôt Git local.
Comprendre la structure d'un Pipeline Déclaratif avec plusieurs étapes.
Exécuter un pipeline et inspecter sa sortie console.
Observer comment les pipelines sont structurés en étapes logiques pour plus de clarté et d'organisation.
Comprendre comment les variables d'environnement sont définies et utilisées pour rendre les pipelines plus dynamiques.

Ces compétences fondamentales sont essentielles pour construire des pipelines d'automatisation sophistiqués. Vous êtes maintenant prêt à explorer des sujets plus avancés, tels que l'utilisation de paramètres, la gestion des identifiants et l'intégration avec divers outils de construction et de déploiement.

Introduction aux Pipelines Jenkins