Why scripted pipelines offer flexibility in Jenkins - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why do scripted pipelines allow more complex logic than declarative pipelines?

Choose the best reason why scripted pipelines in Jenkins offer more flexibility compared to declarative pipelines.

A Scripted pipelines automatically generate UI forms for input parameters.

B Scripted pipelines have a simpler syntax that restricts complex logic.

C Declarative pipelines allow more customization than scripted pipelines.

D Scripted pipelines use Groovy code, allowing loops, conditionals, and custom functions.

💡 Hint

Think about what programming features Groovy code provides.

Scripted pipelines are written in Groovy, which supports full programming features like loops and conditionals, enabling complex logic. Declarative pipelines have a more rigid structure.

💻 Command Output

intermediate

Output of a scripted pipeline with conditional stage execution

What will be the output of this scripted pipeline snippet when the variable runTests is false?

Jenkins

def runTests = false
node {
  stage('Build') {
    echo 'Building...'
  }
  if (runTests) {
    stage('Test') {
      echo 'Testing...'
    }
  }
  stage('Deploy') {
    echo 'Deploying...'
  }
}

A Build stage skipped; only Deploying...

B Building...\nTesting...\nDeploying...

C Building...\nDeploying...

D Testing...\nDeploying...

💡 Hint

Check the condition controlling the 'Test' stage.

The 'Test' stage runs only if runTests is true. Since it is false, the pipeline skips the 'Test' stage and runs 'Build' and 'Deploy' stages.

🔀 Workflow

advanced

How to implement parallel stages in a scripted pipeline

Which scripted pipeline code correctly runs two stages in parallel?

A parallel firstBranch: { echo 'Running first branch' }, secondBranch: { echo 'Running second branch' }

B stage('Parallel') { runInParallel { echo 'First'; echo 'Second' } }

C parallel { stage('First') { echo 'First' } stage('Second') { echo 'Second' } }

D node { parallel { echo 'First'; echo 'Second' } }

💡 Hint

Remember the syntax for the parallel step in scripted pipelines.

The parallel step takes a map of branch names to closures. Option A correctly uses this syntax. Other options misuse the syntax or steps.

❓ Troubleshoot

advanced

Why does this scripted pipeline fail with a missing method error?

Given this scripted pipeline snippet, why does Jenkins report groovy.lang.MissingMethodException?

Jenkins

node {
  stage('Example') {
    sh 'echo Hello'
  }
  stage('Example') {
    sh 'echo World'
  }
}

A Duplicate stage names cause Jenkins to fail with a missing method error.

B The <code>sh</code> step is not allowed inside scripted pipelines.

C Stages must be inside a <code>pipeline</code> block in scripted pipelines.

D The <code>node</code> block is missing a required parameter.

💡 Hint

Check the stage names and how Jenkins handles them.

Using the same stage name twice in a scripted pipeline causes Jenkins to confuse the method calls, leading to a missing method error.

✅ Best Practice

expert

Best practice for sharing variables between stages in scripted pipelines

In a scripted pipeline, what is the best way to share a variable's value between multiple stages?

A Declare the variable outside the <code>node</code> block as a global variable.

B Use <code>env</code> environment variables to store and share values.

C Declare the variable inside each stage separately to avoid conflicts.

D Use <code>def</code> inside each stage to create local copies.

💡 Hint

Think about persistence and accessibility of variables across stages.

Environment variables (env) persist across stages and nodes, making them the best way to share values in scripted pipelines. Variables declared with def are local to their scope.