Creating reusable pipeline steps in Jenkins - Step-by-Step CLI Walkthrough

Introduction

When building automation pipelines, repeating the same steps wastes time and causes errors. Reusable pipeline steps let you write a task once and use it many times, making your pipelines cleaner and easier to maintain.

When you have multiple pipelines that need to run the same tests or build commands.

When you want to share deployment steps across different projects without copying code.

When you want to update a common step in one place and have all pipelines use the new version.

When you want to simplify your Jenkinsfile by moving complex logic into reusable functions.

When you want to enforce consistent steps like code quality checks across all pipelines.

Config File - Jenkinsfile

Jenkinsfile

def call(String name) {
    echo "Hello, ${name}! This is a reusable step."
}

pipeline {
    agent any
    stages {
        stage('Example') {
            steps {
                script {
                    call('Developer')
                }
            }
        }
    }
}

This Jenkinsfile defines a reusable step as a function named call that takes a name and prints a greeting. The pipeline block uses this step inside the Example stage by calling call('Developer'). This shows how to write and use a simple reusable step within the same Jenkinsfile.

Commands

This command uploads or updates the Jenkinsfile in the Jenkins server to apply the reusable step pipeline.

Terminal

jenkins-jobs --conf jenkins.ini update Jenkinsfile

Expected Output

Job updated successfully

This command triggers the Jenkins pipeline named 'my-pipeline' to run the Jenkinsfile with the reusable step.

Terminal

jenkins build my-pipeline

Expected Output

[Pipeline] Start of Pipeline

[Pipeline] stage

[Pipeline] { (Example)

[Pipeline] script

[Pipeline] echo

Hello, Developer! This is a reusable step.

[Pipeline] }

[Pipeline] // stage

[Pipeline] End of Pipeline

Finished: SUCCESS

This command shows the console output of the last run of 'my-pipeline' to verify the reusable step executed correctly.

Terminal

jenkins console my-pipeline

Expected Output

Started by user admin

Running in Durability level: MAX_SURVIVABILITY

[Pipeline] Start of Pipeline

[Pipeline] stage

[Pipeline] { (Example)

[Pipeline] script

[Pipeline] echo

Hello, Developer! This is a reusable step.

[Pipeline] }

[Pipeline] // stage

[Pipeline] End of Pipeline

Finished: SUCCESS

Key Concept

If you remember nothing else from this pattern, remember: reusable pipeline steps let you write a task once and call it many times to keep your pipelines simple and consistent.

Common Mistakes

Defining reusable steps outside of a function or without parameters.

This causes Jenkins to not recognize the step as reusable or flexible, limiting reuse.

Always define reusable steps as functions with parameters to customize behavior.

Copy-pasting the same code block in multiple pipeline stages instead of calling a reusable step.

This leads to duplicated code that is hard to maintain and update.

Extract common code into a reusable step function and call it where needed.

Not testing the reusable step independently before using it in pipelines.

Errors in the reusable step can cause multiple pipelines to fail.

Test reusable steps in a simple pipeline first to ensure they work correctly.

Summary

Define reusable pipeline steps as functions with parameters inside your Jenkinsfile.

Call these functions in pipeline stages to avoid repeating code.

Run and verify your pipeline to ensure the reusable steps execute as expected.

Practice

1. What is the main benefit of creating reusable pipeline steps in Jenkins?

easy

A. It automatically fixes syntax errors.

B. It makes the pipeline run faster.

C. It reduces code duplication and simplifies maintenance.

D. It disables pipeline notifications.

Solution

1. Step 1: Understand the purpose of reusable steps

   Reusable steps are designed to avoid repeating the same code multiple times in pipelines.

2. Step 2: Identify the main advantage

   By reusing code, maintenance becomes easier because changes are made in one place, reducing errors and effort.

3. Final Answer:

   It reduces code duplication and simplifies maintenance. -> Option C

4. Quick Check:

   Reusable steps = less duplication [OK]

Hint: Think about saving time and effort by reusing code [OK]

Common Mistakes:

• Confusing speed improvement with code reuse
• Assuming reusable steps fix errors automatically
• Believing reusable steps control notifications

2. Which syntax correctly defines a reusable step named buildApp in a Jenkins pipeline?

easy

A. def buildApp() { echo 'Building app...' }

B. buildApp() { echo 'Building app...' }

C. function buildApp { echo 'Building app...' }

D. step buildApp() { echo 'Building app...' }

Solution

1. Step 1: Recall Groovy function syntax in Jenkins

   Reusable steps are defined as Groovy functions using the def keyword followed by the function name and parentheses.

