Pipeline stages and steps in Jenkins - Commands & Configuration

Introduction

When you want to automate your software build and deployment, you use a pipeline. Pipelines break the work into stages and steps. Stages group related tasks, and steps are the individual commands or actions inside those stages.

When you want to build your code, run tests, and deploy automatically in order.

When you want to see clear progress and results for each part of your automation.

When you want to stop the process early if a test or build fails.

When you want to organize your automation so it is easy to read and maintain.

When you want to run different tasks on different machines or environments.

Config File - Jenkinsfile

Jenkinsfile

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                echo 'Building the application'
                sh 'echo Build commands go here'
            }
        }
        stage('Test') {
            steps {
                echo 'Running tests'
                sh 'echo Test commands go here'
            }
        }
        stage('Deploy') {
            steps {
                echo 'Deploying the application'
                sh 'echo Deploy commands go here'
            }
        }
    }
}

pipeline: Defines the whole pipeline.

agent any: Runs the pipeline on any available Jenkins agent.

stages: Groups the different stages of the pipeline.

stage('Name'): Defines a stage with a name.

steps: Lists the commands or actions to run inside the stage.

Commands

Check if Jenkins CLI or Jenkins Job Builder is installed and accessible.

Terminal

jenkins-jobs --version

Expected Output

jenkins-job-builder 3.10.0

Start the Jenkins pipeline named 'my-pipeline' to run all stages and steps.

Terminal

jenkins-cli build my-pipeline

Expected Output

[Pipeline] Start of Pipeline

[Pipeline] stage

[Pipeline] { (Build)

Building the application

Build commands go here

[Pipeline] }

[Pipeline] stage

[Pipeline] { (Test)

Running tests

Test commands go here

[Pipeline] }

[Pipeline] stage

[Pipeline] { (Deploy)

Deploying the application

Deploy commands go here

[Pipeline] }

[Pipeline] End of Pipeline

View the console output of the last run of the 'my-pipeline' to check logs for each stage and step.

Terminal

jenkins-cli console my-pipeline

Expected Output

[Pipeline] Start of Pipeline

[Pipeline] stage

[Pipeline] { (Build)

Building the application

Build commands go here

[Pipeline] }

[Pipeline] stage

[Pipeline] { (Test)

Running tests

Test commands go here

[Pipeline] }

[Pipeline] stage

[Pipeline] { (Deploy)

Deploying the application

Deploy commands go here

[Pipeline] }

[Pipeline] End of Pipeline

Key Concept

If you remember nothing else from this pattern, remember: stages organize your pipeline into clear parts, and steps are the commands inside those parts.

Common Mistakes

Putting commands directly under stages without steps block

Jenkins pipeline syntax requires steps inside stages; missing steps causes syntax errors.

Always wrap commands inside a steps block within each stage.

Not naming stages clearly

Without clear stage names, it is hard to understand pipeline progress and logs.

Give each stage a descriptive name that explains its purpose.

Running long commands directly in steps without scripts

Long commands can be hard to read and maintain inside steps.

Use shell scripts or separate files for complex commands and call them from steps.

Summary

Define a Jenkinsfile with pipeline, agent, stages, and steps blocks.

Use stages to group related tasks like build, test, and deploy.

Inside each stage, use steps to run commands or scripts.

Run the pipeline and check console output to see each stage and step run.

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