Builds parametrisieren und Skripte verwenden

Einführung

In modernen CI/CD-Pipelines sind Flexibilität und Automatisierung entscheidend. Das Festkodieren von Werten in Build-Jobs macht diese starr und schwer zu verwalten. Jenkins ermöglicht es Ihnen, dies zu umgehen, indem Sie Ihre Builds parametrisieren und Skripte als Teil des Build-Prozesses ausführen.

In diesem Lab lernen Sie, wie Sie einen flexiblen Jenkins-Job erstellen. Sie beginnen damit, Parameter hinzuzufügen, um Benutzereingaben zur Build-Zeit zu ermöglichen. Anschließend lernen Sie, Shell-Skripte als Build-Schritt auszuführen, die Parameter an diese Skripte zu übergeben und Post-Build-Aktionen zu konfigurieren, die bedingt auf den Erfolg oder Misserfolg des Builds reagieren. Dies sind grundlegende Fähigkeiten für die Erstellung robuster und dynamischer Automatisierungs-Workflows in Jenkins.

Eine Jenkins-Instanz läuft bereits in Ihrer Umgebung. Sie können auf die Jenkins-Weboberfläche zugreifen, indem Sie den Firefox-Browser auf dem Desktop öffnen. Der Browser öffnet sich automatisch unter http://localhost:8080, sodass Sie die URL nicht manuell eingeben müssen. Eine Anmeldung ist nicht erforderlich.

Freestyle-Projekt erstellen und parametrisieren

In diesem Schritt erstellen Sie ein neues Jenkins Freestyle-Projekt und fügen ihm Parameter hinzu. Parameter machen Ihre Jobs interaktiv und ermöglichen es Ihnen, bei jeder Auslösung eines Builds Eingaben zu machen.

Zuerst erstellen wir den Job.

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 parameterized-script-job als Item-Namen ein.
4. Wählen Sie Freestyle project und klicken Sie auf OK.

Sie werden zur Konfigurationsseite des Jobs weitergeleitet. Fügen wir nun Parameter hinzu.

1. Setzen Sie im Abschnitt General das Häkchen bei This project is parameterized (Dieses Projekt ist parametrisiert).

   

2. Klicken Sie auf das Dropdown-Menü Add Parameter (Parameter hinzufügen) und wählen Sie String Parameter.

   • Name: GREETING_NAME
   • Default Value (Standardwert): World
   • Description (Beschreibung): Enter a name to be greeted.

3. Klicken Sie erneut auf das Dropdown-Menü Add Parameter und wählen Sie Choice Parameter.

   • Name: ENVIRONMENT

   • Choices (Auswahlmöglichkeiten): (Geben Sie jede Auswahl in eine neue Zeile ein)

     DEV
     STAGING
     PROD

   • Description (Beschreibung): Select the deployment environment.

Diese Parameter stehen in späteren Build-Schritten zur Verfügung.

Scrollen Sie schließlich nach unten und klicken Sie auf Save (Speichern). Sie werden zur Hauptseite des Jobs weitergeleitet, wo Sie nun eine Option Build with Parameters (Mit Parametern bauen) anstelle von "Build Now" sehen werden.

Shell-Skript-Build-Schritt hinzufügen

In diesem Schritt fügen Sie Ihrem Job-Build-Prozess ein Shell-Skript hinzu. Dies ist eine gängige Methode, um Aufgaben wie das Kompilieren von Code, das Ausführen von Tests oder das Bereitstellen von Anwendungen durchzuführen.

1. Navigieren Sie im Jenkins-Dashboard zu dem Job parameterized-script-job.
2. Klicken Sie im linken Menü auf Configure (Konfigurieren).
3. Scrollen Sie nach unten zum Abschnitt Build Steps (Build-Schritte).
4. Klicken Sie auf das Dropdown-Menü Add build step (Build-Schritt hinzufügen) und wählen Sie Execute shell (Shell ausführen).
5. Geben Sie in das Textfeld Command (Befehl) das folgende Skript ein. Dieses Skript erstellt eine Projektverzeichnisstruktur innerhalb des Jenkins-Workspace und listet dessen Inhalt auf.

echo "--- Starting Build Step ---"
echo "Current directory:"
pwd
echo "Creating project directory structure:"
mkdir -p my-app
echo "Version 1.0" > my-app/version.txt
echo "Listing files in the project directory:"
ls -la my-app
echo "--- Build Step Finished ---"

6. Klicken Sie auf Save (Speichern), um die Änderungen zu übernehmen.

