Erstellen und Ausführen einer grundlegenden Jenkins Pipeline

Einführung

Willkommen zu diesem Lab über die Grundlagen von Jenkins Pipelines. Jenkins Pipeline ist eine leistungsstarke Funktion, mit der Sie Ihren gesamten Build-, Test- und Bereitstellungsprozess als Code definieren können. Diese Definition wird in einer Textdatei namens Jenkinsfile gespeichert, die üblicherweise zusammen mit dem Quellcode Ihrer Anwendung versioniert wird. Diese Praxis ist als "Pipeline-as-Code" bekannt.

In diesem Lab konzentrieren wir uns auf die Declarative Pipeline-Syntax, die eine strukturierte und benutzerfreundliche Methode zum Erstellen von Pipelines bietet. Am Ende dieses Labs werden Sie in der Lage sein:

Ein neues Pipeline-Projekt in der Jenkins-Weboberfläche zu erstellen.
Eine grundlegende Jenkinsfile unter Verwendung der Declarative-Syntax zu schreiben.
Ein Projekt so zu konfigurieren, dass es eine Jenkinsfile aus einem lokalen Git-Repository verwendet.
Eine Pipeline auszuführen und deren Ausgabe zu überprüfen.
Eine Pipeline in mehrere Stages (Phasen) zu unterteilen.
Umgebungsvariablen zur Konfigurationsverwaltung zu nutzen.

Eine Jenkins-Instanz läuft bereits in einem Container für Sie. Fangen wir an.

Erstellen eines Pipeline-Projekts in Jenkins

Ihr erster Schritt besteht darin, ein neues Pipeline-Projekt in Jenkins zu erstellen. Dieser Projekttyp ist speziell darauf ausgelegt, Pipelines auszuführen, die in einer Jenkinsfile definiert sind.

Öffnen Sie den Firefox-Browser über die Desktop-Oberfläche. Der Browser öffnet sich automatisch unter http://localhost:8080, Sie müssen die URL also nicht manuell eingeben. Es ist kein Login erforderlich.
Klicken Sie im Jenkins-Dashboard im linken Menü auf New Item.
Geben Sie im Feld Enter an item name den Namen my-first-pipeline ein.
Wählen Sie Pipeline aus der Liste der Projekttypen aus.
Klicken Sie unten auf der Seite auf die Schaltfläche OK.

Pipeline-Projekt erstellen

Sie werden zur Konfigurationsseite des Projekts weitergeleitet. Belassen Sie die Einstellungen vorerst so, wie sie sind. Scrollen Sie nach unten und klicken Sie auf Save.

Sie haben nun ein leeres Pipeline-Projekt erstellt. Im nächsten Schritt erstellen Sie eine Jenkinsfile und konfigurieren dieses Projekt so, dass es diese verwendet.

SCM konfigurieren, um ein lokales Git-Repository zu verwenden

Jetzt konfigurieren Sie Ihr Jenkins-Projekt so, dass es seine Pipeline-Definition aus einem lokalen Git-Repository abruft, das innerhalb des Jenkins-Containers bereitgestellt wird. Dies hält das Lab unabhängig von externer Netzwerkverfügbarkeit, während Sie dennoch den echten Workflow Pipeline script from SCM nutzen.

Das Demo-Repository befindet sich unter: git://localhost/pipeline-demo.git

Lassen Sie uns die Jenkinsfile untersuchen, die Jenkins aus diesem Repository laden wird:

pipeline {
    agent any
    environment {
        DEPLOY_TARGET = 'staging'
    }
    stages {
        stage('Build') {
            steps {
                echo 'Building the application...'
                sh 'echo "Compiling source code..."'
            }
        }
        stage('Test') {
            steps {
                echo 'Testing the application...'
                sh 'echo "Running unit tests..."'
            }
        }
        stage('Deploy') {
            steps {
                echo "Deploying the application to ${env.DEPLOY_TARGET}..."
                sh 'echo "Application deployed successfully!"'
            }
        }
    }
}

Dieses Declarative Pipeline-Skript enthält mehrere Stages und demonstriert wichtige Konzepte:

pipeline { ... }: Der Hauptblock, der die gesamte Pipeline definiert.
agent any: Weist Jenkins an, diese Pipeline auf einem beliebigen verfügbaren Agenten auszuführen.
environment { ... }: Definiert Umgebungsvariablen, die in der gesamten Pipeline verwendet werden können.
stages { ... }: Ein Container für alle Stages in der Pipeline.
stage('...') { ... }: Definiert spezifische Phasen. Stages helfen dabei, den Workflow zu visualisieren.
steps { ... }: Enthält die tatsächlichen Befehle, die in einer Stage ausgeführt werden sollen.
echo '...': Ein Schritt, der eine Nachricht in das Build-Protokoll schreibt.
sh '...': Ein Schritt, der Shell-Befehle ausführt.

