Einführung in Jenkins Pipelines

Einführung

Willkommen zu diesem Lab über die Grundlagen von Jenkins Pipelines. Jenkins Pipeline ist ein leistungsstarkes Feature, das es Ihnen ermöglicht, Ihren gesamten Build-, Test- und Deployment-Prozess als Code zu definieren. Diese Definition wird in einer Textdatei namens Jenkinsfile gespeichert, die typischerweise zusammen mit dem Quellcode Ihrer Anwendung versioniert wird. Diese Praxis ist als "Pipeline-as-Code" bekannt.

In diesem Lab konzentrieren Sie sich auf die Declarative Pipeline-Syntax, die eine strukturierte und benutzerfreundliche Methode zur Erstellung 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 mit Declarative-Syntax zu schreiben.
• Ein Projekt so zu konfigurieren, dass es eine Jenkinsfile aus einem lokalen Git-Repository verwendet.
• Eine Pipeline auszuführen und ihre Ausgabe zu inspizieren.
• Eine Pipeline in mehrere Stages zu organisieren.
• Umgebungsvariablen zur Verwaltung der Konfiguration zu verwenden.

Eine Jenkins-Instanz läuft bereits in einem Container für Sie. Lassen Sie uns beginnen.

Ein Pipeline-Projekt in Jenkins erstellen

Ihr erster Schritt ist die Erstellung eines neuen Pipeline-Projekts in Jenkins. Dieser Projekttyp wurde speziell für die Ausführung von Pipelines entwickelt, die in einer Jenkinsfile definiert sind.

1. Öffnen Sie den Firefox-Browser über die Desktop-Oberfläche. Der Browser öffnet sich automatisch unter http://localhost:8080, sodass Sie die URL nicht manuell eingeben müssen. Eine Anmeldung ist nicht erforderlich.
2. Klicken Sie im Jenkins-Dashboard im linken Menü auf New Item (Neues Element).
3. Geben Sie im Feld Enter an item name (Einen Elementnamen eingeben) my-first-pipeline ein.
4. Wählen Sie Pipeline aus der Liste der Projekttypen aus.
5. Klicken Sie unten auf der Seite auf die Schaltfläche OK.

8. Sie werden zur Konfigurationsseite des Projekts weitergeleitet. Vorerst belassen wir die Einstellungen unverändert. Scrollen Sie nach unten und klicken Sie auf Save (Speichern).

Sie haben nun ein leeres Pipeline-Projekt erstellt. Im nächsten Schritt erstellen Sie eine Jenkinsfile und konfigurieren dieses Projekt für deren Verwendung.

SCM für die Verwendung eines Remote-Repositorys konfigurieren

Nun konfigurieren Sie Ihr Jenkins-Projekt so, dass es seine Pipeline-Definition aus einem Remote-Git-Repository abruft. Wir verwenden ein Demo-Repository, das eine vorkonfigurierte Jenkinsfile und eine Beispielanwendung enthält.

Das Demo-Repository befindet sich unter: https://github.com/labex-labs/jenkins-demo

Betrachten wir die Jenkinsfile, die wir aus dem Remote-Repository verwenden werden:

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 Wrapper für alle Stages in der Pipeline.
• stage('...') { ... }: Definiert spezifische Stages. Stages helfen bei der Visualisierung des Workflows.
• steps { ... }: Enthält die eigentlichen Befehle, die in einer Stage ausgeführt werden sollen.
• echo '...': Ein Schritt, der eine Nachricht in das Build-Protokoll ausgibt.
• sh '...': Ein Schritt, der Shell-Befehle ausführt.

Konfigurieren Sie nun Ihr Jenkins-Projekt, um dieses Remote-Repository zu verwenden:

