Environment variables access in Jenkins - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

Accessing environment variables in a Jenkins pipeline

What will be the output of the following Jenkins pipeline script snippet?

Jenkins

pipeline {
  agent any
  environment {
    MY_VAR = 'hello'
  }
  stages {
    stage('Print') {
      steps {
        script {
          echo "Value is: ${env.MY_VAR}"
        }
      }
    }
  }
}

A Value is: hello

B Value is: ${MY_VAR}

C Value is:

D Error: MY_VAR not defined

💡 Hint

Remember how environment variables are accessed in Jenkins pipeline scripts using env.

In Jenkins scripted or declarative pipelines, environment variables defined in the environment block are accessed using env.VARIABLE_NAME. Here, env.MY_VAR returns 'hello'.

🧠 Conceptual

intermediate

Understanding environment variable scope in Jenkins

Which statement correctly describes the scope of environment variables defined inside a Jenkins pipeline's environment block?

A They are available only after the pipeline finishes.

B They are available throughout the entire pipeline run.

C They are available only to the shell commands but not to Groovy scripts.

D They are available only within the stage where they are defined.

💡 Hint

Think about when environment variables are set and how Jenkins shares them.

Environment variables defined in the environment block are set for the entire pipeline run and are accessible in all stages and steps.

❓ Troubleshoot

advanced

Troubleshooting missing environment variable in Jenkins shell step

A Jenkins pipeline defines an environment variable MY_SECRET in the environment block. However, when running a shell step, the variable is empty. What is the most likely cause?

A Jenkins does not support environment variables in shell steps.

B The environment variable was not defined in the environment block.

C The shell step uses single quotes around the variable reference, preventing expansion.

D The variable name is case-insensitive and was misspelled.

💡 Hint

Check how shell interprets quotes and variable expansion.

In shell scripts, variables inside single quotes are not expanded. Using double quotes or no quotes allows expansion of environment variables.

🔀 Workflow

advanced

Passing environment variables between Jenkins pipeline stages

Which method correctly passes an environment variable set in one stage to another stage in a Jenkins declarative pipeline?

A Set the variable in the environment block at the pipeline level.

B Use the 'withEnv' step inside each stage separately.

C Set the variable inside a stage's script block and access it directly in the next stage.

D Use 'sh export VAR=value' in one stage and access VAR in the next stage shell step.

💡 Hint

Think about where environment variables must be declared to persist across stages.

Environment variables declared in the pipeline-level environment block are available in all stages. Variables set inside a stage or shell command do not persist to other stages.

✅ Best Practice

expert

Secure handling of sensitive environment variables in Jenkins

What is the recommended best practice to securely use sensitive environment variables like passwords in Jenkins pipelines?

A Print sensitive variables in console logs for debugging.

B Store sensitive values directly in the pipeline script environment block.

C Hardcode secrets in shell commands inside the pipeline.

D Use Jenkins Credentials plugin and access secrets via credentials binding.

💡 Hint

Consider how Jenkins manages secrets securely.

The Jenkins Credentials plugin securely stores secrets and injects them into pipelines without exposing them in logs or code.

Practice

1. In a Jenkins Pipeline script, how do you access an environment variable named BUILD_NUMBER?

easy

A. Using BUILD_NUMBER directly without prefix

B. Using env.BUILD_NUMBER

C. Using getEnv('BUILD_NUMBER')

D. Using $BUILD_NUMBER inside the script block

Solution

1. Step 1: Understand Jenkins environment variable access

   Jenkins Pipeline exposes environment variables via the env object.

2. Step 2: Access the variable using the correct syntax

   You access BUILD_NUMBER as env.BUILD_NUMBER in the script.

3. Final Answer:

   Using env.BUILD_NUMBER -> Option B

4. Quick Check:

   env.VARIABLE_NAME = correct access [OK]

Hint: Always prefix environment variables with env. in Jenkins [OK]

Common Mistakes:

• Trying to use variable name without env prefix
• Using shell-style $VARIABLE inside Groovy script
• Calling non-existent getEnv() method

2. Which of the following is the correct syntax to print the environment variable JOB_NAME in a Jenkins Pipeline script block?

easy

A. println("JOB_NAME")

B. echo $JOB_NAME

C. println(env.JOB_NAME)

D. print(JOB_NAME)

Solution

1. Step 1: Identify the correct way to print env variables in Groovy script

   In Jenkins Pipeline Groovy scripts, use println(env.VARIABLE) to print environment variables.

