Schreiben von Scripted Jenkins Pipelines

Einführung

Jenkins unterstützt zwei Arten von Pipelines. Die Declarative Pipeline verwendet einen strukturierten pipeline { ... }-Block, während die Scripted Pipeline auf Groovy-Code mit node-, stage- und Schritt-Aufrufen basiert. Die Scripted Pipeline ist besonders nützlich, wenn ein Workflow eine direktere Steuerung durch Groovy-Kontrollstrukturen erfordert.

In diesem Lab erstellen Sie einen Pipeline-Job namens scripted-pipeline-demo, führen eine einfache Scripted Pipeline aus und erweitern diese anschließend um eine if-Bedingung sowie einen try/finally-Block zur Bereinigung.

Schreiben einer einfachen Scripted Pipeline

In diesem Schritt schreiben Sie die erste Version einer Scripted Pipeline. Der node-Block weist Jenkins an, einen Executor und einen Workspace zuzuweisen. Innerhalb dieses Blocks definiert stage einen sichtbaren Teil des Workflows, und sh führt einen Shell-Befehl aus.

Erstellen Sie die Datei /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

Geben Sie die Datei mit Zeilennummern aus, um die Struktur zu überprüfen:

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

Sie sollten nun einen node-Block sehen, der die Stages Prepare und Build enthält.

Erstellen eines Pipeline-Jobs aus dem Skript

In diesem Schritt erstellen Sie einen Jenkins Pipeline-Job, der das Groovy-Skript direkt speichert. Jenkins Pipeline-Jobs werden als XML-Dateien unter /var/jenkins_home/jobs abgelegt. Python wird das Groovy-Skript vor dem Schreiben der Job-Konfiguration XML-escapen, damit Zeichen wie Anführungszeichen und geschweifte Klammern sicher erhalten bleiben.

Generieren Sie die Pipeline-Job-Konfiguration:

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

Kopieren Sie die Job-Konfiguration in Jenkins und laden Sie diese neu:

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

Bestätigen Sie, dass Jenkins den Pipeline-Job laden kann:

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

Ausführen der Scripted Pipeline

In diesem Schritt lösen Sie den Pipeline-Job aus und überprüfen das Ergebnis. Jenkins schützt POST-Anfragen mit einem Crumb, daher fordert der erste Befehl einen Crumb an und verwendet den passenden Cookie-Speicher wieder.

Starten Sie den ersten 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

Warten Sie, bis der Build #1 abgeschlossen ist:

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

Überprüfen Sie das Build-Ergebnis:

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

Das erfolgreiche Ergebnis beweist, dass Jenkins die Scripted Pipeline-Syntax akzeptiert und die Shell-Schritte ausgeführt hat.

Hinzufügen von Groovy-Kontrollfluss

In diesem Schritt aktualisieren Sie die Scripted Pipeline mit Groovy-Kontrollstrukturen. Der if-Block entscheidet, ob die Test-Stage ausgeführt werden soll. Der try/finally-Block stellt sicher, dass die Bereinigungsnachricht auch dann ausgegeben wird, wenn eine Stage fehlschlägt.

Ersetzen Sie das Pipeline-Skript durch eine erweiterte Version:

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

Generieren Sie die Job-Konfiguration neu und laden Sie Jenkins erneut:

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

Bestätigen Sie, dass die aktualisierte Job-Konfiguration den Text der neuen Test-Stage enthält:

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

Überprüfen des aktualisierten Pipeline-Protokolls

In diesem Schritt führen Sie die aktualisierte Scripted Pipeline aus und überprüfen die Konsolenausgabe. Das Protokoll sollte die bedingte Test-Stage-Nachricht sowie die Bereinigungsnachricht aus dem finally-Block enthalten.

Starten Sie den zweiten 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

Warten Sie, bis der Build #2 abgeschlossen ist:

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

Geben Sie die wichtigen Zeilen der Konsole aus:

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

Öffnen Sie Firefox über die Desktop-Oberfläche und besuchen Sie http://localhost:8080/job/scripted-pipeline-demo/2/console. Die Konsolenseite sollte die Ausgabe der Test-Stage und die Bereinigungsnachricht anzeigen.

Jenkins scripted Pipeline Konsolenausgabe

Zusammenfassung

Sie haben eine Jenkins Scripted Pipeline mit node-, stage-, echo- und sh-Schritten geschrieben, diese als Pipeline-Job ausgeführt und anschließend um Groovy-Kontrollstrukturen wie if und try/finally erweitert. Sie haben beide Pipeline-Versionen anhand der Jenkins-Build-Ergebnisse und der Konsolenausgabe verifiziert.