How To Set Jenkins Pipeline Environment Variables?

What are Jenkins Pipeline Environment Variables?

While writing the script for a Jenkins pipeline, some dynamic values are to be injected and used. These are especially useful to avoid hardcoding every value into the pipeline. For this dynamic integration, Jenkins set environment variables.

  1. Addition of job parameters available only at runtime, but not at design time.
  2. Boolean values set in environment variables help certain toggle stages in a pipeline via a parameter that describes a specific subset of tests you want to run.
  3. Providing IDs of credentials defined in Jenkins.
  1. currentBuild: As the name suggests, it addresses the currently running build of the Jenkins pipeline.
  2. params: All the parameters provided for a successful build from a read-only map with various typed variables. These can be accessed via params.
  3. docker: This is to provide convenient access to Docker — related functions in a Groovy script of Jenkins pipeline.

Viewing Jenkins Environment Variables List

Jenkins exposes the crucial characteristics of components using environment variables. Thus, a set of these variables are already defined by Jenkins. This includes information about the job and the specific build that is running. Some of the most commonly used variables are :

1. Via env-vars.html :

The environment variables can be viewed on an HTML page. You have to open the page on your Jenkins controller server. The steps to view the jenkins environment variables list are :

  1. The ${YOUR_JENKINS_HOST} itself is an environment variable defining the Jenkins host address/Jenkins URL(that would be http://localhost:8080/).
  2. And env-vars.html is the HTML file consisting of the list of all Jenkins environment variables.
  3. The page looks like this :

2. Via Windows batch script/shell command :

You can also list all the environment variables by writing the shell command in the groovy script of the Jenkins pipeline. The steps to do the same are :

  1. In the Pipeline Script, type the following groovy script.
pipeline{
agent any

stages{
stage("Env Variables"){
steps{
bat ‘set’
}
}
}
}

Reading Jenkins Environment Variables

In this section, we will see how you can read your Jenkins environment variables list. Let’s take it one step at a time-

  1. You can also use the short version, which is BUILD_NUMBER. But this variant is quite confusing for some users. The script to read the build number via environment variables is :
pipeline{
agent any

stages{
stage("Env Build Number"){
steps{
echo "The build number is ${env.BUILD_NUMBER}"
echo "You can also use \${BUILD_NUMBER} -> ${BUILD_NUMBER}"
}
}
}
}

Setting Jenkins Environment Variables

Jenkins environment variables are set both globally as well as locally. Global environment variables can be set via the UI of Jenkins, and local environment variables are set according to the pipeline, being declarative or scripted. The Jenkins pipeline environment variables can also be read from a properties file. For this, we use the Pipeline Utility Steps plugin. You can also inject the variables during the build startup via the EnvInject plugin.

1. Creating Global Environment Variables

Global environment variables are the variables that can be used in any and every Pipeline or Job built on Jenkins. The global variables are set via the Jenkins console and via the groovy script of a pipeline. The ways to set these global environment variables are:

  1. The required code is :
import hudson.EnvVars;
import hudson.slaves.EnvironmentVariablesNodeProperty;
import hudson.slaves.NodeProperty;
import hudson.slaves.NodePropertyDescriptor;
import hudson.util.DescribableList;
import jenkins.model.Jenkins;
public createGlobalEnvironmentVariables(String key, String value){
Jenkins instance = Jenkins.getInstance();DescribableList<NodeProperty<?>, NodePropertyDescriptor> globalNodeProperties = instance.getGlobalNodeProperties();
List<EnvironmentVariablesNodeProperty> envVarsNodePropertyList = globalNodeProperties.getAll(EnvironmentVariablesNodeProperty.class);
EnvironmentVariablesNodeProperty newEnvVarsNodeProperty = null;
EnvVars envVars = null;
if ( envVarsNodePropertyList == null || envVarsNodePropertyList.size() == 0 ) {
newEnvVarsNodeProperty = new hudson.slaves.EnvironmentVariablesNodeProperty();
globalNodeProperties.add(newEnvVarsNodeProperty);
envVars = newEnvVarsNodeProperty.getEnvVars();
} else {
envVars = envVarsNodePropertyList.get(0).getEnvVars();
}
envVars.put(key, value)
instance.save()
}
createGlobalEnvironmentVariables('Var1','Dummy')
  1. There might be a file in your code repository where some configuration properties for your app are saved, Or the file would be available on fileshare somewhere.
  2. There is a plugin in Jenkins that can be used to read these properties from a file. This is the Pipeline Utility Steps plugin.
Username = root
Access_Token = ***************
stage(“reading properties from properties file”) {
steps {
// Use a script block to do custom scripting
script {
def props = readProperties file: 'extravars.properties'
env.Username = props.Username
}
echo "The username is $Username"
}
}

2. Creating Local Environment Variables

The local environment variables are the variables explicitly defined for a particular job in Jenkins. These are defined according to the pipeline and its type. There are declarative pipelines as well as scripted pipelines. The Jenkins declarative Pipelines break down the stages into individual stages that can contain multiple steps; Scripted pipelines, on the other hand, use groovy code and references within the stages without any extra efforts. Because of this difference, the code for creating local environment variables is different for the two types of pipelines.

environment {
DISABLE_AUTH = 'true'
}
pipeline {
agent any
environment {
DISABLE_AUTH = 'true' //can be used in whole pipeline
}
stages {
stage(“Build”) {
steps {
echo env.DISABLE_AUTH
}
}
}
}
pipeline {
agent any
environment {
DISABLE_AUTH = 'true'
}
stages {
stage(“Build”) {
environment {
ENABLE_AUTH = ‘false’ //can be used in this stage only
}
steps {
echo env.DISABLE_AUTH
echo env.ENABLE_AUTH
}
}
}
}
  1. In the scripted pipelines, use withEnv to define local Jenkins environment variables. The withEnv([“env=value]) {} block can also be used to override any environment variable.
  2. The simple code to declare local environment variables is :
node{
stage('Build') {
withEnv(["DISABLE_AUTH=true"]) {
echo env.DISABLE_AUTH }
}
}

3. Injecting Environment Variables in Freestyle Projects

Injecting Jenkins environment variables can be done with the help of a plugin. This plugin is the EnvInject plugin. You can install the EnvInject plugin and inject the environment variables during the build startup. This makes it possible to set up a custom environment for all Jenkins jobs. This plugin is used massively in the freestyle projects of Jenkins. The steps that demonstrate the usage of the EnvInject plugin are:

Capturing bat Command Output in the Environment Variable

You can capture the output of a shell command or batch command as a Jenkins environment variable and use it in later stages of the pipeline. For that you need to use the exact given syntax — bat(script: ‘cmd’, returnStdout:true). This is to force the bat command to return the output to be captured and stored in an environment variable. The steps to store the output into a Jenkins environment variable are:

  1. We have used a script block to save the output in LS, and then we have accessed the same variable and displayed the saved content.
  2. The groovy script that works for the same is :
pipeline {
agent any
stages {
stage("capturing output in Environment Variables") {
steps {
script {
env.LS = bat(script:'dir', returnStdout: true).trim()
// if you access environment variable in the batch command
echo $LS
}
}
}
}

Jenkins Set Environment Variables Using LambdaTest Plugin

As the installation of a plugin is facilitated, new environment variables are added to the jenkins environment variables list. Here, we will install the LambdaTest Jenkins plugin and view the environment variables added by this plugin.

pipeline{
agent any
environment{
LT_USERNAME='racha10r@gmail.com'
LT_ACCESS_KEY='iHnnmi0atXDjDKIqckdBH0gU72Uf8zJb76EyNlXjzvGPzvr54'
LT_TUNNEL=true
}
stages{
stage('printing the environment variables'){
steps{
echo env.LT_USERNAME
echo env.LT_ACCESS_KEY
echo env.LT_TUNNEL
}
}
}
}

Using Jenkins Pipeline Environment Variables with LambdaTest Jenkins Plugin

Before we jump off to learn about the practical usage of Jenkins environment variables, let us understand the pre-requisites for the plugin.

  1. A Jenkins pipeline: A new pipeline will be created on Jenkins to run the Nightwatch tests on the LambdaTest Selenium Grid. To achieve this, this project is integrated into LambdaTest.
  2. Credentials of LambdaTest Account: The credentials to your LambdaTest profile will be needed. You can easily find the Username and Access Key on the profile section of your LambdaTest Account. (After logging in, click on the rightmost avatar, a dropdown menu will appear and then click on the profile section. You will find the username and Access token there.)

Steps to achieve Integration through Environment Variables

  1. Start the Jenkins Server by traversing to the location of Jenkins folder in CMD(Command Line Prompt) and typing the command “java -jar jenkins.war”. (You can also change the port on which Jenkins is running by adding — httpPort = <port number> attribute to the previous command.)
  • Setup Stage: In the setup stage, you will clone the git repository and download the binary file(LT_Windows.zip) required to create an ssh connection through a Tunnel. You will then unzip the zip file and Activate the tunnel by command “LT — user ${LT_USERNAME} — key ${LT_ACCESS_KEY}”.
  • Build Stage: After the activation of Tunnel, you will install the required dependencies by commands, npm install and npm install nightwatch.
  • Test Stage: In the test stage, we will run the tests with the help of Nightwatch. Here the command used is a batch command : bat ‘node_modules/.bin/nightwatch -e chrome tests’. Through this command we are also providing the environment in which the Tests should be run(the environments can be chrome, ie, edge, firefox etc.. LambdaTest eases the process of testing in various environments by providing us to choose the environment as per the need.)
#!/usr/bin/env groovy

node {
// Sets the environment variables from LambdaTest for testing
withEnv(["LT_USERNAME=rachna10r@gmail.com",
"LT_ACCESS_KEY=z71l7Q9ohS9HhKiCqd690mH0sDu5AYrz8VSB0whO3mZ2JEkNAN",
"LT_TUNNEL=true"]){

// Just printing the above set environment variables
echo env.LT_USERNAME
echo env.LT_ACCESS_KEY

stage('setup') {

// Get some code from a GitHub repository
try{
git 'https://github.com/LambdaTest/nightwatch-selenium-sample.git'

//Download Tunnel Binary
bat 'wget "https://downloads.lambdatest.com/tunnel/v3/windows/64bit/LT_Windows.zip"'

//Required if unzip is not installed
bat 'unzip -o LT_Windows.zip'

//Starting Tunnel Process
'LT --user ${LT_USERNAME} --key ${LT_ACCESS_KEY}'
}
catch (err){
echo err
}
}
stage('build') {
// Installing Dependencies
bat 'npm install'
bat 'npm install nightwatch'
}

stage('test') {
try{
// Running the nightwatch tests with environment set as Chrome
bat 'node_modules/.bin/nightwatch -e chrome tests'
}
catch (err){
echo err
}
}
stage('end') {
// Printing the success message
echo "Success"
}
}
}

Checking the Test Cases on the LambdaTest Automation Dashboard

  1. Log in to your LambdaTest account by visiting URL: https://accounts.lambdatest.com/login

Wrapping Up!

Jenkins has a lot of potential in it. With the integration of various plugins and configuration of different platforms like LambdaTest integration with Jenkins; It provides different environments to create a build and facilitates various applications of continuous integration and continuous deployment.

--

--

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store