Créer et Exécuter un Pipeline Jenkins Basique

Introduction

Bienvenue dans ce laboratoire sur les fondamentaux des Jenkins Pipelines. Jenkins Pipeline est une fonctionnalité puissante qui vous permet de définir l'intégralité de votre processus de build, de test et de déploiement sous forme de code. Cette définition est stockée dans un fichier texte appelé Jenkinsfile, qui est 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 Declarative Pipeline, qui offre une manière structurée et conviviale de créer des pipelines. À la fin de ce laboratoire, vous serez capable de :

Créer un nouveau projet Pipeline dans l'interface web de Jenkins.
Écrire un Jenkinsfile de base en utilisant la syntaxe Declarative.
Configurer un projet pour utiliser un Jenkinsfile à partir 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 Pipeline dans Jenkins

Votre première étape consiste à créer un nouveau projet de type 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 de 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 (Nouvel Élément) dans le menu de gauche.
Dans le champ Enter an item name (Entrez un nom d'élément), tapez my-first-pipeline.
Sélectionnez Pipeline dans la liste des types de projets.
Cliquez sur le bouton OK en bas de la page.

Vous serez redirigé vers la page de configuration du projet. Pour l'instant, nous laisserons les paramètres tels quels. Faites défiler jusqu'en bas et cliquez sur Save (Enregistrer).

Vous avez maintenant créé un projet 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 Distant

Vous allez maintenant configurer votre projet Jenkins pour récupérer sa définition de pipeline à partir d'un dépôt Git distant. Nous utiliserons un dépôt de démonstration qui contient un Jenkinsfile pré-configuré et une application d'exemple.

Le dépôt de démonstration est situé à l'adresse : https://github.com/labex-labs/jenkins-demo

Examinons le Jenkinsfile que nous utiliserons à partir du dépôt distant :

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 Declarative Pipeline comprend plusieurs étapes (stages) et démontre des concepts clés :

pipeline { ... }: Le bloc principal qui définit l'intégralité du pipeline.
agent any: Indique à Jenkins d'exécuter ce pipeline sur n'importe quel agent disponible.
environment { ... }: Définit les variables d'environnement qui peuvent être utilisées 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 build.
sh '...': Une étape qui exécute des commandes shell.

Maintenant, configurez votre projet Jenkins pour utiliser ce dépôt distant :

Revenez à l'interface utilisateur de Jenkins dans votre navigateur et naviguez vers 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, entrez : https://github.com/labex-labs/jenkins-demo
Dans le champ Script Path, entrez : introduction-to-pipelines/Jenkinsfile
Cliquez sur Save.

Jenkins pipeline configuration for remote Git repository

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

Exécuter le Pipeline et Vérifier la Sortie

Avec 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 exécution sera planifiée et apparaîtra dans le panneau Build History à gauche. Sous l'historique, la Stage View montrera l'étape "Build" en cours d'exécution, puis deviendra verte 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.
Faites défiler 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. Notez comment le pipeline a automatiquement exécuté les trois étapes (Build, Test, Deploy) qui étaient définies dans le Jenkinsfile du dépôt distant.

Comprendre les Étapes Multiples dans le Pipeline

Les pipelines du monde réel sont composés de plusieurs étapes, telles que la compilation, le test et le déploiement d'une application. Le Jenkinsfile du dépôt distant inclut déjà ces étapes distinctes, démontrant 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!"'
        }
    }
}

Retournez à l'interface Jenkins pour le projet my-first-pipeline et cliquez sur Build Now pour exécuter à nouveau le pipeline si ce n'est 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 avance à travers 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 à l'étape 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 apprendrez les variables d'environnement. La directive environment vous permet de définir des variables qui peuvent être utilisées 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 distant démontre 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 {
        // ... other stages ...
        stage('Deploy') {
            steps {
                echo "Deploying the application to ${env.DEPLOY_TARGET}..."
                sh 'echo "Application deployed successfully!"'
            }
        }
    }
}

Points clés concernant les variables d'environnement dans les pipelines Jenkins :

Le bloc environment { ... } définit des variables qui sont disponibles tout au long du pipeline.
Les variables sont accessibles en utilisant la syntaxe ${env.VARIABLE_NAME}.
Il est crucial d'utiliser des guillemets doubles (") pour les chaînes de caractères avec interpolation de variables, car l'interpolation de variables de Groovy ne fonctionne qu'à l'intérieur des 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 une nouvelle exécution dans Jenkins en cliquant sur Build Now.
Une fois le build terminé, vérifiez la Console Output du build. 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 de la variable d'environnement DEPLOY_TARGET, staging, 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 en tant que code.

Dans ce laboratoire, vous avez pratiqué comment :

Créer un projet Pipeline dans l'interface Jenkins.
Configurer un projet pour utiliser un Jenkinsfile à partir d'un dépôt Git distant (SCM).
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 (credentials) et l'intégration avec divers outils de build et de déploiement.

Introduction aux Pipelines Jenkins