Ecrire et exécuter un Jenkinsfile déclaratif

Le Jenkinsfile déclaratif : votre feuille de route pour l'automatisation

Après avoir défini les étapes théoriques d'un pipeline CI simple, il est temps de les concrétiser. Dans Jenkins, l'approche moderne et recommandée pour définir des pipelines est le "Pipeline as Code", qui se matérialise par un fichier texte appelé Jenkinsfile. Ce fichier, écrit en utilisant une syntaxe spécifique basée sur Groovy, décrit l'ensemble du processus d'automatisation : les étapes, leur ordre, les conditions d'exécution, la gestion des erreurs, etc.

Il existe deux syntaxes principales pour écrire un Jenkinsfile : la syntaxe Scripted et la syntaxe Déclarative. Pour les débutants et pour la majorité des cas d'usage, la syntaxe Déclarative est fortement conseillée. Elle offre une structure plus simple, plus lisible et plus opinionée, ce qui facilite l'apprentissage et la maintenance. Elle impose un cadre clair avec des sections prédéfinies (comme pipeline, agent, stages, steps), rendant la logique du pipeline plus évidente.

L'un des avantages majeurs du Jenkinsfile est qu'il peut (et devrait) être stocké dans votre système de gestion de code source (SCM) au même titre que le code de votre application. Cela signifie que votre pipeline est versionné, partageable, et que son évolution est tracée. Toute modification du pipeline passe par le même processus de revue que le code applicatif, renforçant la collaboration et la fiabilité.

Création du job Pipeline et rédaction du Jenkinsfile

La première étape pratique consiste à créer un nouveau job dans Jenkins qui exécutera notre Jenkinsfile. Dans l'interface Jenkins :

1. Cliquez sur "Nouveau Projet" (ou "New Item").
2. Entrez un nom pour votre projet (par exemple, "Mon-Premier-Pipeline-Declaratif").
3. Sélectionnez le type "Pipeline" et cliquez sur "OK".

Vous arrivez sur la page de configuration du job Pipeline. Dans la section "Pipeline", vous avez principalement deux options pour fournir le script :

• Pipeline script : Vous pouvez écrire ou coller votre Jenkinsfile directement dans la zone de texte fournie. C'est pratique pour des tests rapides ou des pipelines très simples qui n'ont pas vocation à être partagés ou versionnés intensivement.
• Pipeline script from SCM : C'est l'option recommandée. Elle permet à Jenkins de récupérer le Jenkinsfile depuis un dépôt Git (ou autre SCM). Vous devrez alors configurer :
  • SCM : Choisissez "Git".
  • Repository URL : L'URL de votre dépôt Git (celui contenant votre application et, idéalement, votre Jenkinsfile).
  • Credentials : Si le dépôt est privé, sélectionnez les identifiants appropriés.
  • Branches to build : Spécifiez la branche (par exemple, */main ou */master).
  • Script Path : Le nom du fichier Jenkinsfile dans votre dépôt (par défaut, c'est "Jenkinsfile"). Assurez-vous que ce fichier existe à la racine de votre dépôt ou au chemin spécifié.

Pour notre premier exemple, nous allons rédiger un Jenkinsfile simple qui reprend les étapes conceptuelles de Checkout, Build et Test. Voici à quoi il pourrait ressembler. Si vous utilisez l'option "Pipeline script", vous copiez-collez ce code. Si vous utilisez "Pipeline script from SCM", ce contenu doit être dans un fichier nommé Jenkinsfile à la racine de votre dépôt Git.

pipeline {
    agent any // Indique que le pipeline peut s'exécuter sur n'importe quel agent disponible

    stages {
        stage('Checkout') { // Première étape : Récupération du code
            steps {
                echo 'Etape 1: Récupération du code source...'
                // Si le Jenkinsfile est chargé depuis un SCM, Jenkins a déjà cloné le dépôt.
                // Pour un projet réel, vous auriez ici : 
                // git url: 'https://votre-serveur-git.com/votre-projet.git', branch: 'main'
                // Mais si le Jenkinsfile est DANS le SCM, `checkout scm` est souvent implicite ou peut être ajouté pour plus de clarté.
                // Pour cet exemple simple, on simule.
                sh 'ls -la' // Affiche le contenu du workspace après checkout
            }
        }
        stage('Build') { // Deuxième étape : Compilation (simulée)
            steps {
                echo 'Etape 2: Compilation du code...'
                // Exemple conceptuel, remplacez par vos vraies commandes de build
                sh 'echo "Compilation en cours... cela pourrait être mvn compile ou npm install"'
                sh 'mkdir -p target'
                sh 'echo "Produit du build" > target/mon-artefact.txt'
            }
        }
        stage('Test') { // Troisième étape : Tests (simulés)
            steps {
                echo 'Etape 3: Exécution des tests unitaires...'
                // Exemple conceptuel, remplacez par vos vraies commandes de test
                sh 'echo "Tests en cours... cela pourrait être mvn test ou npm test"'
                // Simuler un succès de test
                sh 'echo "Tous les tests sont passés !"'
            }
        }
    }
    post {
        always {
            echo 'Ce pipeline est terminé.'
            // Nettoyage optionnel du workspace
            // cleanWs()
        }
        success {
            echo 'Le pipeline a réussi !'
        }
        failure {
            echo 'Le pipeline a échoué.'
        }
    }
}

Ce Jenkinsfile définit un pipeline avec un agent quelconque, trois étapes séquentielles (Checkout, Build, Test) et une section post qui exécute des actions en fonction du résultat du pipeline. Les commandes sh exécutent des scripts shell. Les commandes echo sont utiles pour afficher des messages dans les logs.

Lancement du pipeline et analyse de la sortie

Une fois votre job Pipeline configuré et le Jenkinsfile fourni (soit directement, soit via SCM), enregistrez la configuration du job en cliquant sur "Sauvegarder" (ou "Save"). Vous serez redirigé vers la page principale de votre job.

Pour exécuter le pipeline, cliquez sur "Lancer un build" (ou "Build Now") dans le menu de gauche. Jenkins va alors démarrer une nouvelle exécution de votre pipeline. Vous verrez apparaître un nouveau numéro de build dans l'historique des builds (Build History) sur la gauche. Chaque build est numéroté séquentiellement (#1, #2, etc.).

Cliquez sur le numéro du build en cours ou récemment terminé. Vous accéderez à la page de ce build spécifique. L'élément le plus important ici pour le moment est la "Sortie de la console" (ou "Console Output"). Cliquez sur ce lien pour voir les logs détaillés de l'exécution de votre pipeline. C'est ici que vous verrez les messages de vos commandes echo, les sorties de vos commandes sh, et surtout, les messages d'erreur si quelque chose se passe mal.

Jenkins offre également une vue graphique de la progression du pipeline, appelée "Stage View". Elle montre chaque étape (stage) définie dans votre Jenkinsfile et son statut (succès, échec, en cours). En cliquant sur une étape, vous pouvez voir les logs spécifiques à cette étape. Si vous avez installé le plugin Blue Ocean, il offre une interface utilisateur encore plus moderne et visuelle pour suivre vos pipelines.

Analysez attentivement la sortie console. Vérifiez que chaque étape s'exécute comme prévu et que les commandes produisent les résultats attendus. Si une étape échoue (par exemple, une commande sh renvoie un code d'erreur non nul), le pipeline s'arrêtera (par défaut) et sera marqué comme échoué (généralement en rouge). Comprendre comment lire les logs est une compétence essentielle pour déboguer et améliorer vos pipelines Jenkins.