LabEx
EntrerRejoindre

Écriture de pipelines Jenkins scriptés

Beginner

Introduction

Jenkins prend en charge deux styles de pipelines. Le pipeline déclaratif utilise un bloc structuré pipeline { ... }, tandis que le pipeline scripté utilise du code Groovy avec des appels node, stage et des étapes. Le pipeline scripté est particulièrement utile lorsqu'un flux de travail nécessite un contrôle de flux Groovy plus direct.

Dans ce laboratoire, vous allez créer un job de pipeline nommé scripted-pipeline-demo, exécuter un pipeline scripté simple, puis le mettre à jour avec une condition if et un bloc de nettoyage try/finally.

Écrire un pipeline scripté de base

Dans cette étape, vous allez écrire la première version d'un pipeline scripté. Le bloc node demande à Jenkins d'allouer un exécuteur et un espace de travail. À l'intérieur, stage nomme une partie visible du flux de travail, et sh exécute une commande shell.

Créez le fichier /home/labex/project/scripted-pipeline.groovy :

cat > /home/labex/project/scripted-pipeline.groovy <<'GROOVY'
node {
    stage('Prepare') {
        echo 'Preparing scripted pipeline'
        sh 'pwd'
    }

    stage('Build') {
        echo 'Building with scripted syntax'
        sh 'echo Compiling scripted pipeline demo'
    }
}
GROOVY

Affichez le fichier avec les numéros de ligne pour vérifier la structure :

nl -ba /home/labex/project/scripted-pipeline.groovy

Vous devriez voir un bloc node contenant les étapes Prepare et Build.

Créer un job de pipeline à partir du script

Dans cette étape, vous allez créer un job de pipeline Jenkins qui stocke le script Groovy en ligne. Les jobs de pipeline Jenkins sont enregistrés au format XML sous /var/jenkins_home/jobs. Python se chargera d'échapper les caractères XML du script Groovy avant d'écrire la configuration du job, afin que les caractères tels que les guillemets et les accolades soient préservés en toute sécurité.

Générez la configuration du job de pipeline :

python3 - <<'PY'
from html import escape
from pathlib import Path

script = Path("/home/labex/project/scripted-pipeline.groovy").read_text()
config = f"""<?xml version='1.1' encoding='UTF-8'?>
<flow-definition plugin="workflow-job">
  <actions/>
  <description>Run a Jenkins scripted Pipeline example.</description>
  <keepDependencies>false</keepDependencies>
  <properties/>
  <definition class="org.jenkinsci.plugins.workflow.cps.CpsFlowDefinition" plugin="workflow-cps">
    <script>{escape(script)}</script>
    <sandbox>true</sandbox>
  </definition>
  <triggers/>
  <disabled>false</disabled>
</flow-definition>
"""
Path("/home/labex/project/scripted-pipeline-config.xml").write_text(config)
PY

Copiez la configuration du job dans Jenkins et rechargez :

docker exec jenkins mkdir -p /var/jenkins_home/jobs/scripted-pipeline-demo
docker cp /home/labex/project/scripted-pipeline-config.xml jenkins:/var/jenkins_home/jobs/scripted-pipeline-demo/config.xml
/home/labex/project/reload-jenkins.sh

Confirmez que Jenkins peut charger le job de pipeline :

curl -fsS http://localhost:8080/job/scripted-pipeline-demo/api/json | grep -o '"name":"scripted-pipeline-demo"'

Exécuter le pipeline scripté

Dans cette étape, vous allez déclencher le job de pipeline et inspecter le résultat. Jenkins protège les requêtes POST avec un "crumb" (jeton de sécurité), donc la première commande demande un crumb et réutilise le fichier de cookies correspondant.

Déclenchez le premier build :

CRUMB=$(curl -fsS -c /tmp/jenkins-scripted-build.cookies 'http://localhost:8080/crumbIssuer/api/xml?xpath=concat(//crumbRequestField,":",//crumb)')
curl -fsS -b /tmp/jenkins-scripted-build.cookies -H "$CRUMB" -X POST http://localhost:8080/job/scripted-pipeline-demo/build

Attendez que le build #1 se termine :

until curl -fsS http://localhost:8080/job/scripted-pipeline-demo/1/api/json >/tmp/scripted-build-1.json 2>/dev/null && grep -q '"building":false' /tmp/scripted-build-1.json; do
  echo "Waiting for scripted pipeline build #1..."
  sleep 3