Lassen Sie uns nun den Job ausführen, um das Skript in Aktion zu sehen.

1. Klicken Sie auf der Job-Seite auf Build with Parameters (Mit Parametern bauen).
2. Belassen Sie die Standardparameterwerte und klicken Sie auf die Schaltfläche Build (Bauen).
3. Ein neuer Build erscheint in der Build History (Build-Verlauf) auf der linken Seite. Klicken Sie auf die Build-Nummer (z. B. #1).
4. Klicken Sie auf Console Output (Konsolenausgabe), um die Protokolle anzuzeigen.

Sie sollten die Ausgabe Ihres Shell-Skripts sehen, einschließlich der Dateiliste.

Started by user admin
Running as SYSTEM
Building in workspace /var/jenkins_home/workspace/parameterized-script-job
[parameterized-script-job] $ /bin/sh -xe /tmp/jenkins15539247300321029374.sh
+ echo --- Starting Build Step ---
--- Starting Build Step ---
+ echo Current directory:
Current directory:
+ pwd
/var/jenkins_home/workspace/parameterized-script-job
+ echo Creating project directory structure:
Creating project directory structure:
+ mkdir -p my-app
+ echo Version 1.0
+ echo Listing files in the project directory:
Listing files in the project directory:
+ ls -la my-app
total 12
drwxr-xr-x 2 jenkins jenkins 4096 Aug 22 01:56 .
drwxr-xr-x 3 jenkins jenkins 4096 Aug 22 01:56 ..
-rw-r--r-- 1 jenkins jenkins   12 Aug 22 01:56 version.txt
+ echo --- Build Step Finished ---
--- Build Step Finished ---
Finished: SUCCESS

Parameter an das Shell-Skript übergeben

In diesem Schritt lernen Sie, wie Sie die in Schritt 1 definierten Parameter in Ihrem Shell-Skript verwenden. Jenkins stellt Build-Parameter als Umgebungsvariablen bereit, auf die Sie in Ihrem Skript mit der Syntax $VARIABLE_NAME zugreifen können.

1. Gehen Sie zurück zur Configure-Seite Ihres parameterized-script-job.
2. Scrollen Sie zum Abschnitt Build Steps und suchen Sie das Befehlsfeld Execute shell.
3. Ersetzen Sie das vorhandene Skript durch das folgende:

echo "--- Starting Parameterized Build Step ---"
echo "Hello, $GREETING_NAME!"
echo "Deploying to the $ENVIRONMENT environment."

## Create project structure if not exists and read the version from the file
mkdir -p my-app
echo "Version 1.0" > my-app/version.txt
APP_VERSION=$(cat my-app/version.txt)
echo "Application version is: $APP_VERSION"
echo "--- Parameterized Build Step Finished ---"

Beachten Sie, wie $GREETING_NAME und $ENVIRONMENT direkt in den echo-Befehlen verwendet werden. Wenn der Job ausgeführt wird, ersetzt Jenkins diese durch die vom Benutzer ausgewählten Werte.

4. Klicken Sie auf Save.

Lassen Sie uns nun den Build mit benutzerdefinierten Parametern ausführen.

1. Klicken Sie auf Build with Parameters.
2. Ändern Sie GREETING_NAME zu LabEx.
3. Wählen Sie STAGING aus dem Dropdown-Menü ENVIRONMENT.
4. Klicken Sie auf Build.
5. Überprüfen Sie die Console Output für den neuen Build.

Die Ausgabe sollte nun die von Ihnen bereitgestellten benutzerdefinierten Werte widerspiegeln.

--- Starting Parameterized Build Step ---
+ echo Hello, LabEx!
Hello, LabEx!
+ echo Deploying to the STAGING environment.
Deploying to the STAGING environment.
+ mkdir -p my-app
+ echo Version 1.0
+ cat my-app/version.txt
+ APP_VERSION=Version 1.0
+ echo Application version is: Version 1.0
Application version is: Version 1.0
+ echo --- Parameterized Build Step Finished ---
--- Parameterized Build Step Finished ---

Build-Fehler mit bedingten Schritten behandeln

In diesem Schritt simulieren Sie einen Build-Fehler und verwenden eine Post-Build-Aktion, um ein Bereinigungs- oder Benachrichtigungsskript nur dann auszuführen, wenn der Build fehlschlägt. Dies ist entscheidend für die Erstellung robuster Pipelines.

Installieren des Post-build Task Plugins

Bevor wir die Post-build Task Aktion nutzen können, müssen wir das erforderliche Plugin installieren.

1. Klicken Sie in Jenkins auf das Zahnradsymbol in der oberen rechten Ecke, um auf das Jenkins-Verwaltungspanel zuzugreifen, und klicken Sie dann auf Plugins.
2. Klicken Sie auf die Registerkarte Available plugins.
3. Klicken Sie auf Check now, um die Plugin-Liste zu aktualisieren.
4. Suchen Sie im Suchfeld nach Post build task.
5. Setzen Sie das Häkchen neben dem Plugin und klicken Sie auf Install without restart.
6. Warten Sie, bis die Installation abgeschlossen ist.

Modifizieren des Skripts zur Simulation eines Fehlers

Nun passen wir das Skript an, damit es unter einer bestimmten Bedingung fehlschlägt.

1. Gehen Sie zur Configure Seite Ihres parameterized-script-job.
2. Ersetzen Sie im Befehlsfeld Execute shell das Skript durch Folgendes:

echo "Deploying to the $ENVIRONMENT environment."

if [ "$ENVIRONMENT" = "PROD" ]; then
  echo "Error: Production deployment is not allowed!"
  exit 1
fi

echo "Deployment to $ENVIRONMENT was successful."

Dieses Skript prüft den Parameter ENVIRONMENT. Wenn dieser auf PROD gesetzt ist, gibt es eine Fehlermeldung aus und beendet sich mit dem Statuscode 1. In Shell-Skripten signalisiert jeder ungleich Null liegende Exit-Code einen Fehler.

Fügen wir nun eine Post-Build-Aktion hinzu, die bei einem Fehler ausgelöst wird.

Hinzufügen einer Post-Build-Aktion

1. Scrollen Sie nach unten zum Abschnitt Post-build Actions.
2. Klicken Sie auf Add post-build action und wählen Sie Post-build task.
3. Geben Sie im Feld Log text Error: ein. Dies weist das Plugin an, nach diesem spezifischen Text in den Build-Protokollen zu suchen.
4. Geben Sie im Feld Script den folgenden Befehl ein:

echo "FAILURE DETECTED! Sending notification..."

5. Klicken Sie auf Save.

Testen der Fehlerbedingung

Testen wir nun die Fehlerbedingung.

1. Klicken Sie auf Build with Parameters.
2. Wählen Sie für ENVIRONMENT die Option PROD und klicken Sie auf Build.
3. Der Build wird fehlschlagen, was durch ein rotes Icon in der Build History angezeigt wird.
4. Überprüfen Sie die Console Output. Sie sehen die Fehlermeldung aus Ihrem Hauptskript und die Meldung aus Ihrer Post-Build-Aktion.

Deploying to the PROD environment.
+ [ PROD = PROD ]
+ echo Error: Production deployment is not allowed!
Error: Production deployment is not allowed!
+ exit 1
Build step 'Execute shell' marked build as failure
Performing Post build task...
Match found for :Error: : True
Logical operation result is TRUE
Running script  : echo "FAILURE DETECTED! Sending notification..."
[parameterized-script-job] $ /bin/sh -xe /tmp/jenkins14011006354379294736.sh
+ echo FAILURE DETECTED! Sending notification...
FAILURE DETECTED! Sending notification...
POST BUILD TASK : SUCCESS
END OF POST BUILD TASK : 0
Finished: FAILURE

Wenn Sie den Build erneut mit DEV oder STAGING ausführen, wird er erfolgreich sein, und die Post-Build-Aktion wird nicht ausgeführt.

Zusammenfassung

Herzlichen Glückwunsch. Sie haben erfolgreich einen flexiblen und robusten Jenkins-Job erstellt.

In diesem Lab haben Sie gelernt, wie Sie:

• Einen parametrisierten Jenkins-Job mit String- und Choice-Parametern erstellen.
• Shell-Skripte als Teil eines Build-Prozesses ausführen.
• Build-Parameter als Umgebungsvariablen innerhalb Ihrer Skripte abrufen und verwenden.
• Bedingte Logik in einem Skript implementieren, um das Build-Ergebnis zu steuern.
• Post-Build-Aktionen konfigurieren, die basierend auf dem Inhalt der Build-Protokolle ausgelöst werden, sodass Sie Build-Fehler elegant behandeln können.

Diese Fähigkeiten sind unerlässlich für den Aufbau hochentwickelter CI/CD-Pipelines, die sich an unterschiedliche Eingaben anpassen und Fehler intelligent behandeln können. Sie können diese Konzepte nun anwenden, um Ihre eigenen Entwicklungs- und Deployment-Workflows zu automatisieren.