Jenkins-Umgebungsvariablen:Ultimativer Leitfaden

Einführung

Jenkins ist eine Open-Source-Lösung zur Automatisierung verschiedener Teile des Softwareentwicklungslebenszyklus (SDLC). Umgebungsvariablen stellen hierfür ein wertvolles Werkzeug dar, das es Entwicklern ermöglicht, einen Wert mehrmals aufzurufen, ohne ihn vor jeder Verwendung definieren zu müssen.

In diesem Tutorial werden wir verschiedene Möglichkeiten zum Auflisten und Festlegen von Jenkins-Umgebungsvariablen behandeln.

Voraussetzungen

• Eine installierte und einsatzbereite Kopie von Jenkins (erfahren Sie, wie Sie Jenkins unter Ubuntu 18.04, Debian 10, CentOS 8 oder Windows 10 installieren).
• Zugriff auf einen Webbrowser.

Was sind Umgebungsvariablen in Jenkins?

Umgebungsvariablen sind globale Schlüssel-Wert-Paare, auf die Jenkins zugreifen und in ein Projekt einfügen kann. Verwenden Sie Jenkins-Umgebungsvariablen, um zu vermeiden, dass Sie für jedes Projekt dieselben Werte codieren müssen.

Zu den weiteren Vorteilen der Verwendung von Jenkins-Umgebungsvariablen gehört eine verbesserte Sicherheit. Jenkins kann Sicherheitsanmeldeinformationen als Variablen verwenden, um vertrauliche oder benutzergenerierte Daten aus dem Projektcode herauszuhalten.

Häufig verwendete Variablentypen in Jenkins sind env (Umgebungsvariablen), currentBuild , params (Parameter) und docker (Zugriff auf Docker-Funktionen). Jenkins speichert alle aktuellen Umgebungsvariablen in Listenform.

So sehen Sie Umgebungsvariablen in Jenkins

Es gibt zwei Möglichkeiten, alle Jenkins-Umgebungsvariablen aufzulisten:

• Zugriff auf die Liste über einen Webbrowser.
• Verwenden von Jenkins-Shell-Befehlen zum Ausdrucken.

Über env-vars.html

Um eine Liste der Jenkins-Umgebungsvariablen in einem Webbrowser anzuzeigen, navigieren Sie zu der folgenden Adresse:

[Jenkins URL]/env-vars.html

Die Jenkins-URL ist eine Kombination aus dem Hostnamen Ihres Systems und dem von Jenkins verwendeten Port. Wenn Sie sich beispielsweise über den Standardport 8080 bei Ihrem System anmelden:

http://localhost:8080/env-vars.html

Über den Shell-Befehl set/printenv

Eine andere Methode besteht darin, einen Jenkins-Job zu erstellen, der einen Shell-Befehl ausführt, um Umgebungsvariablen anzuzeigen. Die Konsolenausgabe dieses Jobs ist eine modifizierte Version der Umgebungsvariablenliste.

1. Klicken Sie auf der linken Seite des Jenkins-Dashboards auf Neues Element .

2. Geben Sie den Namen Umgebungsvariable ein s in das entsprechende Feld und wählen Sie Pipeline aus als Elementtyp.

3. Klicken Sie auf OK zu bestätigen.

4. Scrollen Sie nach unten zur Pipeline Abschnitt und fügen Sie den folgenden Code hinzu:

pipeline{
    agent any
    
    stages{
        stage("Env Variables"){
            steps{
                bat "set"                                                     
            }
        }
    }
}

4. Klicken Sie auf Speichern um Änderungen an der Pipeline zu bestätigen.

5. Klicken Sie auf Jetzt erstellen Link auf der linken Seite, um einen neuen Pipeline-Build zu erstellen.

6. Unter Build-Verlauf , klicken Sie auf die Build-Nummer, um auf die Build-Optionen zuzugreifen.