done

Vérifiez le résultat du build :

curl -fsS http://localhost:8080/job/scripted-pipeline-demo/1/api/json | grep -o '"result":"SUCCESS"'

Le résultat positif confirme que Jenkins a accepté la syntaxe du pipeline scripté et a exécuté les étapes shell.

Ajouter un contrôle de flux Groovy

Dans cette étape, vous allez mettre à jour le pipeline scripté avec un contrôle de flux Groovy. Le bloc if décide si l'étape Test doit être exécutée. Le bloc try/finally garantit que le message de nettoyage s'affiche même si une étape échoue.

Remplacez le script du pipeline par une version plus riche :

cat > /home/labex/project/scripted-pipeline.groovy <<'GROOVY'
node {
    def runTests = true

    try {
        stage('Prepare') {
            echo 'Preparing scripted pipeline'
            sh 'pwd'
        }

        stage('Build') {
            echo 'Building with scripted syntax'
            sh 'echo Compiling scripted pipeline demo'
        }

        if (runTests) {
            stage('Test') {
                echo 'Tests enabled by Groovy condition'
                sh 'echo Running scripted pipeline tests'
            }
        }
    } finally {
        echo 'Pipeline cleanup complete'
    }
}
GROOVY

Régénérez la configuration du job et rechargez Jenkins :

python3 - <<'PY'
from html import escape
from pathlib import Path

script = Path("/home/labex/project/scripted-pipeline.groovy").read_text()
config = f"""<?xml version='1.1' encoding='UTF-8'?>
<flow-definition plugin="workflow-job">
  <actions/>
  <description>Run a Jenkins scripted Pipeline example.</description>
  <keepDependencies>false</keepDependencies>
  <properties/>
  <definition class="org.jenkinsci.plugins.workflow.cps.CpsFlowDefinition" plugin="workflow-cps">
    <script>{escape(script)}</script>
    <sandbox>true</sandbox>
  </definition>
  <triggers/>
  <disabled>false</disabled>
</flow-definition>
"""
Path("/home/labex/project/scripted-pipeline-config.xml").write_text(config)
PY
docker cp /home/labex/project/scripted-pipeline-config.xml jenkins:/var/jenkins_home/jobs/scripted-pipeline-demo/config.xml
/home/labex/project/reload-jenkins.sh

Confirmez que la configuration mise à jour du job contient bien le texte de la nouvelle étape Test :

docker exec jenkins grep -n 'Tests enabled by Groovy condition' /var/jenkins_home/jobs/scripted-pipeline-demo/config.xml

Inspecter le journal du pipeline mis à jour

Dans cette étape, vous allez exécuter le pipeline scripté mis à jour et inspecter la sortie de la console. Le journal doit afficher le message de l'étape conditionnelle Test ainsi que le message de nettoyage provenant du bloc finally.

Déclenchez le deuxième build :

CRUMB=$(curl -fsS -c /tmp/jenkins-scripted-build.cookies 'http://localhost:8080/crumbIssuer/api/xml?xpath=concat(//crumbRequestField,":",//crumb)')
curl -fsS -b /tmp/jenkins-scripted-build.cookies -H "$CRUMB" -X POST http://localhost:8080/job/scripted-pipeline-demo/build

Attendez que le build #2 se termine :

until curl -fsS http://localhost:8080/job/scripted-pipeline-demo/2/api/json >/tmp/scripted-build-2.json 2>/dev/null && grep -q '"building":false' /tmp/scripted-build-2.json; do
  echo "Waiting for scripted pipeline build #2..."
  sleep 3
done

Affichez les lignes importantes de la console :

curl -fsS http://localhost:8080/job/scripted-pipeline-demo/2/consoleText | grep -E 'Tests enabled|Running scripted pipeline tests|Pipeline cleanup complete|Finished: SUCCESS'

Ouvrez Firefox depuis l'interface de bureau et visitez http://localhost:8080/job/scripted-pipeline-demo/2/console. La page de la console devrait afficher la sortie de l'étape Test et le message de nettoyage.

Sortie de la console du pipeline Jenkins scripté

Résumé

Vous avez écrit un pipeline Jenkins scripté avec les étapes node, stage, echo et sh, vous l'avez exécuté en tant que job de pipeline, puis vous avez ajouté un contrôle de flux Groovy avec if et try/finally. Vous avez vérifié les deux versions du pipeline via les résultats des builds Jenkins et la sortie de la console.