When to use scripted over declarative in Jenkins - Mini Project: Build & Apply

When to Use Scripted Over Declarative in Jenkins Pipelines

📖 Scenario: You are a DevOps engineer working on automating software builds and deployments using Jenkins. Jenkins supports two main ways to write pipelines: scripted and declarative. Understanding when to use scripted pipelines instead of declarative ones helps you handle complex automation tasks effectively.

🎯 Goal: Learn to create a simple Jenkins scripted pipeline that includes a conditional step, showing when scripted pipelines are preferred over declarative pipelines.

📋 What You'll Learn

Create a Jenkins scripted pipeline with a map of build stages

Add a configuration variable to control which stages run

Use a for loop to iterate over stages and run selected ones

Print the names of the stages that are executed

💡 Why This Matters

🌍 Real World

Jenkins pipelines automate software build, test, and deployment tasks. Scripted pipelines are used when automation needs complex logic beyond simple linear steps.

💼 Career

DevOps engineers and automation specialists use scripted pipelines to create flexible CI/CD workflows that adapt to changing project requirements.

1

Create a map of build stages

Create a variable called buildStages as a map with these exact entries: 'Build': 'Compile code', 'Test': 'Run unit tests', 'Deploy': 'Deploy to staging'

Jenkins

# Create the buildStages map with exact entries
# Your code here

Hint

Use Groovy map syntax with keys and values inside square brackets.

2

Add a configuration variable to select stages

Create a variable called stagesToRun as a list containing the exact strings 'Build' and 'Test'

Jenkins

def buildStages = ['Build': 'Compile code', 'Test': 'Run unit tests', 'Deploy': 'Deploy to staging']
# Create stagesToRun list with 'Build' and 'Test'
# Your code here

Hint

Use Groovy list syntax with square brackets and comma-separated strings.

3

Use a for loop to run selected stages

Write a for loop with variable stageName to iterate over buildStages.keySet(). Inside the loop, use an if statement to check if stageName is in stagesToRun. If yes, print "Running stage: " + stageName

Jenkins

def buildStages = ['Build': 'Compile code', 'Test': 'Run unit tests', 'Deploy': 'Deploy to staging']
def stagesToRun = ['Build', 'Test']
# Use for loop to iterate buildStages.keySet() and print running stages
# Your code here

Hint

Use Groovy for loop and contains() method on list.

4

Print the executed stages

Add a print statement that outputs exactly "Running stage: Build" and "Running stage: Test" when the script runs

Jenkins

def buildStages = ['Build': 'Compile code', 'Test': 'Run unit tests', 'Deploy': 'Deploy to staging']
def stagesToRun = ['Build', 'Test']
for (stageName in buildStages.keySet()) {
    if (stagesToRun.contains(stageName)) {
        println("Running stage: " + stageName)
    }
}
# Run the script to see output

Hint

Run the script and check the console output matches the expected lines.

Practice

1. Which situation is best suited for using a scripted Jenkins pipeline instead of a declarative one?

easy

A. When you want to use built-in syntax for parallel stages only

B. When you want a simple, easy-to-read pipeline with fixed stages

C. When you need complex loops and conditional logic that declarative can't handle

D. When you want to avoid writing any Groovy code

Solution

1. Step 1: Understand pipeline types

   Declarative pipelines are simpler and use a fixed syntax, while scripted pipelines allow full Groovy code control.

2. Step 2: Match use case to pipeline type

   Complex loops and dynamic conditions require scripted pipelines because declarative syntax is limited.

3. Final Answer:

   When you need complex loops and conditional logic that declarative can't handle -> Option C

4. Quick Check:

   Complex logic = scripted [OK]

Hint: Choose scripted for complex logic, declarative for simple flow [OK]

Common Mistakes:

• Thinking declarative supports all Groovy features
• Using scripted for simple pipelines unnecessarily
• Confusing parallel stage support as exclusive to scripted

2. Which of the following is the correct way to start a scripted pipeline in Jenkins?

