Node and stage blocks in Jenkins - Practice Problems & Coding Challenges

Challenge - 5 Problems

💻 Command Output

intermediate

Output of Jenkins Pipeline with nested node blocks

What will be the output of this Jenkins pipeline snippet when executed?

Jenkins

pipeline {
  agent none
  stages {
    stage('Build') {
      steps {
        script {
          node('linux') {
            echo 'Inside first node'
            node('windows') {
              echo 'Inside nested node'
            }
          }
        }
      }
    }
  }
}

A Syntax error due to nested node blocks

B Inside first node\nInside nested node

C Inside nested node\nInside first node

D Only 'Inside first node' is printed

💡 Hint

Think about how nested node blocks execute in Jenkins pipelines.

In Jenkins declarative pipelines, 'node' blocks are not allowed inside 'steps' blocks, whether single or nested. This is scripted DSL syntax and will cause a 'No such DSL method node' error.

🧠 Conceptual

intermediate

Purpose of 'agent none' in Jenkins pipeline

What is the main purpose of using agent none at the top level of a Jenkins declarative pipeline?

A To disable automatic agent allocation so stages can specify their own agents

B To force the pipeline to run on the master node only

C To automatically allocate an agent for all stages

D To skip all stages in the pipeline

💡 Hint

Consider how agent allocation works when you want different stages on different nodes.

Using 'agent none' disables automatic agent allocation at the pipeline level, allowing each stage to specify its own node or agent block.

❓ Troubleshoot

advanced

Why does this Jenkins pipeline fail with 'No such DSL method node' error?

Given this pipeline snippet, why does Jenkins report 'No such DSL method node' error?

pipeline {
  agent any
  stages {
    stage('Test') {
      steps {
        node('linux') {
          echo 'Running tests'
        }
      }
    }
  }
}

A Because 'node' requires a label but 'linux' is undefined

B Because the 'agent any' conflicts with the 'node' block

C Because 'node' block is not allowed inside 'steps' in declarative pipelines

D Because 'echo' is not allowed inside 'node' blocks

💡 Hint

Check the allowed syntax inside declarative pipeline 'steps' blocks.

In declarative pipelines, 'node' blocks are not allowed inside 'steps'. Instead, use 'agent' at stage level or script blocks for scripted syntax.

🔀 Workflow

advanced

Correct stage and node usage for parallel builds

You want to run two builds in parallel on different nodes: one on 'linux' and one on 'windows'. Which pipeline snippet correctly achieves this?

Jenkins

pipeline {
  agent none
  stages {
    stage('Parallel Builds') {
      parallel {
        'Linux Build': {
          node('linux') {
            echo 'Building on Linux'
          }
        },
        'Windows Build': {
          node('windows') {
            echo 'Building on Windows'
          }
        }
      }
    }
  }
}

A The pipeline runs sequentially because 'parallel' is not allowed inside 'stages'.

B The pipeline runs only on the master node ignoring labels.

C The pipeline will fail because 'agent' cannot be used inside parallel stages.

D The given pipeline snippet runs both builds in parallel on specified nodes.

💡 Hint

Think about how parallel stages and agents work in declarative pipelines.

Declarative pipelines support parallel stages, but 'agent' cannot be used inside parallel branches/stages. Branches share the parent stage's agent. Use scripted 'node' {} inside parallel closures for different agents.

✅ Best Practice

expert

Best practice for using node blocks in Jenkins scripted pipeline

In a scripted Jenkins pipeline, what is the best practice for using node blocks to optimize resource usage and avoid unnecessary workspace allocation?

A Use multiple <code>node</code> blocks for each step to ensure clean workspace every time

B Use a single <code>node</code> block wrapping all build steps to minimize workspace allocation overhead

C Avoid <code>node</code> blocks entirely and run all steps on the master node

D Use nested <code>node</code> blocks with different labels inside each other for flexibility

💡 Hint

Consider workspace allocation and agent usage costs.

Using a single node block reduces overhead by allocating workspace once and reusing it, improving efficiency and reducing resource consumption.

Practice

1. What is the main purpose of a node block in a Jenkins pipeline?

easy

A. To declare environment variables for the pipeline

B. To define a named step grouping in the pipeline

C. To specify the machine or agent where the pipeline steps run

D. To send notifications after the pipeline finishes

Solution

1. Step 1: Understand the role of node block

   The node block tells Jenkins which machine or agent will run the enclosed commands.

2. Step 2: Differentiate from stage block

   The stage block is for grouping steps with a name, not for selecting the machine.

3. Final Answer:

   To specify the machine or agent where the pipeline steps run -> Option C

4. Quick Check:

   Node block = machine selection [OK]

Hint: Node block = where commands run, stage block = what step runs [OK]

Common Mistakes:

• Confusing node with stage blocks
• Thinking node defines step names
• Assuming node sets environment variables

2. Which of the following is the correct syntax to define a stage inside a Jenkins pipeline?

easy

A. stage: Build { echo 'Building...' }

B. node('Build') { echo 'Building...' }

C. steps { stage('Build') { echo 'Building...' } }

D. stage('Build') { steps { echo 'Building...' } }

Solution

1. Step 1: Recall correct stage syntax

   The correct syntax uses stage('name') { steps { ... } } to define a stage with steps inside.