Konfigurieren Sie nun Ihr Jenkins-Projekt für die Verwendung dieses Repositorys:

Kehren Sie zur Jenkins-Benutzeroberfläche in Ihrem Browser zurück und navigieren Sie zur Projektseite my-first-pipeline.
Klicken Sie im linken Menü auf Configure.
Scrollen Sie nach unten zum Abschnitt Pipeline.
Ändern Sie das Dropdown-Menü Definition von "Pipeline script" auf Pipeline script from SCM.
Wählen Sie im erscheinenden SCM-Dropdown-Menü Git aus.
Geben Sie im Feld Repository URL Folgendes ein: git://localhost/pipeline-demo.git
Geben Sie im Feld Script Path Folgendes ein: Jenkinsfile
Klicken Sie auf Save.

Pipeline SCM-Konfiguration

Ihr Projekt ist nun so eingerichtet, dass es die im lokalen Git-Repository definierte Pipeline ausführt.

Pipeline ausführen und Ausgabe prüfen

Nachdem Ihr Projekt konfiguriert ist, ist es an der Zeit, die Pipeline auszuführen und in Aktion zu sehen.

Klicken Sie auf der Projektseite für my-first-pipeline im linken Menü auf Build Now.
Ein neuer Build wird geplant und erscheint im Bereich Build History auf der linken Seite. Unterhalb der Historie zeigt die Stage View an, wie die "Build"-Stage ausgeführt wird und nach Abschluss grün leuchtet.
Um die detaillierte Ausgabe zu sehen, klicken Sie auf die Build-Nummer (z. B. #1) in der Build-Historie.
Klicken Sie auf der Zusammenfassungsseite des Builds im linken Menü auf Console Output.
Scrollen Sie durch das Protokoll. Sie finden die Nachrichten aus Ihren Pipeline-Schritten, die bestätigen, dass Ihre Pipeline erfolgreich ausgeführt wurde.

...
[Pipeline] { (Build)
[Pipeline] echo
Building the application...
[Pipeline] sh
+ echo Compiling source code...
Compiling source code...
[Pipeline] } // stage
[Pipeline] { (Test)
[Pipeline] echo
Testing the application...
[Pipeline] sh
+ echo Running unit tests...
Running unit tests...
[Pipeline] } // stage
[Pipeline] { (Deploy)
[Pipeline] echo
Deploying the application to staging...
[Pipeline] sh
+ echo Application deployed successfully!
Application deployed successfully!
[Pipeline] } // stage
...
Finished: SUCCESS

Sie haben erfolgreich Ihre erste Pipeline ausgeführt und deren Ausgabe überprüft. Beachten Sie, wie die Pipeline automatisch alle drei Stages (Build, Test, Deploy) ausgeführt hat, die in der Jenkinsfile des Repositorys definiert waren.

Mehrere Stages in der Pipeline verstehen

Reale Pipelines bestehen aus mehreren Phasen, wie z. B. dem Erstellen, Testen und Bereitstellen einer Anwendung. Die Jenkinsfile aus dem lokalen Repository enthält bereits diese unterschiedlichen Phasen und demonstriert dieses wichtige Konzept.

Lassen Sie uns untersuchen, wie die Pipeline mit mehreren Stages strukturiert ist:

stages {
    stage('Build') {
        steps {
            echo 'Building the application...'
            sh 'echo "Compiling source code..."'
        }
    }
    stage('Test') {
        steps {
            echo 'Testing the application...'
            sh 'echo "Running unit tests..."'
        }
    }
    stage('Deploy') {
        steps {
            echo "Deploying the application to ${env.DEPLOY_TARGET}..."
            sh 'echo "Application deployed successfully!"'
        }
    }
}

Gehen Sie zurück zur Jenkins-Benutzeroberfläche für das Projekt my-first-pipeline und klicken Sie auf Build Now, um die Pipeline erneut auszuführen, falls Sie dies noch nicht getan haben.
Beobachten Sie die Stage View im Projekt-Dashboard. Sie sehen drei Spalten, die Ihre "Build"-, "Test"- und "Deploy"-Stages repräsentieren. Jenkins visualisiert den Fortschritt, während der Build jede Phase durchläuft.
Klicken Sie auf eine beliebige Stage in der Stage View, um die detaillierten Protokolle für diese spezifische Phase anzuzeigen.
Beachten Sie, wie jede Stage nacheinander ausgeführt wird – Jenkins wartet darauf, dass eine Stage erfolgreich abgeschlossen wird, bevor er zur nächsten übergeht.

Durch die Strukturierung Ihrer Pipeline mit Stages erstellen Sie einen klaren und wartbaren Workflow, der einfach zu überwachen ist. Jede Stage repräsentiert eine logische Phase in Ihrem CI/CD-Prozess, wodurch Probleme leicht identifiziert und der Fortschritt Ihrer Builds visualisiert werden kann.

Umgebungsvariablen in einer Pipeline verstehen

In diesem letzten Schritt lernen Sie Umgebungsvariablen kennen. Die environment-Direktive ermöglicht es Ihnen, Variablen zu definieren, die in Ihrer gesamten Pipeline verwendet werden können. Dies ist ideal, um Konfigurationseinstellungen zu verwalten, ohne sie hart in Ihre Schritte zu codieren.

Die Jenkinsfile aus dem lokalen Repository demonstriert dieses Konzept bereits mit einer Umgebungsvariablen, die ein Bereitstellungsziel angibt.

Lassen Sie uns untersuchen, wie Umgebungsvariablen definiert und verwendet werden:

pipeline {
    agent any
    environment {
        DEPLOY_TARGET = 'staging'
    }
    stages {
        // ... andere Stages ...
        stage('Deploy') {
            steps {
                echo "Deploying the application to ${env.DEPLOY_TARGET}..."
                sh 'echo "Application deployed successfully!"'
            }
        }
    }
}

Wichtige Punkte zu Umgebungsvariablen in Jenkins Pipelines:

Der environment { ... }-Block definiert Variablen, die in der gesamten Pipeline verfügbar sind.
Auf Variablen wird mit der Syntax ${env.VARIABLE_NAME} zugegriffen.
Es ist entscheidend, doppelte Anführungszeichen (") für Zeichenfolgen mit Variableninterpolation zu verwenden, da die Variableninterpolation von Groovy nur innerhalb von doppelt in Anführungszeichen gesetzten Strings funktioniert.
Umgebungsvariablen machen Ihre Pipelines flexibler und einfacher zu warten.

Falls noch nicht geschehen, lösen Sie einen neuen Build in Jenkins aus, indem Sie auf Build Now klicken.
Überprüfen Sie nach Abschluss des Builds den Console Output für den Build. Im Protokoll für die "Deploy"-Stage sehen Sie, dass die Variable korrekt ersetzt wurde:

...
[Pipeline] { (Deploy)
[Pipeline] echo
Deploying the application to staging...
[Pipeline] sh
+ echo Application deployed successfully!
Application deployed successfully!
[Pipeline] } // stage
...
Finished: SUCCESS

Beachten Sie, wie der Wert staging der Umgebungsvariablen DEPLOY_TARGET automatisch in die echo-Anweisung eingesetzt wurde.

Umgebungsvariablen sind unerlässlich für die Erstellung flexibler Pipelines, die einfach für verschiedene Umgebungen (Entwicklung, Staging, Produktion) konfiguriert werden können, ohne den Pipeline-Code selbst ändern zu müssen.

Zusammenfassung

Herzlichen Glückwunsch! Sie haben diese Einführung in Jenkins Pipelines erfolgreich abgeschlossen. Sie haben die Kernkonzepte der Definition eines CI/CD-Workflows als Code kennengelernt.

In diesem Lab haben Sie geübt:

Ein Pipeline-Projekt in der Jenkins-Benutzeroberfläche zu erstellen.
Ein Projekt so zu konfigurieren, dass es eine Jenkinsfile aus einem lokalen Git-Repository verwendet, das für Jenkins bereitgestellt wird.
Die Struktur einer Declarative Pipeline mit mehreren Stages zu verstehen.
Eine Pipeline auszuführen und deren Konsolenausgabe zu untersuchen.
Zu beobachten, wie Pipelines zur Übersichtlichkeit und Organisation in logische Stages unterteilt werden.
Zu verstehen, wie Umgebungsvariablen definiert und verwendet werden, um Pipelines dynamischer zu gestalten.

Diese grundlegenden Fähigkeiten sind essenziell für den Aufbau anspruchsvoller Automatisierungspipelines. Sie sind nun bereit, fortgeschrittenere Themen zu erkunden, wie z. B. die Verwendung von Parametern, die Verwaltung von Anmeldeinformationen und die Integration mit verschiedenen Build- und Bereitstellungstools.