Laden Sie die Datei mit Umgebungsvariablen Jenkins Pipeline

Ich mache eine einfache pipeline:

Bauen -> Staging -> Produktion

Brauche ich verschiedene Umgebungsvariablen für die Inszenierung und Produktion, so versuche ich Quelle Variablen.

sh 'source $JENKINS_HOME/.envvars/stacktest-staging.sh'

Aber es gibt Nicht gefunden

[Stack Test] Running shell script
+ source /var/jenkins_home/.envvars/stacktest-staging.sh
/var/jenkins_home/workspace/Stack Test@tmp/durable-bcbe1515/script.sh: 2: /var/jenkins_home/workspace/Stack Test@tmp/durable-bcbe1515/script.sh: source: not found

Den Pfad richtig ist, weil ich den gleichen Befehl ausführen, wenn ich mich einloggen via ssh, und es funktioniert gut.

Hier ist die pipeline-Idee:

node {
    stage name: 'Build'
    //git and gradle build OK
    echo 'My build stage'

    stage name: 'Staging'
    sh 'source $JENKINS_HOME/.envvars/stacktest-staging.sh' //PROBLEM HERE
    echo '$DB_URL' //Expects http://production_url/my_db
    sh 'gradle flywayMigrate' //To staging
    input message: "Does Staging server look good?"    

    stage name: 'Production'
    sh 'source $JENKINS_HOME/.envvars/stacktest-production.sh'
    echo '$DB_URL' //Expects http://production_url/my_db
    sh 'gradle flywayMigrate' //To production
    sh './deploy.sh'
}

Was soll ich tun?

Ich war denken nicht mit dem pipeline (aber ich werde nicht in der Lage sein, um meine Jenkinsfile).
Oder machen verschiedene jobs für die Inszenierung und Produktion, mit EnvInject Plugin (Aber ich verliere meine Bühne view)
Oder machen withEnv (aber der code wird groß, denn heute arbeite ich mit 12 env vars)

InformationsquelleAutor Rafael | 2016-08-26

31

Einen Weg, den Sie laden konnte environment-Variablen aus einer Datei laden Sie eine Groovy Datei.

Beispiel:
1. Lassen Sie uns sagen, Sie haben eine groovy-Datei in " $JENKINS_HOME/.envvars' genannt 'stacktest-Inszenierung.groovy'.
2. In dieser Datei definieren Sie 2 Umwelt-Variablen, die Sie laden möchten
```
env.DB_URL="hello"
env.DB_URL2="hello2"
```
3. Können Sie dann laden Sie diese in mit
```
load "$JENKINS_HOME/.envvars/stacktest-staging.groovy"
```
4. Dann können Sie Sie in den nachfolgenden echo/shell Schritte.
Zum Beispiel, hier ist eine kurze pipeline Skript:
```
node {
   load "$JENKINS_HOME/.envvars/stacktest-staging.groovy"
   echo "${env.DB_URL}"
   echo "${env.DB_URL2}"
}
```
- Danke für die Antwort. Das ist genau das, was ich brauche. Und auch vielen Dank für die ausführliche Erklärung. Es war sehr einfach zu replizieren.
- Bitte beachten Sie, dass die Verwendung der env-variable wird abgeraten, da die env-variable ist global. Die empfohlene Praxis würde zum laden von lokalen Variablen, und dann schließlich setzen Sie als environment-Variablen, falls erforderlich, in einem Teil der Rohrleitung mithilfe der withEnv konstruieren.
- wie kann ich ein Passwort verwenden, mit withEnv und Jenkinsfile? (ohne aussetzen mein Passwort auf Jenkinsfile, weil ich nicht wollen, dass es auf git-repository). Gibt es eine Möglichkeit ohne load "myenvvars.groovy".
- könnten Sie die Anmeldeinformationen binding-Plug-in fügt einen "withCredentials" pipeline-Funktion, die es erlaubt die übergabe von Anmeldeinformationen gespeichert in Jenkins die Anmeldeinformationen speichert. Wenn die Anmeldeinformationen, die statisch sind, könnten Sie auch einen Blick auf die maskpassword plugin. Sie könnten auch erwägen Sie die Verwendung einer Drittanbieter-Dienst zum speichern von Anmeldeinformationen, wie HasciCorp Gewölbe, der hat seinen eigenen plugin und relative pipeline-Funktion.
- danke. Das funktioniert auch. Hier ist ein Anmeldeinformationen-plugin. "Aus einem Pipeline-job definieren Sie Ihre Anmeldeinformationen ein, dann überprüfen Sie die Snippet-Generator für ein Beispiel für die syntax der withCredentials Schritt"
- Sie können auch verwenden, readProperties().
- warum "env." notwendig ist ? weil ich versucht habe ohne und es hat nicht funktioniert
- Ein Wort der Warnung: Wenn Sie 'load "somefile.groovy"', die Datei wird ignoriert, wenn Sie die verwenden Sie Wiedergabe zu starten Sie Ihre pipeline. Replay ersetzt den Inhalt Ihrer groovy-Dateien mit dem code vorgelegt, die für die Wiedergabe, und somit erhalten Sie die environment-Variablen aus der vorherigen Ausführung, nicht die neueste. Könnte dies nicht ein Problem für Sie, aber bewusst sein, dass, wenn die Datei hat keine Möglichkeit der Veränderung zwischen den Ausführungen, dass solche änderungen werden ignoriert.
InformationsquelleAutor Daniel Omoto
17

Aus den Kommentaren zu den akzeptierte Antwort

