Dynamic parameter values in Jenkins - Commands & Configuration

Introduction

Sometimes you want your Jenkins job to ask for input that changes depending on other choices or external data. Dynamic parameter values let your job show options that update automatically, making your builds smarter and easier to use.

When you want to let users pick a server from a list that updates every time the job runs.

When you need to select a branch from a Git repository and want the list to show current branches.

When you want to show different options based on a previous parameter choice in the same job.

When you want to fetch values from an external API or script to use as parameters.

When you want to reduce errors by limiting user input to valid, current options.

Config File - Jenkinsfile

Jenkinsfile

pipeline {
  agent any
  parameters {
    choice(name: 'ENVIRONMENT', choices: ['dev', 'staging', 'production'], description: 'Select environment')
    activeChoiceReactiveParam(name: 'SERVER', description: 'Select server based on environment') {
      groovyScript {
        script("""
          if (ENVIRONMENT == 'dev') {
            return ['dev-server1', 'dev-server2']
          } else if (ENVIRONMENT == 'staging') {
            return ['staging-server1', 'staging-server2']
          } else {
            return ['prod-server1', 'prod-server2']
          }
        """)
        fallbackScript("return ['error']")
      }
      referencedParameters(['ENVIRONMENT'])
    }
  }
  stages {
    stage('Show Parameters') {
      steps {
        echo "Environment: ${params.ENVIRONMENT}"
        echo "Server: ${params.SERVER}"
      }
    }
  }
}

This Jenkinsfile defines a pipeline with two parameters.

The first is a fixed choice parameter named ENVIRONMENT with three options.

The second is a dynamic choice parameter named SERVER whose options depend on the selected environment.

The activeChoiceReactiveParam block runs a Groovy script that returns a list of servers based on the ENVIRONMENT parameter.

During the build, Jenkins shows the server options that match the chosen environment.

Commands

This command updates or creates the Jenkins job with the dynamic parameters defined in the job configuration file.

Terminal

jenkins-jobs --conf jenkins.ini update my-pipeline-job.yaml

Expected Output

Job 'my-pipeline-job' updated successfully\n

This command triggers the Jenkins job build, setting the ENVIRONMENT parameter to 'dev'. The SERVER parameter options will be dynamically set based on this.

Terminal

java -jar jenkins-cli.jar -s http://localhost:8080 build my-pipeline-job -p ENVIRONMENT=dev

Expected Output

Started build #1\nWaiting for build to complete...\nFinished: SUCCESS\n

→

-p ENVIRONMENT=dev - Sets the ENVIRONMENT parameter to 'dev' for this build

This command fetches the console output of build number 1 to verify the parameters used during the build.

Terminal

java -jar jenkins-cli.jar -s http://localhost:8080 console my-pipeline-job 1

Expected Output

[Pipeline] echo\nEnvironment: dev\n[Pipeline] echo\nServer: dev-server1\n[Pipeline] End of Pipeline\n

Key Concept

Dynamic parameter values let Jenkins jobs show updated, context-aware options to users, improving input accuracy and flexibility.

Common Mistakes

Defining dynamic parameters without referencing other parameters or external data.

The parameter will not change dynamically and defeats the purpose of dynamic values.

Use scripts or functions that read other parameters or external sources to generate the dynamic list.

Not installing or enabling the required Jenkins plugins for dynamic parameters.

The dynamic parameter feature won't work and may cause errors or missing options.

Install plugins like 'Active Choices Plugin' and configure them properly before using dynamic parameters.

Returning an empty or invalid list from the dynamic parameter script.

The parameter will show no options or cause build failures.

Ensure the script always returns a valid non-empty list of strings for the parameter choices.

Summary

Define dynamic parameters in Jenkinsfiles or job configs to generate options based on other inputs or data.

Use scripts inside the parameter definition to return the list of valid choices dynamically.

Trigger builds with parameters and verify the dynamic values appear and work as expected.

Practice

1. What is the main purpose of using dynamic parameter values in Jenkins jobs?

easy

A. To update input options based on other inputs or external data

B. To make Jenkins jobs run faster

C. To disable user inputs during job execution

D. To automatically restart failed jobs

Solution

1. Step 1: Understand dynamic parameters

   Dynamic parameters change their available options based on other inputs or external data sources.

2. Step 2: Identify the purpose

   This makes Jenkins jobs flexible and user-friendly by showing relevant choices dynamically.