easy

A. node { stage('Build') { echo 'Hello' } }

B. pipeline { agent any; stages { stage('Build') { steps { echo 'Hello' } } } }

C. stages { stage('Build') { steps { echo 'Hello' } } }

D. build { stage('Build') { echo 'Hello' } }

Solution

1. Step 1: Identify scripted pipeline syntax

   Scripted pipelines use Groovy code inside a node block, not the pipeline block.

2. Step 2: Check each option

   node { stage('Build') { echo 'Hello' } } uses node { stage('Build') { echo 'Hello' } } which is correct scripted syntax.

3. Final Answer:

   node { stage('Build') { echo 'Hello' } } -> Option A

4. Quick Check:

   Scripted pipelines start with node block [OK]

Hint: Scripted pipelines start with node block, declarative with pipeline [OK]

Common Mistakes:

• Using declarative pipeline syntax for scripted pipelines
• Omitting the node block in scripted pipelines
• Confusing stages block as scripted syntax

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

node {
  for (int i = 1; i <= 3; i++) {
    echo "Count: ${i}"
  }
}

medium

A. Count: 1\nCount: 2\nCount: 3

B. Count: 3

C. Syntax error due to for loop

D. No output because echo is invalid here

Solution

1. Step 1: Understand scripted pipeline loop

   The for loop runs from 1 to 3, printing each count with echo.

2. Step 2: Predict output

   Each iteration prints "Count: 1", "Count: 2", and "Count: 3" on separate lines.

3. Final Answer:

   Count: 1\nCount: 2\nCount: 3 -> Option A

4. Quick Check:

   Loop prints each count line [OK]

Hint: For loops in scripted pipelines print each iteration output [OK]

Common Mistakes:

• Assuming only last iteration prints
• Thinking for loop syntax is invalid in scripted
• Believing echo cannot be used inside node

4. Identify the error in this scripted pipeline snippet:

node {
  stage('Build') {
    echo 'Building...'
  }
  stage('Test')
    echo 'Testing...'
}

medium

A. stage keyword cannot be used in scripted pipelines

B. Incorrect use of echo command inside node

C. node block must be inside stage blocks

D. Missing braces {} around the 'Test' stage block

Solution

1. Step 1: Check stage syntax in scripted pipeline

   Each stage block must have braces {} to group its commands.

2. Step 2: Identify missing braces

   The 'Test' stage lacks braces around echo, causing syntax error.

3. Final Answer:

   Missing braces {} around the 'Test' stage block -> Option D

4. Quick Check:

   All stage blocks need braces in scripted [OK]

Hint: Always use braces {} for stage blocks in scripted pipelines [OK]

Common Mistakes:

• Omitting braces for single commands in stages
• Thinking stage keyword is invalid in scripted
• Misplacing node and stage blocks

5. You want to create a Jenkins pipeline that dynamically creates stages based on a list of environments (dev, test, prod). Which pipeline type should you use and why?

hard

A. Declarative pipeline, because it supports dynamic stage creation easily

B. Scripted pipeline, because it allows loops and dynamic stage generation with Groovy

C. Declarative pipeline, because scripted pipelines cannot handle multiple stages

D. Neither, Jenkins does not support dynamic stages

Solution

1. Step 1: Understand dynamic stage requirements

   Creating stages dynamically requires looping and conditional logic.

2. Step 2: Match pipeline type to dynamic behavior

   Scripted pipelines allow Groovy loops to generate stages dynamically; declarative pipelines are static.

3. Final Answer:

   Scripted pipeline, because it allows loops and dynamic stage generation with Groovy -> Option B

4. Quick Check:

   Dynamic stages = scripted pipeline [OK]

Hint: Use scripted pipelines for dynamic or complex stage creation [OK]

Common Mistakes:

• Assuming declarative supports dynamic stages easily
• Believing scripted pipelines cannot handle multiple stages
• Thinking Jenkins disallows dynamic pipeline structures