Stage block structure in Jenkins - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of a stage block in a Jenkins pipeline?

A stage block groups related steps in a Jenkins pipeline to organize the build process into clear phases like build, test, and deploy.

beginner

How do you define a simple stage block in a Jenkins declarative pipeline?

Use the syntax:

stage('Stage Name') {
  steps {
    // commands here
  }
}

This defines a named stage with steps inside.

intermediate

Can a stage block contain other stage blocks inside it?

No, stage blocks cannot be nested inside other stage blocks in declarative pipelines. Each stage is a separate phase.

intermediate

What happens if a step inside a stage block fails?

If a step fails, the current stage stops and the pipeline usually fails unless error handling is added.

beginner

Why is it useful to have multiple stage blocks in a Jenkins pipeline?

Multiple stage blocks help organize the pipeline into clear parts, making it easier to read, debug, and see progress in the Jenkins UI.

What keyword starts a stage block in a Jenkins declarative pipeline?

A stage

B step

C node

D pipeline

The stage keyword defines a stage block in Jenkins declarative pipelines.

Can you nest one stage block inside another in Jenkins declarative pipelines?

A Yes, always

B Only if stages have different names

C Only if using scripted pipeline

D No, nesting stages is not allowed

Nesting stage blocks inside each other is not allowed in declarative pipelines.

Where do you put the commands to run inside a stage block?

A Directly inside <code>stage</code>

B Inside <code>steps</code> block

C Inside <code>environment</code> block

D Inside <code>post</code> block

Commands go inside the steps block within a stage.

What is the main benefit of using multiple stages in a Jenkins pipeline?

A To organize the pipeline into clear phases

B To run all steps in parallel

C To skip steps automatically

D To reduce pipeline execution time

Multiple stages help organize the pipeline into clear, understandable phases.

If a step inside a stage fails, what usually happens?

A The stage continues anyway

B The pipeline skips to the next stage

C The stage stops and pipeline fails

D The pipeline restarts automatically

A failure in a step usually stops the current stage and fails the pipeline.

Explain the structure of a Jenkins declarative pipeline stage block and its main components.

Think about how you organize tasks in a project phase.

Describe why using multiple stages in a Jenkins pipeline is helpful for managing builds.

Compare it to breaking a big task into smaller steps.

Practice

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

easy

A. To define environment variables for the pipeline

B. To divide the pipeline into named steps for better organization and tracking

C. To specify the agent where the pipeline runs

D. To declare global variables accessible in all stages

Solution

1. Step 1: Understand the role of stage in Jenkins

   The stage block is used to split the pipeline into named sections, making it easier to follow and debug.

2. Step 2: Compare with other pipeline blocks

   Other blocks like environment or agent serve different purposes, not organizing steps.

3. Final Answer:

   To divide the pipeline into named steps for better organization and tracking -> Option B

4. Quick Check:

   Stage block purpose = organization [OK]

Hint: Stages name steps to track progress clearly [OK]

Common Mistakes:

• Confusing stage with environment block
• Thinking stage sets agents
• Assuming stage declares variables

2. Which of the following is the correct syntax for defining a stage named Build with a simple shell command in Jenkins declarative pipeline?

easy

A. stage('Build') { step { sh 'make' } }

B. stage: 'Build' { steps { sh 'make' } }

C. stage('Build') { steps { sh 'make' } }

D. stage('Build') steps { sh 'make' }

Solution

1. Step 1: Recall correct stage block syntax

   The correct syntax uses stage('Name') { steps { ... } } with curly braces and plural steps.

2. Step 2: Identify syntax errors in other options

   The other options contain these errors: singular step instead of plural steps, colon : instead of parentheses for the stage name, and missing opening brace before steps.

3. Final Answer:

   stage('Build') { steps { sh 'make' } } -> Option C

4. Quick Check:

   Correct stage syntax = stage('Build') { steps { sh 'make' } } [OK]

Hint: Remember: stage('name') { steps { ... } } [OK]

Common Mistakes:

• Using colon instead of braces
• Writing singular 'step' instead of 'steps'
• Omitting braces around steps block

