Rédaction du Jenkinsfile : checkout, étape "build" (ex: `echo 'Building...'`), étape "test" (ex: `echo 'Testing...'`)

Structurer votre Jenkinsfile avec la syntaxe déclarative

Maintenant que votre dépôt Git est prêt avec un index.html et un Jenkinsfile (initialement vide ou avec une structure de base), il est temps de passer à la rédaction effective de ce dernier. Nous allons utiliser la syntaxe Déclarative de Jenkins Pipeline, qui offre une structure claire et facile à comprendre pour définir les différentes phases de notre intégration continue.

Un Jenkinsfile Déclaratif commence toujours par le bloc pipeline { ... }. A l'intérieur de ce bloc, nous définirons au moins deux sections principales : agent et stages. La section agent spécifie où le pipeline (ou une étape spécifique) s'exécutera. Pour commencer, agent any indique que Jenkins peut utiliser n'importe quel agent disponible. La section stages { ... } contiendra la séquence de nos étapes logiques : checkout, build, et test.

Chaque étape logique sera définie par un bloc stage('Nom de l'étape') { ... } à l'intérieur de la section stages. Et chaque stage contiendra un bloc steps { ... } qui liste les actions concrètes à effectuer. C'est cette structure hiérarchique qui rend les pipelines déclaratifs si lisibles et organisés.

Etape 1 : "Checkout" - Récupérer le code source depuis Git

La toute première étape de la plupart des pipelines CI est la récupération du code source. Dans notre Jenkinsfile, nous allons créer un stage dédié à cette opération. Nous l'appellerons "Checkout SCM" (Source Code Management).

A l'intérieur du bloc steps de ce stage, nous utiliserons l'instruction git fournie par Jenkins pour cloner notre dépôt. Vous devrez remplacer 'URL_DE_VOTRE_DEPOT_GIT' par l'URL réelle de votre dépôt (par exemple, celle de GitHub, GitLab, etc.).

Voici à quoi ressemblera cette première partie de votre Jenkinsfile :

pipeline {
    agent any // Exécuter sur n'importe quel agent disponible

    stages {
        stage('Checkout SCM') { // Première étape : Récupération du code
            steps {
                echo 'Récupération du code source depuis Git...'
                git url: 'URL_DE_VOTRE_DEPOT_GIT' // Remplacez par l'URL de votre dépôt
                // Si votre dépôt est privé, vous pourriez avoir besoin d'ajouter credentialsId: 'VOTRE_ID_CREDENTIALS_GIT'
                echo 'Code source récupéré.'
            }
        }
        // D'autres étapes suivront ici
    }
}

L'instruction echo est utilisée ici pour afficher des messages dans la console du build, ce qui aide à suivre la progression du pipeline. Si votre dépôt est public, la simple mention de l'url suffit. Pour les dépôts privés, vous devrez configurer des identifiants (credentials) dans Jenkins et y faire référence via credentialsId.

Etape 2 : "Build" - Simuler la construction du projet

Une fois le code source récupéré, la phase suivante est typiquement la construction (build) du projet. Comme nous travaillons avec une simple page web statique, il n'y a pas de compilation complexe à effectuer. Nous allons donc simuler cette étape.

Ajoutons un nouveau stage nommé "Simulate Build" à la suite du stage "Checkout SCM". A l'intérieur de son bloc steps, nous utiliserons simplement une commande echo pour indiquer que la phase de build est en cours. Dans un projet réel, vous remplaceriez cette commande par des appels à des outils de build comme Maven, Gradle, npm, etc.

Votre Jenkinsfile complété avec cette étape ressemblera à ceci :

pipeline {
    agent any

    stages {
        stage('Checkout SCM') {
            steps {
                echo 'Récupération du code source depuis Git...'
                git url: 'URL_DE_VOTRE_DEPOT_GIT'
                echo 'Code source récupéré.'
            }
        }

        stage('Simulate Build') { // Deuxième étape : Simulation du build
            steps {
                echo 'Début de la simulation de construction...'
                // Dans un vrai projet, ici iraient les commandes de build
                // Par exemple : sh 'mvn clean install' ou sh 'npm run build'
                sh 'ls -la' // Affiche le contenu du workspace pour vérification
                echo 'Simulation de construction terminée.'
            }
        }
        // L'étape de test suivra ici
    }
}

J'ai ajouté une commande sh 'ls -la'. L'instruction sh permet d'exécuter des commandes shell. Ici, ls -la listera le contenu du répertoire de travail, ce qui nous permettra de vérifier que les fichiers (index.html et Jenkinsfile) ont bien été clonés à l'étape précédente.

Etape 3 : "Test" - Simuler l'exécution des tests

La dernière étape fondamentale de notre pipeline CI simple est la simulation de la phase de test. Comme pour le build, nous n'allons pas exécuter de tests complexes, mais simplement matérialiser cette étape.

Ajoutez un stage nommé "Simulate Test" après le stage "Simulate Build". Dans ses steps, nous utiliserons à nouveau echo pour marquer le début et la fin de cette phase. Nous pouvons aussi ajouter une petite vérification simple, par exemple, s'assurer que le fichier index.html existe.

Voici le Jenkinsfile complet :

pipeline {
    agent any

    stages {
        stage('Checkout SCM') {
            steps {
                echo 'Récupération du code source depuis Git...'
                git url: 'URL_DE_VOTRE_DEPOT_GIT' // N'oubliez pas de remplacer l'URL !
                echo 'Code source récupéré.'
            }
        }

        stage('Simulate Build') {
            steps {
                echo 'Début de la simulation de construction...'
                sh 'ls -la' // Vérifier le contenu du workspace
                echo 'Simulation de construction terminée.'
            }
        }

        stage('Simulate Test') { // Troisième étape : Simulation des tests
            steps {
                echo 'Début de la simulation des tests...'
                // Dans un vrai projet, ici iraient les commandes de test
                // Par exemple : sh 'mvn test' ou sh 'npm test'
                sh 'if [ -f index.html ]; then echo "Le fichier index.html existe."; else echo "ERREUR: index.html non trouvé !"; exit 1; fi'
                echo 'Simulation des tests terminée.'
            }
        }
    }

    post {
        always {
            echo 'Pipeline terminé.'
        }
        success {
            echo 'Le pipeline a réussi !'
        }
        failure {
            echo 'Le pipeline a échoué.'
        }
    }
}

La commande sh 'if [ -f index.html ]...' est un petit script shell qui vérifie l'existence du fichier index.html. Si le fichier n'est pas trouvé, il affiche une erreur et termine avec un code d'erreur (exit 1), ce qui ferait échouer le pipeline. J'ai également ajouté une section post qui s'exécute après toutes les étapes, utile pour des actions de nettoyage ou de notification.

Une fois ce Jenkinsfile rédigé, commitez-le et pushez-le vers votre dépôt Git. Votre pipeline est maintenant défini sous forme de code et prêt à être exécuté par Jenkins !