7. Klicken Sie auf Konsolenausgabe auf der linken Seite.

Die Konsolenausgabe Seite zeigt die Ausgabe des Shell-Befehls an. In diesem Fall ist es eine Liste von Jenkins-Umgebungsvariablen:

So lesen Sie Umgebungsvariablen in der Jenkins-Pipeline

Es gibt zwei Möglichkeiten, Jenkins-Umgebungsvariablen zu lesen und darauf zuzugreifen:

• Verwendung der env Objekt mit dem Variablennamen.
• Verwendung des kurzen Variablennamens.

Als Beispiel verwenden wir die BUILD_NUMBER -Variable, die die aktuelle Pipeline-Build-Nummer enthält. Dieser Code demonstriert beide Methoden zum Lesen der Variablen:

pipeline {
    agent any

    stages {
        stage("Env Variables") {
            steps {
                echo "The current build number is ${env.BUILD_NUMBER}"
                echo "Another method is to use \${BUILD_NUMBER}, which is ${BUILD_NUMBER}"
            }
        }
    }
}

Im obigen Beispiel liest Jenkins die Variable mit:

• ${env.BUILD_NUMBER} :Verwenden der env Objekt.
• ${BUILD_NUMBER} :Verwendung des kurzen Variablennamens.

Die Ausgabe zeigt als Ergebnis die aktuelle Build-Nummer an:

So legen Sie Umgebungsvariablen in einer Jenkins-Pipeline fest

Benutzer können Jenkins-Umgebungsvariablen auf globaler oder lokaler Ebene festlegen. Fügen Sie globale Umgebungsvariablen über das Jenkins-Dashboard hinzu, während lokale Variablen mithilfe von deklarativen, imperativen und Skript-Pipelines hinzugefügt werden.

Globale Umgebungsvariablen von Jenkins

In Jenkins kann jede Pipeline oder jeder Job auf globale Umgebungsvariablen zugreifen und diese lesen. So fügen Sie mit dem Jenkins-Dashboard eine neue globale Umgebungsvariable hinzu:

1. Klicken Sie auf der linken Seite des Jenkins-Dashboards auf Manage Jenkins .

2. Unter der Systemkonfiguration Klicken Sie im Abschnitt auf System konfigurieren .

3. Scrollen Sie nach unten, bis Sie die Globalen Eigenschaften erreichen Sektion. Aktivieren Sie das Kontrollkästchen neben Umgebungsvariablen und klicken Sie auf Hinzufügen Schaltfläche, um eine neue Variable hinzuzufügen.

4. Geben Sie den Namen und Wert der neuen Variablen in die entsprechenden Felder ein.

5. Klicken Sie auf Speichern Schaltfläche, um die neuen Variablen zu speichern.

Lokale Jenkins-Umgebungsvariablen

Sie können eine lokale Umgebungsvariable in Jenkins mithilfe der deklarativen Pipeline festlegen. Diese Methode verwendet die environment {} Blocksyntax:

environment {
    [variable name] = "[variable value]"
}

Das Platzieren dieses Blocks am Anfang der Pipeline bedeutet, dass die Variable in jedem Schritt der Pipeline zur Verwendung verfügbar ist. Wenn Sie es in einer bestimmten Phase platzieren, ist es nur während der Schritte dieser Phase und nur in dieser Phase verfügbar.

Eine andere Methode ist die Verwendung eines env Objekt in einem Skript, um zwingend eine Umgebungsvariable zu definieren:

script {
    env. [variable name] = "[variable value]"
}

Verwenden Sie schließlich einen withEnv([]) {} block setzt eine lokale Umgebungsvariable als Teil einer Skript-Pipeline:

withEnv(["[variable name]= [variable value]"])

Als Beispiel verwendet dieser Code alle drei oben beschriebenen Methoden in einer einzigen Pipeline, um lokale Umgebungsvariablen festzulegen:

pipeline {
    agent any

    environment {
        DATE = "December 17th"
    }

    stages {
        stage("Env Variables") {
            environment {
                NAME = "Alex"
            }

            steps {
                echo "Today is ${env.DATE}"
                echo "My name ${env.NAME}"

                script {
                    env.WEBSITE = "phoenixNAP KB"
                }

                echo "This is an example for ${env.WEBSITE}"

                withEnv(["TEST_VARIABLE=TEST_VALUE"]) {
                    echo "The value of TEST_VARIABLE is ${env.TEST_VARIABLE}"
                }
            }
        }
    }
}

In diesem Beispiel legen wir das DATE fest und NAME Umgebungsvariablen deklarativ. DATE steht ganz oben in der Pipeline und kann in jeder Phase verwendet werden, während NAME befindet sich in den "Env Variables" Phase, also können wir es nur innerhalb dieser Phase verwenden. Die WEBSITE Variable zwingend gesetzt ist, und TEST_VARIABLE ist Teil einer Skript-Pipeline.

Die Konsolenausgabe für diese Pipeline zeigt, dass Jenkins erfolgreich auf jede Variable zugreifen und diese lesen kann:

Injizieren von Umgebungsvariablen

Hinzufügen des EnvInject-Plug-ins to Jenkins ermöglicht es Ihnen, Umgebungsvariablen während des Build-Starts einzufügen. Dies ist besonders nützlich, wenn Sie ein Freestyle-Projekt in Jenkins erstellen.

Befolgen Sie die unten beschriebenen Schritte, um das EnvInject-Plugin zu Jenkins hinzuzufügen und Variablen einzufügen:

1. Klicken Sie auf Jenkins verwalten auf der linken Seite des Dashboards.

2. In der Systemkonfiguration Klicken Sie im Abschnitt auf Plugins verwalten Schaltfläche.

3. Unter Verfügbar Suchen Sie im Tab nach envinject . Aktivieren Sie das Kontrollkästchen neben Environment Injector Plugin und klicken Sie auf Ohne Neustart installieren .

4. Kehren Sie nach Abschluss der Installation des Plugins zum Dashboard zurück. Klicken Sie auf Neues Element Link, um ein neues Projekt zu erstellen, fügen Sie einen Namen hinzu und wählen Sie das Freestyle-Projekt aus Typ.

5. Klicken Sie auf OK um ein neues Projekt zu erstellen.

6. Scrollen Sie nach unten zum Build Abschnitt und klicken Sie auf Build-Schritte hinzufügen , um ein Dropdown-Menü mit verfügbaren Optionen zu öffnen. Wählen Sie Umgebungsvariablen einfügen aus .

7. Wenn Sie Umgebungsvariablen aus einer Eigenschaftsdatei hinzufügen möchten, fügen Sie den Pfad zur Datei im Eigenschaftsdateipfad hinzu Feld. Eine andere Möglichkeit besteht darin, die neuen Variablen direkt zum Properties Content hinzuzufügen unter Verwendung von [variable name] = [variable value] Syntax.

8. Klicken Sie auf Speichern Schaltfläche, um das Hinzufügen der neuen Umgebungsvariable zu bestätigen.

So überschreiben Sie die Umgebungsvariable in Jenkins

Die Jenkins-Pipeline ermöglicht es Benutzern, Umgebungsvariablen zu überschreiben und den aktuellen Wert der Variablen durch einen neuen zu ändern.

Der Überschreibungsprozess folgt mehreren Regeln bei der Bestimmung der Variablenpriorität:

• Der withEnv([]) { } block überschreibt jede Umgebungsvariable.
• Variablen, die mit env festgelegt werden Objekt kann diese mit der environment {} festgelegten Werte nicht überschreiben blockieren.
• Variablen, die mit env festgelegt werden -Objekt kann nur andere Variablen überschreiben, die mit env festgelegt wurden Objekt.