Erstellen Sie Ihre erste Jenkins Declarative Pipeline für CI/CD

Jenkins ist der De-facto-Standard für Open-Source-Automatisierungsserver und bildet das Rückgrat für Continuous Integration und Continuous Delivery (CI/CD)-Pipelines in Tausenden von Organisationen. Während Jenkins zwei Arten von Pipeline-Syntaxen anbietet – Scripted und Declarative – ist die Syntax der Declarative Pipeline für die meisten Benutzer der empfohlene Ansatz, da sie eine einfachere, strukturiertere und besser lesbare Groovy DSL darstellt.

Diese Anleitung bietet ein umfassendes Schritt-für-Schritt-Tutorial zum Erstellen Ihrer allerersten funktionalen Jenkins Declarative Pipeline. Wir behandeln die Integration von Quellcodeverwaltung (SCM), die Definition der Build-Umgebung, die Ausführung von Tests und die Implementierung einer Beispiel-Deployment-Stufe, um Ihnen eine solide Grundlage für die Automatisierung Ihres Softwareauslieferungszyklus zu geben.

Verständnis der Struktur der Declarative Pipeline

Die Declarative Pipeline definiert den gesamten Workflow in einer Datei namens Jenkinsfile, die zusammen mit Ihrem Anwendungscode in Ihrem SCM-Repository (z. B. Git) gespeichert wird. Diese Praxis ist als Pipeline as Code bekannt.

Kernelemente einer Declarative Pipeline

Eine Declarative Pipeline muss die folgenden Blöcke der obersten Ebene enthalten:

pipeline: Der obligatorische äußerste Block, der den Pipeline-Inhalt definiert.
agent: Gibt an, wo die Pipeline oder eine bestimmte Stufe ausgeführt wird (z. B. any, none oder spezifische Labels).
stages: Enthält einen oder mehrere sequentielle stage-Blöcke.
stage: Definiert einen konzeptionellen Arbeitsblock (z. B. Build, Test, Deploy).
steps: Enthält einen oder mehrere Befehle oder Funktionen, die innerhalb einer stage ausgeführt werden.

pipeline {
    agent any 
    environment { // Optional: Definiert Umgebungsvariablen
        APP_VERSION = '1.0.0'
    }
    stages {
        stage('Build') {
            steps {
                // Befehle kommen hierher
            }
        }
    }
    post { // Optional: Aktionen, die nach Abschluss der Pipeline ausgeführt werden
        always { 
            echo 'Pipeline abgeschlossen.' 
        }
    }
}

Schritt 1: Einrichten des Jenkins-Jobs

Um eine Pipeline aus Code auszuführen, müssen Sie einen Jenkins-Job konfigurieren, der die Jenkinsfile aus Ihrem Repository liest.

Navigieren Sie zu Ihrem Jenkins-Dashboard und wählen Sie New Item.
Geben Sie einen Namen für Ihre Pipeline ein (z. B. my-first-ci-pipeline).
Wählen Sie den Elementtyp Pipeline und klicken Sie auf OK.
Scrollen Sie auf der Konfigurationsseite nach unten zum Abschnitt Pipeline.
Ändern Sie die Definition von Pipeline script zu Pipeline script from SCM.
Wählen Sie Ihr SCM (z. B. Git).
Geben Sie die Repository URL ein und konfigurieren Sie bei Bedarf Ihre Anmeldedaten.
Stellen Sie sicher, dass der Script Path auf Jenkinsfile gesetzt ist (Standard).

Schritt 2: Definieren der `Jenkinsfile` für CI/CD

Wir erstellen eine umfassende Jenkinsfile, die einen einfachen CI/CD-Workflow simuliert und Standardstufen für eine erfolgreiche Bereitstellung integriert.

Gehen Sie davon aus, dass Sie eine Repository-Struktur mit Ihrem Anwendungscodes (z. B. ein einfaches Python- oder Java-Projekt) und der Jenkinsfile im Stammverzeichnis haben.

Das vollständige Beispiel einer Declarative Pipeline

Diese Pipeline verwendet den node-Agenten (falls konfiguriert) und grundlegende Shell-Schritte (sh), um reale Arbeiten zu simulieren. Die Bereitstellungsstufe ist bedingt und wird nur ausgeführt, wenn die vorherigen Stufen erfolgreich abgeschlossen wurden.