2. Step 2: Check each option

   stage('Build') { steps { echo 'Building...' } } matches the correct syntax. Options A, B, and D misuse keywords or structure.

3. Final Answer:

   stage('Build') { steps { echo 'Building...' } } -> Option D

4. Quick Check:

   Stage syntax = stage('name') { steps { ... } } [OK]

Hint: Stage blocks use stage('name') with steps inside [OK]

Common Mistakes:

• Using node instead of stage for grouping steps
• Missing steps block inside stage
• Incorrect colon or braces placement

3. Given the Jenkins pipeline snippet below, what will be the output?

pipeline {
  agent any
  stages {
    stage('Example') {
      steps {
        node('linux') {
          echo 'Running on Linux node'
        }
      }
    }
  }
}

medium

A. Running on Linux node

B. Syntax error due to nested node inside steps

C. Pipeline runs but no output is shown

D. Error: agent and node blocks cannot be combined

Solution

1. Step 1: Analyze pipeline structure

   The pipeline uses agent any globally and inside the stage steps calls node('linux') to run commands on a Linux node.

2. Step 2: Understand nested node usage

   Nested node blocks inside steps are allowed in scripted pipelines; here it will run the echo command on the specified node.

3. Final Answer:

   Running on Linux node -> Option A

4. Quick Check:

   Nested node runs commands on specified agent [OK]

Hint: Nested node inside steps runs commands on chosen agent [OK]

Common Mistakes:

• Assuming nested node causes syntax error
• Thinking agent any forbids node blocks
• Expecting no output from echo

4. Identify the error in this Jenkins pipeline snippet:

pipeline {
  agent any
  stages {
    stage('Test') {
      node {
        steps {
          echo 'Testing...'
        }
      }
    }
  }
}

medium

A. The node block is incorrectly placed inside stage

B. Missing agent inside the stage block

C. The steps block should be outside node

D. The echo command is invalid inside steps

Solution

1. Step 1: Review pipeline block structure

   Declarative pipelines require agent to specify where stages run; node is not valid inside stage in declarative syntax.

2. Step 2: Identify correct usage

   Instead of node, the stage should have an agent block or rely on global agent any.

3. Final Answer:

   The node block is incorrectly placed inside stage -> Option A

4. Quick Check:

   Declarative stage needs agent, not node [OK]

Hint: Use agent, not node, inside declarative stage blocks [OK]

Common Mistakes:

• Using node block inside declarative stage
• Confusing steps placement
• Thinking echo is invalid inside steps

5. You want to run two stages in your Jenkins pipeline: 'Build' on a Linux node and 'Test' on a Windows node. Which pipeline snippet correctly uses node and stage blocks to achieve this?

hard

A. pipeline {
agent none
stages {
stage('Build') {
steps {
node('linux') {
echo 'Building on Linux'
}
}
}
stage('Test') {
steps {
node('windows') {
echo 'Testing on Windows'
}
}
}
}
}

B. pipeline {
agent any
stages {
stage('Build') {
agent { label 'linux' }
steps {
echo 'Building on Linux'
}
}
stage('Test') {
agent { label 'windows' }
steps {
echo 'Testing on Windows'
}
}
}
}

C. pipeline {
agent any
stages {
stage('Build') {
node('linux') {
steps {
echo 'Building on Linux'
}
}
}
stage('Test') {
node('windows') {
steps {
echo 'Testing on Windows'
}
}
}
}
}

D. pipeline {
agent none
stages {
stage('Build') {
agent { label 'windows' }
steps {
echo 'Building on Linux'
}
}
stage('Test') {
agent { label 'linux' }
steps {
echo 'Testing on Windows'
}
}
}
}

Solution

1. Step 1: Understand declarative pipeline agent usage

   In declarative pipelines, use agent { label 'name' } inside stages to specify the node label.

2. Step 2: Evaluate each option

   pipeline { agent any stages { stage('Build') { agent { label 'linux' } steps { echo 'Building on Linux' } } stage('Test') { agent { label 'windows' } steps { echo 'Testing on Windows' } } } } correctly uses agent inside each stage with labels 'linux' and 'windows'. pipeline { agent none stages { stage('Build') { steps { node('linux') { echo 'Building on Linux' } } } stage('Test') { steps { node('windows') { echo 'Testing on Windows' } } } } } misuses node inside steps in declarative style. pipeline { agent any stages { stage('Build') { node('linux') { steps { echo 'Building on Linux' } } } stage('Test') { node('windows') { steps { echo 'Testing on Windows' } } } } } uses node blocks incorrectly inside stage. pipeline { agent none stages { stage('Build') { agent { label 'windows' } steps { echo 'Building on Linux' } } stage('Test') { agent { label 'linux' } steps { echo 'Testing on Windows' } } } } swaps labels incorrectly.

3. Final Answer:

   Option B uses agent labels correctly inside stages -> Option B

4. Quick Check:

   Use agent { label } inside stages for node selection [OK]

Hint: Use agent { label 'name' } inside stages, not node blocks [OK]

Common Mistakes:

• Using node blocks inside declarative stages
• Swapping node labels by mistake
• Not setting agent none when using stage agents