Pipeline stages and steps in Jenkins - Step-by-Step Execution

Process Flow - Pipeline stages and steps

Start Pipeline

↓

Stage 1: Build

↓

Execute Steps in Build

↓

Stage 2: Test

↓

Execute Steps in Test

↓

Stage 3: Deploy

↓

Execute Steps in Deploy

↓

Pipeline Complete

The pipeline starts, then runs each stage in order. Each stage runs its steps. After all stages finish, the pipeline ends.

Execution Sample

Jenkins

pipeline {
  agent any
  stages {
    stage('Build') {
      steps { echo 'Building...' }
    }
    stage('Test') {
      steps { echo 'Testing...' }
    }
    stage('Deploy') {
      steps { echo 'Deploying...' }
    }
  }
}

This Jenkins pipeline runs three stages: Build, Test, and Deploy, each printing a message.

Process Table

Step	Stage	Step Action	Output	Pipeline State
1	Build	echo 'Building...'	Building...	Build stage running
2	Build	Build stage complete		Moving to Test stage
3	Test	echo 'Testing...'	Testing...	Test stage running
4	Test	Test stage complete		Moving to Deploy stage
5	Deploy	echo 'Deploying...'	Deploying...	Deploy stage running
6	Deploy	Deploy stage complete		Pipeline complete

💡 All stages completed, pipeline ends successfully

Status Tracker

Variable	Start	After Build	After Test	After Deploy
Current Stage	None	Build	Test	Deploy
Pipeline Status	Not started	Running	Running	Completed

Key Moments - 2 Insights

Why does the pipeline wait for all steps in a stage before moving to the next stage?

Because Jenkins runs all steps inside a stage sequentially and only moves to the next stage after completing all steps, as shown in execution_table rows 1-2 and 3-4.

What happens if a step inside a stage fails?

The pipeline stops immediately and does not proceed to the next stages. This is implied by the pipeline state changes in the execution_table where each stage completes before moving on.

Visual Quiz - 3 Questions

Look at the execution table, what is the pipeline state after step 3?

A Build stage running

B Test stage running

C Deploy stage running

D Pipeline complete

💡 Hint

Check the 'Pipeline State' column at step 3 in the execution_table.

At which step does the pipeline move from the Test stage to the Deploy stage?

A Step 4

B Step 2

C Step 5

D Step 6

💡 Hint

Look for the 'Moving to Deploy stage' note in the 'Pipeline State' column.

If the 'Build' stage had two steps instead of one, how would the execution table change?

A The pipeline would skip the Test stage

B The Deploy stage would run before Build

C There would be two rows for the Build stage steps before moving to Test

D The pipeline would end after the first Build step

💡 Hint

Consider how each step is represented as a row in the execution_table.

Concept Snapshot

Jenkins pipelines run in stages.
Each stage has steps executed in order.
Pipeline moves to next stage only after current stage completes.
Stages help organize and visualize pipeline progress.
Failures stop the pipeline immediately.

Full Transcript

A Jenkins pipeline runs through stages one by one. Each stage contains steps that run in order. For example, the Build stage runs its steps, then the pipeline moves to the Test stage, and finally the Deploy stage. The pipeline only moves forward after all steps in a stage finish. If any step fails, the pipeline stops. This helps organize work and track progress clearly.

Practice

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

easy

A. To define environment variables

B. To run shell commands directly

C. To divide the pipeline into distinct parts for clarity

D. To store pipeline logs

Solution

1. Step 1: Understand the role of stages

   Stages are used to split the pipeline into clear sections, making it easier to read and manage.

2. Step 2: Differentiate stages from steps

   Steps are the actual commands or actions inside stages, not the division itself.

3. Final Answer:

   To divide the pipeline into distinct parts for clarity -> Option C

4. Quick Check:

   Stages divide pipeline parts = C [OK]

Hint: Stages split pipeline parts; steps run commands inside [OK]

Common Mistakes:

• Confusing stages with steps
• Thinking stages run commands directly
• Assuming stages store logs

2. Which of the following is the correct syntax to define a stage named Build in a Jenkins declarative pipeline?

easy

A. stages { Build { steps { echo 'Building...' } } }