1. Kehren Sie zur Jenkins-Benutzeroberfläche in Ihrem Browser zurück und navigieren Sie zur Projektseite my-first-pipeline.
2. Klicken Sie im linken Menü auf Configure.
3. Scrollen Sie zum Abschnitt Pipeline.
4. Ändern Sie das Dropdown-Menü Definition von "Pipeline script" zu Pipeline script from SCM.
5. Wählen Sie im erscheinenden Dropdown-Menü SCM die Option Git aus.
6. Geben Sie im Feld Repository URL Folgendes ein: https://github.com/labex-labs/jenkins-demo
7. Geben Sie im Feld Script Path Folgendes ein: introduction-to-pipelines/Jenkinsfile
8. Klicken Sie auf Save.

Ihr Projekt ist nun so eingerichtet, dass es die im Remote-GitHub-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 sie in Aktion zu sehen.

1. Klicken Sie auf der Projektseite für my-first-pipeline im linken Menü auf Build Now.

2. Ein neuer Build wird geplant und erscheint im Bereich Build History auf der linken Seite. Unter der Historie zeigt die Stage View an, dass die "Build"-Stage ausgeführt wird und nach Abschluss grün wird.

   

3. Um die detaillierte Ausgabe anzuzeigen, klicken Sie in der Build History auf die Build-Nummer (z. B. #1).

4. Klicken Sie auf der Zusammenfassungsseite des Builds im linken Menü auf Console Output.

   

5. 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 Remote-Repositorys definiert waren.

Mehrere Stages in der Pipeline verstehen

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

Betrachten wir, 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!"'
        }
    }
}

1. 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.

2. Beobachten Sie die Stage View auf dem Projekt-Dashboard. Sie sehen drei Spalten, die Ihre Stages "Build", "Test" und "Deploy" darstellen. Jenkins visualisiert den Fortschritt, während der Build durch jede einzelne Stage läuft.

   

3. Klicken Sie auf eine beliebige Stage in der Stage View, um die detaillierten Protokolle für diese spezifische Stage anzuzeigen.

4. Beachten Sie, wie jede Stage sequenziell ausgeführt wird – Jenkins wartet, bis eine Stage erfolgreich abgeschlossen ist, bevor es zur nächsten Stage übergeht.

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

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 für die Verwaltung von Konfigurationseinstellungen, ohne sie fest in Ihre Schritte zu kodieren.

Die Jenkinsfile aus dem Remote-Repository demonstriert dieses Konzept bereits mit einer Umgebungsvariable, die ein Deployment-Ziel angibt.

Betrachten wir, wie Umgebungsvariablen definiert und verwendet werden:

pipeline {
    agent any
    environment {
        DEPLOY_TARGET = 'staging'
    }
    stages {
        // ... other 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.
• Variablen werden mit der Syntax ${env.VARIABLE_NAME} aufgerufen.
• Es ist entscheidend, doppelte Anführungszeichen (") für Strings mit Variableninterpolation zu verwenden, da die Variableninterpolation von Groovy nur innerhalb von doppelt zitierten Strings funktioniert.
• Umgebungsvariablen machen Ihre Pipelines flexibler und einfacher zu warten.

1. Wenn Sie dies noch nicht getan haben, lösen Sie einen neuen Build in Jenkins aus, indem Sie auf Build Now klicken.

2. Überprüfen Sie nach Abschluss des Builds die 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

3. Beachten Sie, wie der Wert der Umgebungsvariable DEPLOY_TARGET (staging) automatisch in die echo-Anweisung eingefügt 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 zu ändern.

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 gelernt.

In diesem Lab haben Sie geübt, wie Sie:

• Ein Pipeline-Projekt in der Jenkins-Benutzeroberfläche erstellen.
• Ein Projekt so konfigurieren, dass es eine Jenkinsfile aus einem Remote-Git-Repository (SCM) verwendet.
• Die Struktur einer Deklarativen Pipeline mit mehreren Stages verstehen.
• Eine Pipeline ausführen und ihre Konsolenausgabe inspizieren.
• Beobachten, wie Pipelines zur besseren Übersichtlichkeit und Organisation in logische Stages unterteilt werden.
• Verstehen, wie Umgebungsvariablen definiert und verwendet werden, um Pipelines dynamischer zu gestalten.

Diese grundlegenden Fähigkeiten sind unerlässlich für den Aufbau komplexer 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 Deployment-Tools.