2. Step 2: Match the correct syntax

   def buildApp() { echo 'Building app...' } uses def buildApp() { ... } which is the correct Groovy function definition.

3. Final Answer:

   def buildApp() { echo 'Building app...' } -> Option A

4. Quick Check:

   Groovy functions start with def [OK]

Hint: Look for 'def' keyword to define functions in Jenkinsfile [OK]

Common Mistakes:

• Omitting 'def' keyword
• Using JavaScript or shell syntax
• Using unsupported keywords like 'step' or 'function'

3. Given the reusable step below, what will be the output when calling buildApp('Test')?

def buildApp(String env) {
  echo "Building for ${env} environment"
}

pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        script {
          buildApp('Test')
        }
      }
    }
  }
}

medium

A. No output

B. Building for Test environment

C. Error: Missing parameter

D. Building for env environment

Solution

1. Step 1: Understand the function call with parameter

   The function buildApp takes a string parameter env and prints a message including it.

2. Step 2: Substitute the parameter value

   Calling buildApp('Test') replaces ${env} with 'Test', so the output is 'Building for Test environment'.

3. Final Answer:

   Building for Test environment -> Option B

4. Quick Check:

   Parameter substitution = correct output [OK]

Hint: Replace variables with passed arguments to find output [OK]

Common Mistakes:

• Ignoring parameter substitution
• Assuming default or missing parameter error
• Thinking no output occurs without explicit return

4. Identify the error in this reusable step definition:

def deployApp(env) {
  echo "Deploying to ${environment}"
}

pipeline {
  agent any
  stages {
    stage('Deploy') {
      steps {
        script {
          deployApp('production')
        }
      }
    }
  }
}

medium

A. Parameter name mismatch: 'env' vs 'environment' inside echo

B. Missing 'def' keyword before function name

C. Incorrect pipeline syntax: missing agent label

D. Function call missing parentheses

Solution

1. Step 1: Check parameter usage inside function

   The function defines parameter env but uses ${environment} inside the echo, which is undefined.

2. Step 2: Identify the mismatch causing error

   This mismatch causes a runtime error because environment is not declared or passed.

3. Final Answer:

   Parameter name mismatch: 'env' vs 'environment' inside echo -> Option A

4. Quick Check:

   Parameter names must match exactly [OK]

Hint: Match parameter names exactly inside function body [OK]

Common Mistakes:

• Using different variable names inside function
• Omitting 'def' keyword (not the issue here)
• Incorrect pipeline syntax unrelated to function

5. You want to create a reusable step notifyBuild that sends different messages based on build status. Which code snippet correctly implements this using parameters and conditional logic?

hard

A. def notifyBuild(String status) {
match (status) {
'SUCCESS' -> echo 'Build succeeded!'
'FAILURE' -> echo 'Build failed!'
}
}

B. def notifyBuild(status) {
switch (status) {
case 'SUCCESS': echo 'Build succeeded!'
case 'FAILURE': echo 'Build failed!'
}
}

C. def notifyBuild(String status) {
if status = 'SUCCESS' {
echo 'Build succeeded!'
} else {
echo 'Build failed!'
}
}

D. def notifyBuild(String status) {
if (status == 'SUCCESS') {
echo 'Build succeeded!'
} else {
echo 'Build failed!'
}
}

Solution

1. Step 1: Review correct Groovy conditional syntax

   Groovy uses if (condition) { ... } with double equals == for comparison.

2. Step 2: Analyze each option

   def notifyBuild(String status) { if (status == 'SUCCESS') { echo 'Build succeeded!' } else { echo 'Build failed!' } } uses correct parameter typing, if-else structure, and comparison operator.
   def notifyBuild(status) { switch (status) { case 'SUCCESS': echo 'Build succeeded!' case 'FAILURE': echo 'Build failed!' } } misses breaks in switch, causing fall-through.
   def notifyBuild(String status) { match (status) { 'SUCCESS' -> echo 'Build succeeded!' 'FAILURE' -> echo 'Build failed!' } } uses invalid 'match' syntax in Groovy.
   def notifyBuild(String status) { if status = 'SUCCESS' { echo 'Build succeeded!' } else { echo 'Build failed!' } } uses single equals = instead of == in if condition, causing assignment error.

3. Final Answer:

   def notifyBuild(String status) { if (status == 'SUCCESS') { echo 'Build succeeded!' } else { echo 'Build failed!' } } -> Option D

4. Quick Check:

   Use if (condition == value) for Groovy conditionals [OK]

Hint: Use if with double equals (==) for conditions in Groovy [OK]

Common Mistakes:

• Using single equals (=) instead of double (==) in conditions
• Using unsupported 'match' syntax
• Missing breaks in switch causing fall-through