B. stage: Build { steps { echo 'Building...' } }

C. stage { name: 'Build' steps { echo 'Building...' } }

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

Solution

1. Step 1: Recall declarative pipeline stage syntax

   The correct syntax uses stage('Name') { ... } to define a stage.

2. Step 2: Check the options for correct structure

   stage('Build') { steps { echo 'Building...' } } matches the correct syntax with stage('Build') { steps { ... } }.

3. Final Answer:

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

4. Quick Check:

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

Hint: Use stage('Name') { steps { ... } } for stages [OK]

Common Mistakes:

• Using colon instead of parentheses for stage name
• Placing stage inside stages incorrectly
• Missing quotes around stage name

3. Given this Jenkins pipeline snippet, what will be the output when the pipeline runs?

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

medium

A. Running tests

B. Build stage executed

C. Syntax error

D. No output

Solution

1. Step 1: Identify the stage and steps

   The pipeline has one stage named 'Test' with a step that echoes 'Running tests'.

2. Step 2: Understand echo step output

   The echo step prints the given string to the console output when the pipeline runs.

3. Final Answer:

   Running tests -> Option A

4. Quick Check:

   Echo prints 'Running tests' = A [OK]

Hint: Echo prints text inside steps during stage run [OK]

Common Mistakes:

• Thinking stage name prints output
• Assuming syntax error without checking carefully
• Expecting output from missing steps

4. Identify the error in this Jenkins pipeline snippet:

pipeline {
  agent any
  stages {
    stage('Deploy')
      steps {
        echo 'Deploying app'
      }
  }
}

medium

A. Steps block should be outside stages

B. Missing curly braces after stage declaration

C. Echo command syntax error

D. Incorrect agent declaration

Solution

1. Step 1: Check stage syntax

   The stage block must have curly braces enclosing its content: stage('Deploy') { ... }.

2. Step 2: Identify missing braces

   In the snippet, the stage declaration lacks opening and closing braces around steps.

3. Final Answer:

   Missing curly braces after stage declaration -> Option B

4. Quick Check:

   Stage needs braces { } = D [OK]

Hint: Always use braces {} after stage('name') [OK]

Common Mistakes:

• Forgetting braces after stage name
• Placing steps outside stages block
• Misunderstanding agent syntax

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 pipeline snippet correctly implements this logic?

hard

A. pipeline {
agent any
stages {
stage('Build') {
steps {
echo 'Building...'
}
}
stage('Test') {
steps {
echo 'Testing...'
}
}
}
}

B. pipeline {
agent any
stages {
stage('Build') {
steps {
echo 'Building...'
}
}
stage('Test') {
when {
expression { currentBuild.result == 'SUCCESS' }
}
steps {
echo 'Testing...'
}
}
}
}

C. pipeline {
agent any
stages {
stage('Build') {
steps {
echo 'Building...'
}
}
stage('Test') {
when {
branch 'main'
}
steps {
echo 'Testing...'
}
}
}
}

D. pipeline {
agent any
stages {
stage('Build') {
steps {
echo 'Building...'
}
}
stage('Test') {
steps {
echo 'Testing...'
}
}
}
post {
success {
echo 'Build succeeded'
}
}
}

Solution

1. Step 1: Understand conditional stage execution

   Jenkins declarative pipelines run stages sequentially by default. If the Build stage fails, the Test stage is skipped.

2. Step 2: Check the snippet with sequential stages

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

3. Step 3: Verify distractors

   The snippet with when { expression { currentBuild.result == 'SUCCESS' } } uses the correct property result instead of currentResult.
   The snippet with when { branch 'main' } conditions on Git branch.
   The snippet with post { success { ... } } adds an unrelated post-action block.

4. Final Answer:

   pipeline { agent any stages { stage('Build') { steps { echo 'Building...' } } stage('Test') { steps { echo 'Testing...' } } } } -> Option A

5. Quick Check:

   Sequential stages run conditionally by default = A [OK]

Hint: Stages run sequentially by default; failure skips subsequent stages [OK]

Common Mistakes:

• Using invalid when expression syntax
• Conditioning on branch instead of stage success
• Adding unnecessary post blocks