// Jenkinsfile
pipeline {
    // 1. Agent Definition: Legt fest, wo die gesamte Pipeline ausgeführt wird
    agent { 
        label 'my-build-agent' // Verwenden Sie ein bestimmtes Label, falls verfügbar, oder 'any'
    }

    // 2. Umgebungsvariablen: Definieren Sie Variablen, die in der gesamten Pipeline verwendbar sind
    environment {
        CONTAINER_REGISTRY = 'registry.example.com'
        IMAGE_NAME = 'myapp'
    }

    stages {

        // Stufe 1: Checkout (Quellcodeverwaltung)
        stage('Checkout Source') {
            steps {
                // Der Schritt 'checkout scm' prüft automatisch den Code aus
                // basierend auf der im Jenkins-Job-Setup definierten Konfiguration.
                checkout scm
                sh 'echo "Quellcode erfolgreich ausgecheckt."
            }
        }

        // Stufe 2: Erstellen von Artefakten
        stage('Build Artifact') {
            steps {
                sh 'echo "Starte Build für $IMAGE_NAME:$BUILD_ID"'
                // Simulation: Erstellen eines Docker-Images oder Kompilieren einer jar/war-Datei
                sh "docker build -t ${IMAGE_NAME}:${BUILD_ID} ."
            }
        }

        // Stufe 3: Tests und Qualitätskontrollen
        stage('Run Tests') {
            steps {
                sh './run_unit_tests.sh'
                sh 'echo "Führe Integrationstests aus..."'
                // Beispiel für das Sammeln von Testergebnissen (erfordert entsprechende Plugins)
                // junit '**/target/surefire-reports/*.xml'
            }
        }

        // Stufe 4: Bereitstellung (Bedingt)
        stage('Deploy to Staging') {
            // Die Direktive 'when' stellt sicher, dass die Stufe nur unter bestimmten Bedingungen ausgeführt wird
            when {
                branch 'main'
            }
            steps {
                sh "docker push ${CONTAINER_REGISTRY}/${IMAGE_NAME}:${BUILD_ID}"
                sh 'kubectl apply -f k8s/deployment-staging.yaml'
                script {
                    // Script-Blöcke ermöglichen traditionelle Groovy-Logik innerhalb von Declarative-Schritten
                    echo "Bereitstellung in der Staging-Umgebung erfolgreich."
                }
            }
        }
    }

    // 3. Post Actions: Definieren Sie Aktionen basierend auf dem endgültigen Pipeline-Status
    post {
        success {
            echo 'Pipeline erfolgreich abgeschlossen. Benachrichtige das Team über Slack...'
            // slackSend channel: '#devops-alerts', message: 'CI/CD Success!'
        }
        failure {
            echo 'Pipeline fehlgeschlagen. Überprüfen Sie die Protokolle auf Fehler.'
        }
        cleanup {
            sh 'docker rmi -f $(docker images -aq --filter label=build_id=$BUILD_ID)'
        }
    }
}

Schritt 3: Ausführen und Überwachen der Pipeline

Sobald die Jenkinsfile committet und in den in Ihrem Jenkins-Job konfigurierten Branch gepusht wurde:

Klicken Sie auf der Jenkins-Job-Seite auf Build Now (oder warten Sie auf den SCM-Polling-/Webhook-Trigger).
Überwachen Sie den Build im Bereich Build History.
Klicken Sie auf die laufende Build-Nummer und wählen Sie Console Output, um die Ausführungsdetails Schritt für Schritt anzuzeigen.
Sie können auch die Stage View-Visualisierung (wenn das Plugin installiert ist) verwenden, um den Fortschritt der Stufen Checkout, Build, Test und Deploy grafisch darzustellen.

Best Practices und erweiterte Funktionen

Nutzung von Bibliotheken und gemeinsam genutztem Code

Vermeiden Sie für komplexe oder sich stark wiederholende Schritte die direkte Eingabe von ausführlichem Groovy-Code in die Jenkinsfile. Verwenden Sie stattdessen Shared Libraries. Diese externen Bibliotheken ermöglichen es Ihnen, gemeinsame Funktionen (wie Standardbereitstellungsroutinen oder Benachrichtigungsfunktionen) zu definieren, die von mehreren Pipelines aufgerufen werden können, wodurch Ihre Jenkinsfile übersichtlicher wird.

// Aufrufen eines Shared Library-Schritts
stage('Custom Setup') {
    steps {
        customLibrary.initializeEnvironment(env: 'prod')
    }
}

Arbeiten mit Anmeldedaten

Speichern Sie niemals sensible Informationen (Passwörter, Token, API-Schlüssel) direkt in der Jenkinsfile. Verwenden Sie das integrierte Anmeldedatenverwaltungssystem von Jenkins.

Der Schritt withCredentials ermöglicht den sicheren Zugriff auf gespeicherte Geheimnisse:

stage('Authenticate Registry') {
    steps {
        withCredentials([usernamePassword(credentialsId: 'docker-registry-creds', 
                                          passwordVariable: 'PASS', 
                                          usernameVariable: 'USER')]) {
            sh "docker login -u ${USER} -p ${PASS} ${CONTAINER_REGISTRY}"
        }
    }
}

Warnung: Agentenauswahl

Tipp: Definieren Sie Ihren agent immer spezifisch mit einem label anstelle von agent any. Die Verwendung von agent any bedeutet, dass die Pipeline auf dem Jenkins-Controller-Knoten ausgeführt werden könnte, was ein Sicherheitsrisiko darstellt und die Leistung des Controllers beeinträchtigen kann. Stellen Sie sicher, dass Sie über ordnungsgemäß konfigurierte Jenkins-Agenten (Knoten) mit installierten notwendigen Werkzeugen (Docker, Maven, Node.js) verfügen.

Fazit

Die Jenkins Declarative Pipeline bietet ein leistungsfähiges, lesbares und wartbares Framework zur Implementierung von Continuous Integration und Continuous Delivery. Durch die Definition der Workflow-Struktur – einschließlich Agents, Umgebungsvariablen, sequenziellen Stufen und Post-Build-Aktionen – erhalten Sie vollständige Transparenz und Kontrolle über Ihren Softwareautomatisierungsprozess. Mit dieser grundlegenden Jenkinsfile sind Sie nun bereit, komplexere Schritte zu integrieren, wie z. B. automatisierte Sicherheitsüberprüfungen, Artefaktveröffentlichungen und Promotionen über mehrere Umgebungen hinweg.