3. Given this Jenkins pipeline snippet, what will be the output in the console for the Test stage?

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

medium

A. No output

B. Test stage skipped

C. Syntax error in pipeline

D. Running tests

Solution

1. Step 1: Analyze the pipeline snippet

   The pipeline defines a single stage named 'Test' with a step that echoes 'Running tests'.

2. Step 2: Understand echo behavior in Jenkins

   The echo command prints the given string to the console output during the stage execution.

3. Final Answer:

   Running tests -> Option D

4. Quick Check:

   Echo prints message = Running tests [OK]

Hint: Echo prints text inside steps block [OK]

Common Mistakes:

• Assuming echo does not print
• Thinking stage is skipped
• Confusing syntax errors

4. Identify the error in this Jenkins pipeline stage block:

stage('Deploy') {
  step {
    sh 'deploy.sh'
  }
}

medium

A. The block should use steps instead of step

B. The stage name must be lowercase

C. The sh command is invalid inside a stage

D. Missing agent declaration inside the stage

Solution

1. Step 1: Check the block keyword inside stage

   The correct keyword to wrap commands inside a stage is steps (plural), not step.

2. Step 2: Verify other options

   Stage names can be any case, sh is valid inside steps, and agent is optional if defined globally.

3. Final Answer:

   The block should use steps instead of step -> Option A

4. Quick Check:

   Use 'steps' block inside stage [OK]

Hint: Inside stage, use 'steps' plural for commands [OK]

Common Mistakes:

• Using singular 'step' instead of 'steps'
• Thinking stage name case matters
• Assuming sh is invalid inside stage

5. You want to create a Jenkins pipeline with two stages: Build and Test. The Test stage should only run if the Build stage succeeds. Which structure correctly enforces this using stage blocks?

hard

A. pipeline { agent any; stages { stage('Build') { steps { sh 'make' } } stage('Test') { when { expression { currentBuild.result == null || currentBuild.result == 'SUCCESS' } } steps { sh 'make test' } } } }

B. pipeline { agent any; stages { stage('Build') { steps { sh 'make' } } stage('Test') { steps { sh 'make test' } } } }

C. pipeline { agent any; stages { stage('Build') { steps { sh 'make' } } stage('Test') { when { branch 'main' } steps { sh 'make test' } } } }

D. pipeline { agent any; stages { stage('Build') { steps { sh 'make' } } stage('Test') { steps { sh 'make test' } post { always { echo 'Test done' } } } } }

Solution

1. Step 1: Understand stage execution conditions

   By default, stages run sequentially but may run even if previous stages fail. To run Test only if Build succeeds, use a when condition checking build result.

2. Step 2: Analyze options for conditional execution

   pipeline { agent any; stages { stage('Build') { steps { sh 'make' } } stage('Test') { when { expression { currentBuild.result == null || currentBuild.result == 'SUCCESS' } } steps { sh 'make test' } } } } uses when with an expression checking if the current build result is success or null (meaning no failure yet), ensuring Test runs only after successful Build.

3. Step 3: Verify other options

   pipeline { agent any; stages { stage('Build') { steps { sh 'make' } } stage('Test') { steps { sh 'make test' } } } } runs both stages unconditionally. pipeline { agent any; stages { stage('Build') { steps { sh 'make' } } stage('Test') { when { branch 'main' } steps { sh 'make test' } } } } runs Test only on branch 'main' but not based on build success. pipeline { agent any; stages { stage('Build') { steps { sh 'make' } } stage('Test') { steps { sh 'make test' } post { always { echo 'Test done' } } } } } runs Test always and adds a post action.

4. Final Answer:

   pipeline { agent any; stages { stage('Build') { steps { sh 'make' } } stage('Test') { when { expression { currentBuild.result == null || currentBuild.result == 'SUCCESS' } } steps { sh 'make test' } } } } -> Option A

5. Quick Check:

   Use 'when' with build result for conditional stages [OK]

Hint: Use 'when' block to run stage only on success [OK]

Common Mistakes:

• Assuming stages run conditionally by default
• Using branch condition instead of build result
• Missing 'when' block for conditional execution