I have been ordered to migrate a dotnet build from Bamboo to Jenkins. I used a Freestyle job to run a powershell script, using the PowerShell plugin and successfully built it. However I need to add version number to the built artifact. The Bamboo job uses:
~\.dotnet\tools\dotnet-lambda.exe package -pl $fullDir -f "netcoreapp3.1" -o Payment.${bamboo.majorVersion}.${bamboo.minorVersion}.${bamboo.revisionVersion}.${bamboo.buildNumber}.zip
I went into Jenkins Configuration and in Global Properties, created Environment variables named - buildNumber, majorVersion, minorVersion and revisionVersion, giving it values and in the Build part of the Freestyle job, I used:
~\.dotnet\tools\dotnet-lambda.exe package -pl $fullDir -f "netcoreapp3.1" -o Payment.${env.majorVersion}.${env.minorVersion}.${env.revisionVersion}.${env.buildNumber}.zip
However the name of the built artifact is: Payment.....zip
How can I pass the variable values?
Is there a way to auto increment the revisionNumber and buildNumber, instead of hard coding it?
I'm very new to both Bamboo and Jenkins. Any help would be extremely helpful.
Regards
Ramesh
Personally, I'd not configure this things globally as they seem job specific. Nevertheless,
Install the Environment Injector plugin. You now have two options:
General tab
[ X ] Prepare an environment for the run
Build Environment tab
[ X ] Inject environment variables to the build process
Set the "Properties Content" (that's an environment variable).
In your shell step( no need to preface with ${env....} ):
Execute Shell step:
#!sh -
echo ${FOO}.${BUILD_NUMBER}
echo ${LABEL}
Output:
[EnvInject] - Loading node environment variables.
[EnvInject] - Preparing an environment for the build.
[EnvInject] - Keeping Jenkins system variables.
[EnvInject] - Keeping Jenkins build variables.
[EnvInject] - Injecting contributions.
Building in workspace C:\Users\jenkins\.jenkins\workspace\Foo
[EnvInject] - Executing scripts and injecting environment variables after the SCM step.
[EnvInject] - Injecting as environment variables the properties content
FOO=bar
[EnvInject] - Variables injected successfully.
[Foo] $ sh - C:\Users\jenkins\AppData\Local\Temp\jenkins281351632631450693.sh
bar.8
Finished: SUCCESS
You'll also see at the bottom of the Execute Shell step a link to ${JENKINS_URL}/env-vars.html which lists variables available to shell scripts, which includes BUILD_NUMBER; use that in lieu of buildNumber.
The plugin also supports configuration same at both the Global and the Node level.
You can also have individual build steps to inject / change variables between job steps (we use this to set specific JAVA_HOME for SonarQube step).
You will also see an [Environment variables] button on the LH side of each build log to inspect what you ran with (see below).
If you add Build With Parameters plugin then you can be prompted to supply values for variables when triggering the job which can be consumed in the same fashion without re-configuring the job (it won't remember them, but you will see a [Parameters] button on the LH side of each build log to inspect what you ran with.
The Version Number plugin can provides greater flexibility, say you want to AutoIncrement and the "BUILD_NUMBER" option is too limiting, it offers a variable BUILDS_ALL_TIME, which can use the above defined variables or hard-coded constants to aggregate a version label and optionally control which it is incremented (eg: only increment on successful builds). eg:
[ X ] Prepare an environment for the run
Properties Content
FOO=bar
[ X ] Create a formatted version number
Environment Variable Name [ BUILD-${FOO}.${BUILDS_ALL_TIME} ]
Skip Builds worse than [ SUCCESS ]
Execute Shell step:
#!sh -
echo ${FOO}.${BUILD_NUMBER}
echo ${LABEL}
Output:
[Foo] $ sh - C:\Users\jenkins\AppData\Local\Temp\jenkins4160554383847615506.sh
bar.10
BUILD-bar.2
I'm using a Python script task of type 'file' in my Azure DevOps Yaml pipeline. I need to use the variables that I defined in my Variable Group in the Python file.
The following is my task on Azure devops yaml pipeline.
- task: PythonScript#0
displayName: 'Run a Python script'
inputs:
scriptPath: 'pythonTest.py'
Any advise on how I can achieve this?
Thanks!
You need to pass the variables to the script, using arguments, and you of course need to reference the variable group:
variables:
- group: variableGroup
steps:
- task: PythonScript#0
displayName: 'Run a Python script'
inputs:
scriptPath: 'pythonTest.py'
arguments: --variableInScript $(variableInVariableGroup)
And then use 'argparse' in the script.
https://learn.microsoft.com/en-us/azure/devops/pipelines/ecosystems/python?view=azure-devops#run-python-scripts
If you were using an inline script you could have done it like this:
- task: PythonScript#0
inputs:
scriptSource: 'inline'
script: |
print('variableInVariableGroup: $(variableInVariableGroup)')
According to the Azure DevOps official documentation:
System and user-defined variables also get injected as environment
variables for your platform. When variables are turned into
environment variables, variable names become uppercase, and periods
turn into underscores. For example, the variable name any.variable
becomes the variable name $ANY_VARIABLE.
So you just have to access the corresponding environment variable from your script. In Python, this can be done using the os.environ dictionary:
import os
my_var = os.environ["MY_VAR"]
Within .gitlab-ci.yml I've created a new variable under script: by using $CI_COMMIT_SHA and modifying it. When I echo the variable it returns the proper value. However, I'm not having any success passing it along to Docker. What am I not doing right?
Ultimately, I would like access this custom variable inside my container.
build:
script:
# converts commit SHA to UNIX time
- export COMMIT_TIME_UNIX=$(git show -s --format=%ct $CI_COMMIT_SHA)
- echo $COMMIT_TIME_UNIX
You would need to check, when the same script is executed in a Docker/container environment, if it is still in the right Git repository path.
You can add, before the first export:
pwd
git status
env|grep GIT
That way, you will check if you are doing Git commands where you should, and if there is any GIT_xxx environnement variable which might influence said command.
I trigger a shell script from Jenkins, This scripts get date and export it as a environment(Linux) variable $DATE. I need to use this $DATE inside same Jenkins job. I made job as parameter build. Created a string parameter as DATE value as DATE=$DATE. But it is not working.
Please suggest !!
You mention that you are exporting a DATE environment variable in an shell script, which is presumably being started via an "Execute shell" step.
The problem is, once the shell step has completed, that environment is gone — the variables will not be carried over to subsequent build steps.
So when you later try to use the $DATE value — whether in another build step, or as a parameter to another job — that particular environment variable will no longer exist.
What you can do instead is use the EnvInject plugin to export environment variables during a build. Variables set up using this plugin will be available to all subsequent build steps.
For example, you could write the DATE to a properties field in one build step:
echo DATE=$(date +%Y-%m-%d) > env.properties
Then you can add an "Inject environment variables for your job" build step, and enter env.properties in the "Environment Properties File Path" field.
That way, the DATE variable (and anything else in that properties file) will be exported and will be visible to the rest of the build steps.
You could use an assignment statement and sh's returnStdout to get the value in Jenkins without having to write to a properties file.
foo = sh(
returnStdout: true,
script: 'date'
)
Then later on in the Jenkinsfile you can use $foo like any other variable.
EDIT: This is for a pipeline job, not a freestyle job.
I had the same issue.
The solution that worked for me was:
env.ABC=bat(returnStdout: true,
script: ''' #echo off echo abc ''').trim()
The .trim() and #echo off is important if you want to reuse the variable in another batch script.
I would like to be able to do something like:
AOEU=$(echo aoeu)
and have Jenkins set AOEU=aoeu.
The Environment Variables section in Jenkins doesn't do that. Instead, it sets AOEU='$(echo aoeu)'.
How can I get Jenkins to evaluate a shell command and assign the output to an environment variable?
Eventually, I want to be able to assign the executor of a job to an environment variable that can be passed into or used by other scripts.
This can be done via EnvInject plugin in the following way:
Create an "Execute shell" build step that runs:
echo AOEU=$(echo aoeu) > propsfile
Create an Inject environment variables build step and set "Properties File Path" to propsfile.
Note: This plugin is (mostly) not compatible with the Pipeline plugin.
The simplest way
You can use EnvInject plugin to injects environment variables at build startup. For example:
How you know it's working
In my case, I needed to add the JMETER_HOME environment variable to be available via my Ant build scripts across all projects on my Jenkins server (Linux), in a way that would not interfere with my local build environment (Windows and Mac) in the build.xml script. Setting the environment variable via Manage Jenkins - Configure System - Global properties was the easiest and least intrusive way to accomplish this. No plug-ins are necessary.
The environment variable is then available in Ant via:
<property environment="env" />
<property name="jmeter.home" value="${env.JMETER_HOME}" />
This can be verified to works by adding:
<echo message="JMeter Home: ${jmeter.home}"/>
Which produces:
JMeter Home: ~/.jmeter
In my case, I had configure environment variables using the following option and it worked-
Manage Jenkins -> Configure System -> Global Properties -> Environment Variables -> Add
You can try something like this
stages {
stage('Build') {
environment {
AOEU= sh (returnStdout: true, script: 'echo aoeu').trim()
}
steps {
sh 'env'
sh 'echo $AOEU'
}
}
}
You can use Environment Injector Plugin to set environment variables in Jenkins at job and node levels. These are the steps to set them at job level:
From the Jenkins web interface, go to Manage Jenkins > Manage Plugins and install the plugin.
Go to your job Configure screen
Find Add build step in Build section and select Inject environment variables
Set the desired environment variable as VARIABLE_NAME=VALUE pattern. In my case, I changed value of USERPROFILE variable
If you need to define a new environment variable depending on some conditions (e.g. job parameters), then you can refer to this answer.
EnvInject Plugin aka (Environment Injector Plugin) gives you several options to set environment variables from Jenkins configuration.
By selecting Inject environment variables to the build process you will get:
Properties File Path
Properties Content
Script File Path
Script Content
and finally Evaluated Groovy script.
Evaluated Groovy script gives you possibility to set environment variable based on result of executed command:
with execute method:
return [HOSTNAME_SHELL: 'hostname'.execute().text,
DATE_SHELL: 'date'.execute().text,
ECHO_SHELL: 'echo hello world!'.execute().text
]
or with explicit Groovy code:
return [HOSTNAME_GROOVY: java.net.InetAddress.getLocalHost().getHostName(),
DATE_GROOVY: new Date()
]
(More details about each method could be found in build-in help (?))
Unfortunately you can't do the same from Script Content as it states:
Execute a script file aimed at setting an environment such as creating
folders, copying files, and so on. Give the script file content. You
can use the above properties variables. However, adding or overriding
environment variables in the script doesn't have any impacts in the
build job.
There is Build Env Propagator Plugin which lets you add new build environment variables, e.g.
Any successive Propagate build environment variables step will override previously defined environment variable values.
Normally you can configure Environment variables in Global properties in Configure System.
However for dynamic variables with shell substitution, you may want to create a script file in Jenkins HOME dir and execute it during the build. The SSH access is required. For example.
Log-in as Jenkins: sudo su - jenkins or sudo su - jenkins -s /bin/bash
Create a shell script, e.g.:
echo 'export VM_NAME="$JOB_NAME"' > ~/load_env.sh
echo "export AOEU=$(echo aoeu)" >> ~/load_env.sh
chmod 750 ~/load_env.sh
In Jenkins Build (Execute shell), invoke the script and its variables before anything else, e.g.
source ~/load_env.sh
This is the snippet to store environment variable and access it.
node {
withEnv(["ENABLE_TESTS=true", "DISABLE_SQL=false"]) {
stage('Select Jenkinsfile') {
echo "Enable test?: ${env.DEVOPS_SKIP_TESTS}
customStep script: this
}
}
}
Note: The value of environment variable is coming as a String. If you want to use it as a boolean then you have to parse it using Boolean.parse(env.DISABLE_SQL).
extending the answer of #JSixface:
To define environment variables globally for access from within all the stages of a declarative pipeline, you can add the environment section within the pipeline block.
pipeline {
agent {
node {
label 'myAgent'
}
}
environment {
AOEU = "${sh(returnStdout: true, script: 'echo aoeu').trim()}"
}
stages {
...
}
}
Try Environment Script Plugin (GitHub) which is very similar to EnvInject. It allows you to run a script before the build (after SCM checkout) that generates environment variables for it. E.g.
and in your script, you can print e.g. FOO=bar to the standard output to set that variable.
Example to append to an existing PATH-style variable:
echo PATH+unique_identifier=/usr/local/bin
So you're free to do whatever you need in the script - either cat a file, or run a script in some other language from your project's source tree, etc.
For some reason sudo su - jenkins does not log me to jenkins user, I ended up using different approach.
I was successful setting the global env variables using using jenkins config.xml at /var/lib/jenkins/config.xml (installed in Linux/ RHEL) - without using external plugins.
I simply had to stop jenkins add then add globalNodeProperties, and then restart.
Example, I'm defining variables APPLICATION_ENVIRONMENT and SPRING_PROFILES_ACTIVE to continious_integration below,
<?xml version='1.0' encoding='UTF-8'?>
<hudson>
<globalNodeProperties>
<hudson.slaves.EnvironmentVariablesNodeProperty>
<envVars serialization="custom">
<unserializable-parents/>
<tree-map>
<default>
<comparator class="hudson.util.CaseInsensitiveComparator"/>
</default>
<int>2</int>
<string>APPLICATION_ENVIRONMENT</string>
<string>continious_integration</string>
<string>SPRING_PROFILES_ACTIVE</string>
<string>continious_integration</string>
</tree-map>
</envVars>
</hudson.slaves.EnvironmentVariablesNodeProperty>
</globalNodeProperties>
</hudson>
You can use either of the following ways listed below:
Use Env Inject Plugin for creating environment variables. Follow this for usage and more details https://github.com/jenkinsci/envinject-plugin
Navigate below and can add
Manage Jenkins -> Configure System -> Global Properties -> Environment Variables -> Add
Scripted Pipeline syntax that we use is this:
env.AEOU = sh label:'set env var',
returnStdout: true,
script : '''#!/bin/bash
echo "aeou"
'''
sh label:'checkit',
script : '''#!/bin/bash
echo "${AEOU}"
'''
Note the use of triple-single-quote notation for the script parameter to the sh step. This ensures that the ${AEOU} does not get interpolated by Groovy and does get interpolated by the bash shell.
We use groovy job file:
description('')
steps {
environmentVariables {
envs(PUPPETEER_SKIP_CHROMIUM_DOWNLOAD: true)
}
}