Avoiding hard-coded values in Jenkins - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to use a parameter instead of a hard-coded value in Jenkins pipeline.

Jenkins

pipeline {
  agent any
  parameters {
    string(name: 'BRANCH', defaultValue: '[1]', description: 'Git branch to build')
  }
  stages {
    stage('Build') {
      steps {
        echo "Building branch: ${params.BRANCH}"
      }
    }
  }
}

Drag options to blanks, or click blank then click option'

Amain

Bdevelop

Cmaster

Dfeature

Attempts:

3 left

💡 Hint

Common Mistakes

Using a fixed branch name directly in the steps instead of a parameter.

Not defining the parameter in the pipeline.

The default branch name is usually 'master' in many repositories. Using a parameter allows changing it without editing the pipeline code.

2fill in blank

medium

Complete the code to read the environment variable instead of hard-coding the Docker image name.

Jenkins

pipeline {
  agent any
  environment {
    IMAGE_NAME = '[1]'
  }
  stages {
    stage('Build') {
      steps {
        echo "Using image: ${env.IMAGE_NAME}"
      }
    }
  }
}

Drag options to blanks, or click blank then click option'

ADOCKER_IMAGE

Bdocker_image

CimageName

DdockerImage

Attempts:

3 left

💡 Hint

Common Mistakes

Using camelCase for environment variable names.

Hard-coding the image name directly in the steps.

Environment variables are usually uppercase with underscores. Using 'DOCKER_IMAGE' follows this convention and avoids hard-coding.

3fill in blank

hard

Fix the error in the code by replacing the hard-coded timeout value with a parameter.

Jenkins

pipeline {
  agent any
  parameters {
    string(name: 'TIMEOUT_MINUTES', defaultValue: '30', description: 'Timeout in minutes')
  }
  stages {
    stage('Test') {
      steps {
        timeout(time: [1], unit: 'MINUTES') {
          echo 'Running tests'
        }
      }
    }
  }
}

Drag options to blanks, or click blank then click option'

ATIMEOUT_MINUTES

Bparams.TIMEOUT_MINUTES

Cenv.TIMEOUT_MINUTES

Dtimeout

Attempts:

3 left

💡 Hint

Common Mistakes

Using the parameter name directly without 'params.' prefix.

Using environment variable syntax instead of parameters.

To use a parameter value in Jenkins pipeline, you access it via 'params.PARAM_NAME'. This replaces the hard-coded timeout value.

4fill in blank

hard

Fill both blanks to replace hard-coded credentials with Jenkins credentials binding.

Jenkins

pipeline {
  agent any
  environment {
    USERNAME = credentials('[1]')
    PASSWORD = credentials('[2]')
  }
  stages {
    stage('Deploy') {
      steps {
        echo "Deploying with user ${env.USERNAME}"
      }
    }
  }
}

Drag options to blanks, or click blank then click option'

ADEPLOY_USER

BDEPLOY_PASS

Cdeploy_user

Ddeploy_pass

Attempts:

3 left

💡 Hint

Common Mistakes

Using lowercase or incorrect credential IDs.

Hard-coding username and password directly in the pipeline.

Jenkins credentials are referenced by their IDs, which are usually uppercase with underscores. Using 'DEPLOY_USER' and 'DEPLOY_PASS' avoids hard-coding sensitive data.

5fill in blank

hard

Fill all three blanks to create a map of environment variables avoiding hard-coded values.

Jenkins

pipeline {
  agent any
  environment {
    vars = [
      '[1]': params.BRANCH,
      '[2]': env.DOCKER_IMAGE,
      '[3]': credentials('DEPLOY_PASS')
    ]
  }
  stages {
    stage('Print Vars') {
      steps {
        echo "Branch: ${vars.BRANCH_NAME}, Image: ${vars.IMAGE_NAME}, Password: ${vars.PASSWORD}"
      }
    }
  }
}

Drag options to blanks, or click blank then click option'

ABRANCH_NAME

BIMAGE_NAME

CPASSWORD

DDEPLOY_PASS

Attempts:

3 left

💡 Hint

Common Mistakes

Using credential IDs as keys instead of descriptive names.

Hard-coding values instead of using parameters or environment variables.

The keys in the map should be descriptive environment variable names. Using 'BRANCH_NAME', 'IMAGE_NAME', and 'PASSWORD' avoids hard-coded strings and improves clarity.

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