Dynamic parameter values in Jenkins - Mini Project: Build & Apply

Dynamic Parameter Values in Jenkins Pipeline

📖 Scenario: You are setting up a Jenkins pipeline for a software project. You want to create a build parameter that changes its available options based on another parameter's value. This helps the team pick the right build options easily.

🎯 Goal: Build a Jenkins pipeline script that defines two parameters: ENVIRONMENT and VERSION. The VERSION parameter's options should change dynamically depending on the selected ENVIRONMENT value.

📋 What You'll Learn

Create a string parameter called ENVIRONMENT with options: dev, test, prod

Create a dynamic choice parameter called VERSION whose options depend on the ENVIRONMENT value

Use a Groovy script inside the pipeline to set the VERSION options dynamically

Print the selected ENVIRONMENT and VERSION values in the pipeline output

💡 Why This Matters

🌍 Real World

Dynamic parameters help teams avoid mistakes by showing only relevant options based on previous choices, making builds faster and less error-prone.

💼 Career

Understanding dynamic parameters is useful for Jenkins administrators and DevOps engineers to create flexible and user-friendly pipelines.

1

Create the ENVIRONMENT parameter

Create a Jenkins pipeline parameter called ENVIRONMENT with the choices dev, test, and prod using the parameters block.

Jenkins

pipeline {
    agent any
    parameters {
        // Your code here
    }
    stages {
        stage('Example') {
            steps {
                echo 'Starting pipeline'
            }
        }
    }
}

Hint

Use the choice parameter type inside the parameters block.

2

Add a dynamic VERSION parameter

Add a VERSION parameter using the extendedChoice plugin or a Groovy script that will later be set dynamically based on ENVIRONMENT. For now, add the parameter with an empty placeholder list.

Jenkins

pipeline {
    agent any
    parameters {
        choice(name: 'ENVIRONMENT', choices: ['dev', 'test', 'prod'], description: 'Select the environment')
        // Your code here to add VERSION parameter
    }
    stages {
        stage('Example') {
            steps {
                echo 'Starting pipeline'
            }
        }
    }
}

Hint

Add a choice parameter named VERSION with an empty list for now.

3

Set VERSION options dynamically based on ENVIRONMENT

Inside the stages block, add a script step that sets the VERSION parameter choices dynamically using a Groovy map. Use dev -> ["1.0-dev", "1.1-dev"], test -> ["1.0-test", "1.1-test"], and prod -> ["1.0", "1.1"]. Assign the correct list to a variable called versionOptions based on params.ENVIRONMENT.

Jenkins

pipeline {
    agent any
    parameters {
        choice(name: 'ENVIRONMENT', choices: ['dev', 'test', 'prod'], description: 'Select the environment')
        choice(name: 'VERSION', choices: [''], description: 'Select the version')
    }
    stages {
        stage('Example') {
            steps {
                echo 'Starting pipeline'
                // Set versionOptions based on params.ENVIRONMENT
                // Your code here
            }
        }
    }
}

Hint

Use a Groovy map to store version lists and select based on params.ENVIRONMENT.

4

Print the selected ENVIRONMENT and VERSION

Add echo statements inside the steps block to print the selected ENVIRONMENT and VERSION values using params.ENVIRONMENT and params.VERSION.

Jenkins

pipeline {
    agent any
    parameters {
        choice(name: 'ENVIRONMENT', choices: ['dev', 'test', 'prod'], description: 'Select the environment')
        choice(name: 'VERSION', choices: [''], description: 'Select the version')
    }
    stages {
        stage('Example') {
            steps {
                echo 'Starting pipeline'
                script {
                    def versionsMap = [
                        dev: ['1.0-dev', '1.1-dev'],
                        test: ['1.0-test', '1.1-test'],
                        prod: ['1.0', '1.1']
                    ]
                    def versionOptions = versionsMap[params.ENVIRONMENT]
                }
                // Your code here to print selected parameters
            }
        }
    }
}

Hint

Use echo with params.ENVIRONMENT and params.VERSION to show selections.

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