Avoiding hard-coded values in Jenkins - Step-by-Step Execution

Process Flow - Avoiding hard-coded values

Start Jenkins Pipeline

↓

Define Parameters or Variables

↓

Use Variables in Pipeline Steps

↓

Run Pipeline with Dynamic Values

↓

Output Results Using Variables

↓

End Pipeline

This flow shows how Jenkins pipelines avoid hard-coded values by defining variables or parameters first, then using them dynamically in pipeline steps.

Execution Sample

Jenkins

pipeline {
  agent any
  parameters {
    string(name: 'GREETING', defaultValue: 'Hello', description: 'Greeting message')
  }
  stages {
    stage('Example') {
      steps {
        echo "${params.GREETING}, Jenkins!"
      }
    }
  }
}

A Jenkins pipeline that uses a parameter GREETING instead of a hard-coded greeting message.

Process Table

Step	Action	Variable/Parameter	Value	Output
1	Start pipeline	-	-	-
2	Read parameter GREETING	params.GREETING	Hello (default)	-
3	Execute echo step	params.GREETING	Hello	Hello, Jenkins!
4	Pipeline ends	-	-	-

💡 Pipeline ends after executing all stages using dynamic parameter values instead of hard-coded strings.

Status Tracker

Variable/Parameter	Start	After Step 2	After Step 3	Final
params.GREETING	undefined	Hello (default)	Hello	Hello

Key Moments - 2 Insights

Why do we use parameters like params.GREETING instead of writing 'Hello' directly?

Using parameters lets us change the greeting without editing the pipeline code. As seen in step 2 and 3 of the execution table, the value can be set dynamically, making the pipeline flexible.

What happens if we change the parameter value when running the pipeline?

The pipeline uses the new value instead of the default. This is shown in the execution table where params.GREETING holds the value used in the echo step, allowing different outputs without code changes.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of params.GREETING at Step 2?

A "Goodbye"

B "Hello (default)"

C "Jenkins"

D undefined

💡 Hint

Check the 'Variable/Parameter' and 'Value' columns at Step 2 in the execution table.

At which step does the pipeline output the greeting message?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look at the 'Output' column in the execution table to find when the message is printed.

If we change the parameter GREETING to 'Hi' before running, what changes in the execution table?

A No change, it stays 'Hello'

B Pipeline fails because of unknown value

C Value at Step 2 and Step 3 changes to 'Hi', output changes to 'Hi, Jenkins!'

D Output changes but variable value stays 'Hello'

💡 Hint

Refer to how params.GREETING value affects the output in the execution table and variable tracker.

Concept Snapshot

Avoid hard-coded values in Jenkins pipelines by using parameters or variables.
Define parameters in the pipeline block.
Use ${params.PARAM_NAME} to access values dynamically.
This makes pipelines flexible and easier to maintain.
Change values at runtime without editing code.

Full Transcript

This Jenkins pipeline example shows how to avoid hard-coded values by defining a parameter named GREETING with a default value 'Hello'. The pipeline reads this parameter at runtime and uses it in the echo step to print a greeting message. The execution table traces each step: starting the pipeline, reading the parameter, executing the echo command with the parameter value, and ending the pipeline. The variable tracker shows how params.GREETING changes from undefined to the default value and is used in the output. Key moments clarify why using parameters is better than hard-coding and how changing parameter values affects the pipeline output. The visual quiz tests understanding of parameter values at different steps and the effect of changing parameters before running the pipeline.

Practice

1. Why should you avoid hard-coded values in Jenkins pipelines?

easy

A. Because Jenkins does not support hard-coded values

B. Because hard-coded values run faster

C. To reduce the number of pipeline steps

D. To make pipelines flexible and easier to maintain

Solution

1. Step 1: Understand pipeline flexibility

   Hard-coded values fix data in one place, making changes difficult and pipelines less reusable.

2. Step 2: Recognize benefits of environment variables

   Using environment variables allows easy updates and reuse without changing pipeline code.

3. Final Answer:

   To make pipelines flexible and easier to maintain -> Option D

4. Quick Check:

   Flexibility = Avoid hard-coded values [OK]

Hint: Remember: environment variables make pipelines flexible [OK]

