Declarative pipeline syntax in Jenkins - Step-by-Step Execution

Process Flow - Declarative pipeline syntax

Start pipeline

↓

Define pipeline block

↓

Specify agent

↓

Define stages

↓

Stage 1: Steps

↓

Stage 2: Steps

↓

Post actions (optional)

↓

Pipeline ends

The declarative pipeline starts with a pipeline block, specifies an agent, defines stages with steps, and optionally post actions before ending.

Execution Sample

Jenkins

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

This pipeline runs on any agent and has one stage 'Build' that prints 'Building...'.

Process Table

Step	Action	Evaluation	Result
1	Start pipeline	pipeline block found	Pipeline execution begins
2	Agent specified	agent any	Runs on any available agent
3	Enter stages block	stages found	Prepare to run stages
4	Enter stage 'Build'	stage('Build') found	Ready to run Build stage
5	Execute steps in 'Build'	steps { echo 'Building...' }	Prints 'Building...' to console
6	No more stages	end of stages	Stages complete
7	No post actions	post block missing	Pipeline ends
8	Pipeline ends	end of pipeline block	Pipeline execution finished

💡 Pipeline completes after all stages and steps run successfully.

Status Tracker

Variable	Start	After Step 2	After Step 5	Final
pipeline	undefined	defined	defined	defined
agent	undefined	any	any	any
stages	undefined	defined	defined	defined
stage 'Build'	undefined	undefined	executing	executed

Key Moments - 3 Insights

Why do we need to specify an agent in the pipeline?

The agent tells Jenkins where to run the pipeline. Without it, Jenkins doesn't know which machine or environment to use. See step 2 in the execution table where 'agent any' means it can run anywhere.

What happens if we forget to put steps inside a stage?

Stages need steps to do work. Without steps, the stage runs but does nothing. In the execution table, step 5 shows the steps block running the echo command. Without it, no action happens.

Can the pipeline run without stages?

No, stages organize the pipeline work. The pipeline block requires stages to define tasks. Step 3 shows entering stages block; without it, the pipeline has no tasks to run.

Visual Quiz - 3 Questions

Look at the execution table, what is the agent value after step 2?

A none

B any

C undefined

D agent not set

💡 Hint

Check the 'agent' row in variable_tracker after Step 2.

At which step does the pipeline print 'Building...'?

A Step 4

B Step 6

C Step 5

D Step 3

💡 Hint

Look at the 'Execute steps in Build' action in the execution_table.

If we add a post block, at which step would it execute?

A After Step 6

B Before Step 4

C After Step 7

D At Step 2

💡 Hint

Post actions run after all stages complete, see step 6 and 7 in execution_table.

Concept Snapshot

Declarative pipeline syntax:
pipeline {
  agent any
  stages {
    stage('Name') {
      steps { ... }
    }
  }
  post { ... }
}
- agent defines where to run
- stages contain ordered tasks
- steps are commands inside stages
- post runs after stages finish

Full Transcript

The declarative pipeline in Jenkins starts with a pipeline block that defines the whole process. Inside, an agent is specified to tell Jenkins where to run the pipeline. Then stages are defined, each with a name and steps that perform actions. For example, a 'Build' stage can have steps that print messages or run commands. After all stages run, optional post actions can execute for cleanup or notifications. The pipeline ends after all these steps complete. This flow ensures Jenkins knows what to do, where, and in what order.

Practice

1. Which block is mandatory to start a Jenkins declarative pipeline?

easy

A. stage

B. agent

C. steps

D. pipeline

Solution

1. Step 1: Understand the pipeline structure

   The pipeline block is the root block that wraps the entire declarative pipeline script.

2. Step 2: Identify mandatory blocks

   While agent, stages, and steps are important, the pipeline block is always required to define the pipeline.

3. Final Answer:

   <code>pipeline</code> -> Option D

4. Quick Check:

   Root block = pipeline [OK]

Hint: Look for the root block that wraps everything [OK]

Common Mistakes:

• Confusing stage as root block
• Thinking steps is the top block
• Assuming agent is mandatory alone

2. Which of the following is the correct syntax to define an agent that runs on any available node?

easy

A. agent any

B. agent: any

C. agent { any }

D. agent = any

Solution

1. Step 1: Recall agent syntax in declarative pipeline

   The correct syntax to specify an agent that runs on any available node is agent any without punctuation.

2. Step 2: Check other options for syntax errors

   Options with colons, braces, or equals signs are invalid in declarative pipeline syntax for agent.

3. Final Answer:

   agent any -> Option A

4. Quick Check:

   Agent syntax is simple: agent any [OK]

Hint: Remember: no punctuation, just 'agent any' [OK]

Common Mistakes:

• Adding colons or braces around 'any'
• Using equals sign instead of space
• Confusing scripted pipeline syntax

3. What will be the output of this Jenkins declarative pipeline snippet?

pipeline {
  agent any
  stages {
    stage('Hello') {
      steps {
        echo 'Hello World'
      }
    }
  }
}

medium

A. Fails because 'echo' is not allowed in declarative pipeline

B. Prints 'Hello World' in the build log

C. Pipeline runs but no output is shown

D. Syntax error due to missing agent label

Solution

1. Step 1: Analyze the pipeline structure

   The pipeline has a valid agent any, one stage named 'Hello', and a step that echoes 'Hello World'.

2. Step 2: Understand the echo step behavior

   The echo step prints the given message to the Jenkins build log during execution.

3. Final Answer:

   Prints 'Hello World' in the build log -> Option B

4. Quick Check:

   echo prints message to log [OK]

Hint: echo always prints text to Jenkins console [OK]

Common Mistakes:

• Thinking echo is disallowed in declarative pipelines
• Assuming missing agent label causes error here
• Believing pipeline runs silently without output

4. Identify the error in this declarative pipeline snippet:

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        sh 'make build'
      }
    }
  }
  steps {
    echo 'Done'
  }
}

medium

A. The sh command is invalid in declarative pipeline

B. Missing agent block

C. The steps block is misplaced outside stage

D. The stage block must be outside stages

Solution

1. Step 1: Review pipeline block structure

   In declarative pipelines, steps must be inside a stage block, which is inside stages.

2. Step 2: Locate the misplaced steps block

   The steps block with echo 'Done' is incorrectly placed directly under pipeline, outside any stage.

3. Final Answer:

   The <code>steps</code> block is misplaced outside <code>stage</code> -> Option C

4. Quick Check:

   steps must be inside stage [OK]

Hint: steps always go inside a stage block [OK]

Common Mistakes:

• Placing steps directly under pipeline
• Confusing agent placement
• Thinking sh is invalid in declarative pipelines

5. You want to run two stages in parallel in a declarative pipeline. Which snippet correctly defines parallel stages?

hard

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

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

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

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

Solution

1. Step 1: Understand parallel syntax in declarative pipeline

   Parallel stages must be nested inside a stage block using the parallel block.

2. Step 2: Check each option for correct structure

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

   correctly places parallel inside a stage named 'Parallel' with nested stages 'Test' and 'Build'. Other options place parallel incorrectly or omit it.

3. Final Answer:

   Option A with parallel inside a stage block -> Option A

4. Quick Check:

   parallel inside stage block = correct [OK]

Hint: Parallel block must be inside a stage block [OK]

Common Mistakes:

• Placing parallel directly under stages
• Omitting the parallel block
• Placing parallel outside pipeline