Nicht verwenden Globale 'env' verwenden aber 'withEnv' konstruieren, z.B. zu sehen:
Ausgabe #9: nicht festgelegt env vars mit globalen env in top 10 der besten Praktiken jenkins pipeline plugin

Im folgenden Beispiel: VAR1 ist eine einfache java-string (kein groovy-variable expansion), VAR2 ist ein groovy-string (also die variable 'someGroovyVar' erweitert).

Dem übergebenen Skript ist eine einfache java-string, also $VAR1 und $VAR2 übergeben werden buchstäblich auf die Schale, und die echo ' s sind auf environment-Variablen VAR1 und VAR2.
```
stage('build') {
    def someGroovyVar = 'Hello world'
    withEnv(['VAR1=VALUE ONE',
             "VAR2=${someGroovyVar}"
            ]) {
        def result = sh(script: 'echo $VAR1; echo $VAR2', returnStdout: true)
        echo result
    }
}
```
Für Geheimnisse /Kennwörter, die Sie verwenden können, Anmeldeinformationen Bindung plugin

Beispiel:

HINWEIS: CREDENTIALS_ID1 ist eine eingetragene Benutzername/Passwort secret auf dem Jenkins-Einstellungen.
```
stage('Push') {
    withCredentials([usernamePassword(
                         credentialsId: 'CREDENTIALS_ID1',
                         passwordVariable: 'PASSWORD',
                         usernameVariable: 'USER')]) {
        echo "User name: $USER"
        echo "Password:  $PASSWORD"
    }
}
```
Den jenkisn Konsole log-Ausgabe verbirgt sich der real-Werte:
```
[Pipeline] echo
User name: ****
[Pipeline] echo
Password:  ****
```
Jenkins und Anmeldeinformationen ist ein großes Problem, wahrscheinlich sehen: Anmeldeinformationen plugin

Vollständigkeit halber: die Meisten der Zeit, müssen wir die Geheimnisse, die in der environment-Variablen, wie wir Sie verwenden von shell-Skripten, also kombinieren wir die withCredentials und withEnv wie folgt:
```
stage('Push') {
    withCredentials([usernamePassword(
                         credentialsId: 'CREDENTIALS_ID1',
                         passwordVariable: 'PASSWORD',
                         usernameVariable: 'USER')]) {
        withEnv(["ENV_USERNAME=${USER}",
                 "ENV_PASSWORD=${PASSWORD}"
            ]) {
                def result = sh(script: 'echo $ENV_USERNAME', returnStdout: true)
                echo result

        }
    }
}
```
- Für das, was seinen Wert - ich war in der Lage, verweisen Sie die Anmeldeinformationen wie shell, env vars ohne hinzufügen in die withEnv Schritt.
- Sicher, es ist möglich. Aber withEnv lokal ist nur der Schritt, während env var global ist. (das ist der Punkt, der Frage #9: nicht festgelegt env vars mit globalen env).
InformationsquelleAutor huch
2

Einen anderen Weg zur Lösung dieses installieren "Pipeline-Dienstprogramm Schritte" - plugin, das bietet uns readProperties-Methode ( zum Verweis bitte auf den link gehen,https://jenkins.io/doc/pipeline/steps/pipeline-utility-steps/#pipeline-utility-steps)
Hier im Beispiel sehen wir, dass Sie speichern die Schlüssel in einem array und verwenden Sie die Tasten, um den Wert abzurufen.
Aber in diesem Fall die in der Produktion das problem wird sein, wie wenn wir alle Variablen, die später in die property-Datei, die variable Hinzugefügt werden muss in die Reihe der Jenkins-Datei als auch.
Um loszuwerden, diese enge Kopplung, können wir code schreiben, der in einer solchen Art und Weise, so dass den Jenkins-build-Umgebung bekommen können automatisch Informationen über alle vorhandenen Tasten präsentiert, die derzeit in der Property-Datei. Hier ist ein Beispiel für die Referenz
```
def loadEnvironmentVariables(path){
    def props = readProperties  file: path
    keys= props.keySet()
    for(key in keys) {
        value = props["${key}"]
        env."${key}" = "${value}"
    }
} 
```
- Und der client-code sieht wie
```
path = '\\ABS_Output\\EnvVars\\pic_env_vars.properties'
loadEnvironmentVariables(path)
```
InformationsquelleAutor Sumanta Mondal
1

Wenn Sie mit Jenkins 2.0 Sie können das laden der property-Datei (die darin besteht, alle erforderlichen Umgebungsvariablen zusammen mit Ihren entsprechenden Werten) und Lesen Sie alle environment-Variablen aufgelistet, die es automatisch und injizieren es in die Jenkins zur Verfügung gestellt env Einheit.

Hier ist eine Methode, die führt, die die oben genannten Aktion.
```
def loadProperties(path) {
    properties = new Properties()
    File propertiesFile = new File(path)
    properties.load(propertiesFile.newDataInputStream())
    Set<Object> keys = properties.keySet();
    for(Object k:keys){
    String key = (String)k;
    String value =(String) properties.getProperty(key)
    env."${key}" = "${value}"
    }
}
```
Um diese Methode aufrufen, müssen wir übergeben den Pfad der property-Datei als string-variable Zum Beispiel, in unserem Jenkins-Datei mit groovy-Skript, das wir nennen können, wie
```
path = "${workspace}/pic_env_vars.properties"
loadProperties(path)
```
Bitte Fragen Sie mich, wenn Sie irgendwelche Zweifel haben,

InformationsquelleAutor Sumanta Mondal

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.