Common Mistakes:

• Thinking hard-coded values improve speed
• Believing Jenkins disallows hard-coded values
• Confusing fewer steps with better practice

2. Which syntax correctly uses an environment variable MY_VAR in a Jenkins pipeline script?

easy

A. echo 'Value is $MY_VAR'

B. echo "Value is ${MY_VAR}"

C. echo "Value is %MY_VAR%"

D. echo "Value is MY_VAR"

Solution

1. Step 1: Identify correct variable syntax in Groovy

   Jenkins pipeline scripts use Groovy, where environment variables are accessed as ${VAR_NAME} inside strings.

2. Step 2: Compare options

   echo "Value is ${MY_VAR}" uses ${MY_VAR}, which is the correct Groovy syntax for environment variables in strings.

3. Final Answer:

   echo "Value is ${MY_VAR}" -> Option B

4. Quick Check:

   Groovy env var syntax = ${VAR} [OK]

Hint: Use ${VAR} to access env variables in Jenkins Groovy scripts [OK]

Common Mistakes:

• Using $VAR without braces in Groovy strings
• Using Windows-style %VAR% syntax
• Writing variable name as plain text

3. Given this Jenkins pipeline snippet:

environment {
  GREETING = 'Hello'
}

pipeline {
  agent any
  stages {
    stage('Print') {
      steps {
        echo "${GREETING}, World!"
      }
    }
  }
}

What will be the output when this pipeline runs?

medium

A. Hello, World!

B. ${GREETING}, World!

C. GREETING, World!

D. Error: GREETING not defined

Solution

1. Step 1: Understand environment block usage

   The environment block defines GREETING as 'Hello', making it available in the pipeline steps.

2. Step 2: Evaluate echo statement

   The echo uses "${GREETING}, World!" which substitutes GREETING with 'Hello'.

3. Final Answer:

   Hello, World! -> Option A

4. Quick Check:

   Env var substitution = Hello, World! [OK]

Hint: Environment vars replace ${VAR} in pipeline steps [OK]

Common Mistakes:

• Expecting literal ${GREETING} output
• Confusing variable scope outside environment block
• Assuming syntax error due to quotes

4. You have this Jenkins pipeline snippet:

environment {
  PASSWORD = credentials('my-secret')
}

steps {
  echo "Password is $PASSWORD"
}

What is the problem with this code?

medium

A. Echoing password directly exposes sensitive data

B. credentials() cannot be used inside environment block

C. Using $PASSWORD instead of ${PASSWORD} causes no substitution

D. Missing quotes around credentials ID

Solution

1. Step 1: Understand credentials usage

   Using credentials('my-secret') loads a secret securely into PASSWORD variable.

2. Step 2: Identify security risk

   Echoing the password directly prints sensitive data in logs, which is unsafe.

3. Final Answer:

   Echoing password directly exposes sensitive data -> Option A

4. Quick Check:

   Never print secrets in logs [OK]

Hint: Never echo secrets; use them securely [OK]

Common Mistakes:

• Thinking $PASSWORD syntax is wrong in Groovy
• Believing credentials() can't be in environment block
• Ignoring security risks of printing secrets

5. You want to avoid hard-coded URLs in your Jenkins pipeline. Which approach best achieves this while keeping the URL secret and reusable?

hard

A. Write the URL directly in the pipeline script as a string

B. Pass the URL as a command-line argument to Jenkins

C. Store the URL in Jenkins credentials and access it via environment variable

D. Use a global variable in the pipeline script with the URL

Solution

1. Step 1: Identify secure storage for sensitive data

   Jenkins credentials store secrets securely and allow reuse without exposing them in code.

2. Step 2: Use environment variables to access credentials

   Accessing credentials via environment variables avoids hard-coding and keeps pipelines flexible.

3. Final Answer:

   Store the URL in Jenkins credentials and access it via environment variable -> Option C

4. Quick Check:

   Secure reuse = credentials + env vars [OK]

Hint: Use Jenkins credentials for secret reusable values [OK]

Common Mistakes:

• Hard-coding secrets in scripts
• Passing secrets insecurely via command line
• Using global vars that expose secrets