Keeping pipelines fast in Jenkins - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to run a stage only when changes are detected in the 'src/' directory.

Jenkins

stage('Build') {
  when {
    changeset '[1]'
  }
  steps {
    echo 'Building project...'
  }
}

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

Aexpression true

Bbranch 'main'

Cenvironment 'PROD'

D'src/**'

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'branch' instead of 'changeset' for file changes.

Not specifying the path pattern correctly.

The changeset 'src/**' condition runs the stage only if files under 'src/' changed, keeping the pipeline fast by skipping unnecessary builds.

2fill in blank

medium

Complete the code to cache dependencies in a Jenkins pipeline using the 'stash' step.

Jenkins

stage('Cache Dependencies') {
  steps {
    [1] name: 'deps', includes: 'node_modules/**'
  }
}

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

Astash

BarchiveArtifacts

Cunstash

Dcheckout

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'unstash' instead of 'stash' to save files.

Using 'archiveArtifacts' which is for storing build outputs.

The stash step saves files temporarily to speed up later stages by reusing dependencies.

3fill in blank

hard

Fix the error in the pipeline code to parallelize tests correctly.

Jenkins

parallel {
  unit: {
    steps {
      sh 'run-unit-tests.sh'
    }
  },
  integration: {
    steps {
      [1] 'run-integration-tests.sh'
    }
  }
}

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

Ascript

Bsh

Cbat

Dstage

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'bat' which is for Windows batch scripts.

Using 'stage' inside parallel incorrectly.

The sh step runs shell commands in Linux agents. Using it correctly runs the integration tests in parallel.

4fill in blank

hard

Fill both blanks to enable polling for changes and ensure the source code is checked out.

Jenkins

pipeline {
  agent any
  triggers {
    pollSCM('[1]')
  }
  options {
    skipDefaultCheckout [2]
  }
  stages {
    stage('Build') {
      steps {
        echo 'Building...'
      }
    }
  }
}

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

AH/5 * * * *

Bfalse

Dtrue

Attempts:

3 left

💡 Hint

Common Mistakes

Disabling polling causes pipeline not to trigger on changes.

Skipping checkout causes build failures.

Setting pollSCM('H/5 * * * *') enables polling for changes, and skipDefaultCheckout false ensures the source code is checked out, which is needed for builds.

5fill in blank

hard

Fill all three blanks to define a fast pipeline that runs tests in parallel and uses caching.

Jenkins

pipeline {
  agent any
  stages {
    stage('Prepare') {
      steps {
        [1] name: 'cache', includes: 'dependencies/**'
      }
    }
    stage('Test') {
      parallel {
        unit: {
          steps {
            [2] 'run-unit-tests.sh'
          }
        },
        integration: {
          steps {
            [3] 'run-integration-tests.sh'
          }
        }
      }
    }
  }
}

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

Astash

Bsh

Dcheckout

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'checkout' instead of 'stash' for caching.

Using 'bat' instead of 'sh' on Linux agents.

Use stash to cache dependencies, and sh to run shell scripts for both unit and integration tests in parallel, keeping the pipeline fast.

Practice

1. Why is it important to keep Jenkins pipelines fast?

easy

A. To make the pipeline logs longer

B. To deliver code quickly and improve team efficiency

C. To increase the number of pipeline steps

D. To use more server resources

Solution

1. Step 1: Understand pipeline speed impact

   Fast pipelines reduce wait time for developers and speed up delivery.

2. Step 2: Identify the benefit of fast pipelines

   Faster pipelines improve team efficiency and allow quicker feedback.

3. Final Answer:

   To deliver code quickly and improve team efficiency -> Option B

4. Quick Check:

   Fast pipelines = faster delivery [OK]

Hint: Fast pipelines help teams deliver code quickly [OK]

Common Mistakes:

• Thinking more steps make pipelines faster
• Believing longer logs improve speed
• Assuming more resource use equals speed

2. Which Jenkins pipeline syntax correctly sets a timeout of 10 minutes for a stage?

easy

A. timeout(time: 10, unit: 'MINUTES') { /* steps */ }

B. timeout(10 minutes) { /* steps */ }

C. timeout(10) { /* steps */ }

D. timeout(time=10, unit='minutes') { /* steps */ }

Solution

1. Step 1: Recall Jenkins timeout syntax

   The correct syntax uses named parameters: time and unit.

