Why scripted pipelines offer flexibility in Jenkins - Visual Breakdown

Process Flow - Why scripted pipelines offer flexibility

Start Pipeline

↓

Execute Scripted Pipeline

↓

Use Groovy Code

↓

Add Conditions, Loops, Variables

↓

Control Flow Dynamically

↓

Flexible Build Steps

↓

Pipeline Ends

Scripted pipelines run Groovy code step-by-step, allowing dynamic decisions and flexible build steps.

Execution Sample

Jenkins

node {
  if (env.BRANCH_NAME == 'main') {
    echo 'Deploying to production'
  } else {
    echo 'Deploying to staging'
  }
}

This scripted pipeline checks the branch name and prints a message accordingly.

Process Table

Step	Condition Checked	Condition Result	Action Taken	Output
1	env.BRANCH_NAME == 'main'	True	echo 'Deploying to production'	Deploying to production
2	End of script	N/A	Pipeline ends	N/A

💡 Script ends after executing the matching branch condition.

Status Tracker

Variable	Start	After Step 1	Final
env.BRANCH_NAME	main	main	main

Key Moments - 2 Insights

Why can we use if-else conditions in scripted pipelines?

Because scripted pipelines run Groovy code, they allow normal programming constructs like if-else, as shown in step 1 of the execution table.

What happens if the branch name is not 'main'?

The else block runs, printing 'Deploying to staging'. This flexibility comes from using code logic, not fixed steps.

Visual Quiz - 3 Questions

Look at the execution table, what is printed when env.BRANCH_NAME is 'main'?

A Deploying to production

B Deploying to staging

C No output

D Error message

💡 Hint

Check Step 1 output in the execution table.

At which step does the pipeline finish execution?

A Step 1

B Step 3

C Step 2

D It never ends

💡 Hint

Look at the exit note and Step 2 in the execution table.

If we add a loop inside the scripted pipeline, what changes in the execution?

A The output stays the same

B More steps appear in the execution table showing each loop iteration

C The pipeline stops immediately

D The pipeline ignores the loop

💡 Hint

Scripted pipelines allow loops, so execution steps increase accordingly.

Concept Snapshot

Scripted pipelines use Groovy code for builds.
They allow conditions, loops, and variables.
This makes pipelines flexible and dynamic.
You control flow with normal programming logic.
Great for complex build scenarios.

Full Transcript

Scripted pipelines in Jenkins run Groovy code step-by-step. This lets you use programming features like if-else conditions and loops. For example, you can check the branch name and decide what to do next. This flexibility means you can create dynamic build flows that change based on variables or environment. The execution table shows how the pipeline checks the branch and prints a message accordingly. Variables like env.BRANCH_NAME keep their values during execution. Beginners often wonder why scripted pipelines allow if-else; it's because they run real code. Also, if the branch is not 'main', the else block runs, showing flexibility. Adding loops would add more steps to the execution, showing each iteration. This makes scripted pipelines powerful for complex tasks.

Practice

1. Why do scripted pipelines in Jenkins offer more flexibility compared to declarative pipelines?

easy

A. Because they only support predefined stages without customization.

B. Because they have a simpler syntax with fewer features.

C. Because they allow using loops, conditions, and custom error handling.

D. Because they automatically generate pipeline code without user input.

Solution

1. Step 1: Understand scripted pipeline features

   Scripted pipelines allow writing code with loops, conditions, and error handling, giving more control.

2. Step 2: Compare with declarative pipelines

   Declarative pipelines have a simpler, fixed structure and less flexibility for complex logic.

3. Final Answer:

   Because they allow using loops, conditions, and custom error handling. -> Option C

4. Quick Check:

   Scripted pipelines = flexible code control [OK]

Hint: Look for options mentioning loops and conditions for flexibility [OK]

Common Mistakes:

• Confusing simplicity with flexibility
• Thinking declarative pipelines allow all custom code
• Assuming scripted pipelines auto-generate code

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

easy

A. node {

B. stage {

C. pipeline {

D. scripted {

Solution

1. Step 1: Identify scripted pipeline block syntax

   Scripted pipelines start with node { to define the workspace and steps.

2. Step 2: Eliminate other options

   pipeline { is for declarative pipelines; stage { defines a stage; scripted { is invalid syntax.

3. Final Answer:

   node { -> Option A

4. Quick Check:

   Scripted pipeline starts with node block [OK]

Hint: Scripted pipelines start with 'node {' block [OK]

Common Mistakes:

• Using 'pipeline {' which is declarative syntax
• Confusing 'stage {' as pipeline start
• Assuming 'scripted {' is valid 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: 0\nCount: 1\nCount: 2

C. Syntax error due to for loop

D. No output because echo is invalid

Solution

1. Step 1: Analyze the for loop range

   The loop runs from i=1 to i=3 inclusive, so it iterates 3 times.

2. Step 2: Check the echo output each iteration

   Each iteration prints "Count: " followed by the current i value, producing lines for 1, 2, and 3.

3. Final Answer:

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

4. Quick Check:

   Loop 1 to 3 prints counts 1,2,3 [OK]

Hint: Check loop start and end values carefully [OK]

Common Mistakes:

• Starting loop at 0 instead of 1
• Thinking echo is invalid in scripted pipeline
• Assuming syntax error in for loop

4. Identify the error in this scripted pipeline snippet:

node {
  if (env.BRANCH_NAME == 'main')
    echo 'Deploying to production'
  else
    echo 'Deploying to staging'
}

medium

A. node block cannot contain if statements

B. Missing curly braces {} around if and else blocks

C. echo command cannot be used inside if

D. Incorrect use of env variable syntax

Solution

1. Step 1: Check if-else syntax in scripted pipeline

   In scripted pipelines, if and else blocks must use curly braces {} when spanning multiple lines or statements.

2. Step 2: Identify missing braces

   The snippet lacks braces around the echo statements, which can cause syntax errors or unexpected behavior.

3. Final Answer:

   Missing curly braces {} around if and else blocks -> Option B

4. Quick Check:

   If-else blocks need braces in scripted pipelines [OK]

Hint: Always use braces {} for if-else blocks in scripted pipelines [OK]

Common Mistakes:

• Assuming env.BRANCH_NAME syntax is wrong
• Thinking echo can't be inside if
• Believing node block forbids if statements

5. You want to retry a build step up to 3 times if it fails, using a scripted pipeline. Which snippet correctly implements this retry logic?

hard

A. node {
for (int i=0; i<3; i++) {
sh 'run-build.sh'
}
}

B. node {
while (true) {
sh 'run-build.sh'
}
}

C. node {
try {
sh 'run-build.sh'
} catch (err) {
retry(3)
}
}

D. node {
retry(3) {
sh 'run-build.sh'
}
}

Solution

1. Step 1: Understand Jenkins retry step

   The retry(n) { ... } block retries the enclosed steps up to n times on failure automatically.

2. Step 2: Evaluate each option

   node { retry(3) { sh 'run-build.sh' } } correctly uses retry(3) around the build command. node { for (int i=0; i<3; i++) { sh 'run-build.sh' } } runs the command 3 times without retry on failure. node { try { sh 'run-build.sh' } catch (err) { retry(3) } } misuses retry inside catch. node { while (true) { sh 'run-build.sh' } } loops infinitely.

3. Final Answer:

   node { retry(3) { sh 'run-build.sh' } } -> Option D

4. Quick Check:

   Use retry(n) block for automatic retries [OK]

Hint: Use retry(n) block to retry steps automatically [OK]

Common Mistakes:

• Using loops instead of retry block
• Placing retry inside catch block incorrectly
• Creating infinite loops without exit