2. Step 2: Check each option

   println("JOB_NAME") prints the string "JOB_NAME" literally. echo $JOB_NAME uses shell syntax, invalid in Groovy. print(JOB_NAME) attempts to print JOB_NAME directly, but it's not available in Groovy scope without env prefix.

3. Final Answer:

   println(env.JOB_NAME) -> Option C

4. Quick Check:

   Use println(env.VARIABLE) to print env vars in script [OK]

Hint: Use println(env.VARIABLE) inside script blocks [OK]

Common Mistakes:

• Using shell syntax like $VARIABLE inside Groovy
• Printing variable name as string instead of value
• Trying to access variables without env. prefix

3. Given this Jenkins Pipeline snippet:

pipeline {
  agent any
  stages {
    stage('Print Env') {
      steps {
        script {
          echo "Branch is: ${env.BRANCH_NAME}"
        }
      }
    }
  }
}

What will be the output if the environment variable BRANCH_NAME is set to feature-123?

medium

A. Branch is: feature-123

B. Branch is: ${env.BRANCH_NAME}

C. Branch is: BRANCH_NAME

D. Error: BRANCH_NAME not found

Solution

1. Step 1: Understand string interpolation in Jenkins Pipeline

   Using double quotes with ${env.BRANCH_NAME} interpolates the variable value.

2. Step 2: Substitute the environment variable value

   Since BRANCH_NAME is set to "feature-123", the output will be "Branch is: feature-123".

3. Final Answer:

   Branch is: feature-123 -> Option A

4. Quick Check:

   Double quotes + ${env.VAR} = variable value [OK]

Hint: Use double quotes and ${env.VAR} for variable interpolation [OK]

Common Mistakes:

• Using single quotes which prevent interpolation
• Printing variable name literally without ${}
• Assuming env variables are undefined

4. You wrote this Jenkins Pipeline snippet:

pipeline {
  agent any
  environment {
    MY_VAR = 'hello'
  }
  stages {
    stage('Test') {
      steps {
        script {
          echo env.MY_VAR
        }
      }
    }
  }
}

But the output is empty. What is the likely cause?

medium

A. The environment block syntax is incorrect; use MY_VAR='hello' with quotes and no spaces around =

B. Environment variables must be accessed as env['MY_VAR'] not env.MY_VAR

C. The environment variable was not set correctly; use MY_VAR='hello' without spaces

D. You cannot access environment variables inside script blocks

Solution

1. Step 1: Check environment block syntax

   In Jenkins Pipeline, environment variables must be assigned with no spaces around = and values in quotes, like MY_VAR='hello'.

2. Step 2: Identify the syntax error in the snippet

   The snippet uses MY_VAR = 'hello' with spaces around = which is invalid and causes the variable not to be set.

3. Final Answer:

   The environment block syntax is incorrect; use MY_VAR='hello' with quotes and no spaces around = -> Option A

4. Quick Check:

   Use no spaces around = in environment block [OK]

Hint: No spaces around = in environment block assignments [OK]

Common Mistakes:

• Adding spaces around = in environment variable assignment
• Trying to access env vars incorrectly
• Assuming script block can't access env vars

5. You want to pass a secret API key stored as an environment variable API_KEY to a shell command in Jenkins Pipeline. Which is the best way to do this securely?

hard

A. Use sh "curl -H 'Authorization: Bearer $API_KEY' https://api.example.com"

B. Use sh(script: "curl -H 'Authorization: Bearer ${env.API_KEY}' https://api.example.com")

C. Use sh(script: "curl -H 'Authorization: Bearer $API_KEY' https://api.example.com", environment: [API_KEY: env.API_KEY])

D. Use Jenkins credentials binding plugin to inject API_KEY and access it as env.API_KEY inside sh

Solution

1. Step 1: Understand secure handling of secrets in Jenkins

   Secrets like API keys should be stored in Jenkins credentials and injected securely, not hardcoded or exposed in logs.

2. Step 2: Use credentials binding plugin

   This plugin injects secrets as environment variables during the build, accessible as env.API_KEY inside sh without exposing them in logs.

3. Final Answer:

   Use Jenkins credentials binding plugin to inject API_KEY and access it as env.API_KEY inside sh -> Option D

4. Quick Check:

   Use credentials plugin for secrets, not plain env vars [OK]

Hint: Use Jenkins credentials plugin for secrets, not plain env vars [OK]

Common Mistakes:

• Passing secrets directly in shell commands risking exposure
• Using string interpolation exposing secrets in logs
• Not using Jenkins credentials plugin for sensitive data