2. Step 2: Match correct syntax

   timeout(time: 10, unit: 'MINUTES') { /* steps */ } uses timeout(time: 10, unit: 'MINUTES') which is valid Groovy syntax.

3. Final Answer:

   timeout(time: 10, unit: 'MINUTES') { /* steps */ } -> Option A

4. Quick Check:

   timeout(time: 10, unit: 'MINUTES') = correct syntax [OK]

Hint: Use named parameters time and unit for timeout [OK]

Common Mistakes:

• Using timeout(10 minutes) without quotes
• Missing unit parameter
• Using equal signs instead of colons

3. What will be the output of this Jenkins pipeline snippet?

pipeline {
  agent any
  stages {
    stage('Parallel') {
      parallel {
        stage('A') { steps { echo 'Running A' } }
        stage('B') { steps { echo 'Running B' } }
      }
    }
  }
}

medium

A. Runs stages A and B at the same time

B. Runs stages A and B one after another

C. Runs only stage A

D. Pipeline fails due to syntax error

Solution

1. Step 1: Analyze parallel block syntax in Jenkins Declarative Pipeline

   The parallel block can contain nested stages inside it in Declarative Pipeline syntax.

2. Step 2: Identify the behavior

   Stages A and B inside parallel run concurrently, so both run at the same time.

3. Final Answer:

   Runs stages A and B at the same time -> Option A

4. Quick Check:

   parallel runs stages concurrently [OK]

Hint: parallel block runs nested stages concurrently [OK]

Common Mistakes:

• Thinking stages can not be nested inside parallel
• Assuming parallel runs stages sequentially
• Believing the syntax is invalid

4. You have a Jenkins pipeline that runs slowly. Which change will help fix this issue?

stage('Build') {
  steps {
    sh 'sleep 60'
  }
}

medium

A. Add more sleep commands to wait longer

B. Increase the timeout to 120 minutes

C. Change sleep to a non-blocking command

D. Remove the sleep command or reduce its duration

Solution

1. Step 1: Identify slow step

   The 'sleep 60' command pauses the pipeline for 60 seconds, slowing it down.

2. Step 2: Fix by removing or reducing sleep

   Removing or reducing sleep will speed up the pipeline.

3. Final Answer:

   Remove the sleep command or reduce its duration -> Option D

4. Quick Check:

   Removing delays = faster pipeline [OK]

Hint: Remove unnecessary waits like sleep to speed up pipelines [OK]

Common Mistakes:

• Adding more sleep commands
• Increasing timeout instead of fixing delay
• Thinking sleep is non-blocking

5. You want to speed up a Jenkins pipeline by skipping tests when a commit message contains '[skip tests]'. Which pipeline step correctly implements this logic?

hard

A. if (env.GIT_COMMIT_MESSAGE.contains('[skip tests]')) { sh 'run-tests.sh' } else { echo 'Skipping tests' }

B. if (env.GIT_COMMIT_MESSAGE == '[skip tests]') { sh 'run-tests.sh' } else { echo 'Skipping tests' }

C. if (env.GIT_COMMIT_MESSAGE.contains('[skip tests]')) { echo 'Skipping tests'; } else { sh 'run-tests.sh' }

D. if (env.GIT_COMMIT_MESSAGE.contains('skip tests')) { sh 'run-tests.sh' } else { echo 'Skipping tests' }

Solution

1. Step 1: Understand the condition to skip tests

   Tests should be skipped if commit message contains '[skip tests]'.

2. Step 2: Match correct logic and commands

   if (env.GIT_COMMIT_MESSAGE.contains('[skip tests]')) { echo 'Skipping tests'; } else { sh 'run-tests.sh' } checks for '[skip tests]' and skips tests by echoing message; else runs tests.

3. Final Answer:

   if (env.GIT_COMMIT_MESSAGE.contains('[skip tests]')) { echo 'Skipping tests'; } else { sh 'run-tests.sh' } -> Option C

4. Quick Check:

   Correct condition and action = if (env.GIT_COMMIT_MESSAGE.contains('[skip tests]')) { echo 'Skipping tests'; } else { sh 'run-tests.sh' } [OK]

Hint: Use contains('[skip tests]') to conditionally skip tests [OK]

Common Mistakes:

• Using equality instead of contains
• Reversing the if-else logic
• Missing brackets in string match