3. Final Answer:

   To update input options based on other inputs or external data -> Option A

4. Quick Check:

   Dynamic parameters update options dynamically [OK]

Hint: Dynamic parameters change options based on other inputs [OK]

Common Mistakes:

• Thinking dynamic parameters speed up job execution
• Confusing dynamic parameters with job restart features
• Assuming dynamic parameters disable inputs

2. Which Jenkins plugin is commonly used to create dynamic parameter values based on a script?

easy

A. Pipeline Plugin

B. Git Plugin

C. Active Choices Plugin

D. Mailer Plugin

Solution

1. Step 1: Identify plugins for dynamic parameters

   The Active Choices Plugin allows parameters to be dynamically generated using Groovy scripts.

2. Step 2: Exclude unrelated plugins

   Git Plugin manages source control, Pipeline Plugin manages job pipelines, and Mailer Plugin sends emails, none create dynamic parameters.

3. Final Answer:

   Active Choices Plugin -> Option C

4. Quick Check:

   Active Choices Plugin enables dynamic parameters [OK]

Hint: Active Choices Plugin supports scripted dynamic parameters [OK]

Common Mistakes:

• Choosing Git Plugin for dynamic parameters
• Confusing Pipeline Plugin with parameter plugins
• Selecting Mailer Plugin unrelated to parameters

3. Given this Groovy script for an Active Choices parameter:

return ['dev', 'test', 'prod'].findAll { it.startsWith(params.ENV_PREFIX ?: '') }

What will be the parameter options if ENV_PREFIX is set to t?

medium

A. ['dev', 'test', 'prod']

B. ['test']

C. ['prod']

D. []

Solution

1. Step 1: Understand the script filtering

   The script returns list items starting with the value of ENV_PREFIX. Here, ENV_PREFIX is 't'.

2. Step 2: Filter the list

   From ['dev', 'test', 'prod'], only 'test' starts with 't'.

3. Final Answer:

   ['test'] -> Option B

4. Quick Check:

   Filter by prefix 't' gives ['test'] [OK]

Hint: Filter list by prefix to find matching options [OK]

Common Mistakes:

• Ignoring the prefix filter and returning full list
• Choosing empty list when prefix matches an item
• Selecting wrong matching item

4. You wrote this Active Choices script:

return ['one', 'two', 'three'].filter { it.contains(params.SEARCH) }

But Jenkins shows a syntax error. What is the problem?

medium

A. The parameter SEARCH must be declared as a string

B. The list should be a map, not a list

C. The script must use double quotes for strings

D. The method should be findAll instead of filter

Solution

1. Step 1: Check Groovy list filtering methods

   Groovy uses findAll to filter lists, not filter which causes syntax error.

2. Step 2: Confirm other parts are correct

   The list syntax and parameter usage are valid; string quotes can be single or double.

3. Final Answer:

   The method should be findAll instead of filter -> Option D

4. Quick Check:

   Use findAll for filtering lists in Groovy [OK]

Hint: Use findAll, not filter, to filter lists in Groovy [OK]

Common Mistakes:

• Using filter instead of findAll causes syntax errors
• Thinking list must be a map for filtering
• Believing quotes type causes syntax error

5. You want a Jenkins job parameter that lists all Git branches dynamically from a repository URL. Which approach correctly implements this dynamic parameter?

hard

A. Use Active Choices Plugin with a Groovy script that runs git ls-remote --heads <repo_url> and parses branch names

B. Use a String parameter and ask users to type branch names manually

C. Use a Boolean parameter to select if branches should be listed

D. Use a fixed Choice parameter with hardcoded branch names

Solution

1. Step 1: Identify dynamic branch listing method

   Active Choices Plugin with Groovy script can run shell commands to fetch live branch names from Git.

2. Step 2: Exclude static or unrelated options

   String parameter requires manual input, Boolean parameter is not for listing, fixed Choice is static and not dynamic.

3. Final Answer:

   Use Active Choices Plugin with a Groovy script that runs git ls-remote --heads <repo_url> and parses branch names -> Option A

4. Quick Check:

   Active Choices + git command fetches dynamic branches [OK]

Hint: Use Active Choices with git command to list branches dynamically [OK]

Common Mistakes:

• Using static parameters instead of dynamic scripts
• Choosing Boolean parameter for listing options
• Forgetting to parse git command output