Why shared libraries reduce duplication in Jenkins - Why It Works

Introduction

When you write Jenkins pipelines, you often repeat the same code in many places. Shared libraries let you write common code once and use it everywhere, saving time and avoiding mistakes.

When multiple Jenkins pipelines need to perform the same steps like building or testing code.

When you want to update a common process in one place instead of changing many pipeline files.

When you want to keep your pipeline scripts clean and easy to read by moving complex logic out.

When your team grows and many people write pipelines that share similar tasks.

When you want to enforce consistent steps across all your Jenkins jobs.

Config File - vars/commonBuild.groovy

vars/commonBuild.groovy

def call(String projectName) {
    echo "Building project: ${projectName}"
    // Add build steps here
    sh 'echo Compiling source code'
    sh 'echo Running tests'
    echo "Build complete for ${projectName}"
}

This file defines a shared library function named commonBuild. It takes a project name and runs common build steps like compiling and testing. Pipelines can call this function to reuse the same build logic.

Commands

Create the directory structure for the shared library inside Jenkins home.

Terminal

mkdir -p ~/.jenkins/shared-libraries/commonBuild/vars

Expected Output

No output (command runs silently)

Create the shared library Groovy script with common build steps.

Terminal

echo 'def call(String projectName) {\n    echo "Building project: ${projectName}"\n    sh "echo Compiling source code"\n    sh "echo Running tests"\n    echo "Build complete for ${projectName}"\n}' > ~/.jenkins/shared-libraries/commonBuild/vars/commonBuild.groovy

Expected Output

No output (command runs silently)

Install the Jenkins plugin that supports global shared libraries.

Terminal

jenkins-cli.jar -s http://localhost:8080 install-plugin workflow-cps-global-lib

Expected Output

Installing workflow-cps-global-lib plugin...

Success

Configure Jenkins to use the shared library from a Git repository as a global library.

Terminal

jenkins-cli.jar -s http://localhost:8080 groovy = <<EOF
import jenkins.model.*
import org.jenkinsci.plugins.workflow.libs.*
import jenkins.plugins.git.GitSCMSource
import org.jenkinsci.plugins.workflow.libs.SCMSourceRetriever

GlobalLibraries libraries = GlobalLibraries.get()
LibraryConfiguration libConfig = new LibraryConfiguration('commonBuild')
libConfig.setDefaultVersion('master')
libConfig.setImplicit(true)
libConfig.setRetriever(new SCMSourceRetriever(new GitSCMSource(null, 'https://github.com/example/commonBuild.git', '', '*', '', false)))
libraries.getLibraries().add(libConfig)
Jenkins.instance.save()
EOF

Expected Output

No output (command runs silently)

Create a Jenkins pipeline script that calls the shared library function to build the project.

Terminal

echo 'pipeline {\n  agent any\n  stages {\n    stage("Build") {\n      steps {\n        commonBuild("my-app")\n      }\n    }\n  }\n}' > Jenkinsfile

Expected Output

No output (command runs silently)

Trigger the Jenkins pipeline job that uses the shared library to run the build.

Terminal

jenkins-cli.jar -s http://localhost:8080 build my-pipeline

Expected Output

[Pipeline] Start of Pipeline

[Pipeline] echo

Building project: my-app

[Pipeline] sh

+ echo Compiling source code

Compiling source code

[Pipeline] sh

+ echo Running tests

Running tests

[Pipeline] echo

Build complete for my-app

[Pipeline] End of Pipeline

Finished: SUCCESS

Key Concept

Shared libraries let you write common pipeline code once and reuse it everywhere, reducing repetition and mistakes.

Common Mistakes

Writing the same build steps in every Jenkinsfile instead of using a shared library.

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

Put common steps in a shared library function and call it from pipelines.

Not configuring the shared library correctly in Jenkins global settings.

Pipelines will fail because Jenkins cannot find the shared library code.

Set up the shared library in Jenkins configuration with the correct repository and name.

Forgetting to commit and push the shared library code to the Git repository.

Jenkins will use an empty or outdated library version, causing errors or missing steps.

Always commit and push changes to the shared library repo before running pipelines.

Summary

Create a shared library Groovy script with common pipeline steps.

Configure Jenkins to use the shared library globally from a Git repo.

Call the shared library function in Jenkins pipelines to reuse code.

Trigger pipelines to run the shared build steps without duplication.

Practice

1. Why do Jenkins shared libraries help reduce duplication in pipelines?

easy

A. They let you reuse common code across multiple pipelines.

B. They automatically fix errors in your pipeline scripts.

C. They run pipelines faster by caching results.

D. They replace the need for Jenkins agents.

Solution

1. Step 1: Understand what duplication means in Jenkins pipelines

   Duplication means copying the same code in many pipeline scripts, which wastes time and can cause errors.

2. Step 2: Identify how shared libraries help

   Shared libraries store common code in one place, so pipelines can reuse it without copying.

3. Final Answer:

   They let you reuse common code across multiple pipelines. -> Option A

4. Quick Check:

   Reuse code = reduce duplication [OK]

Hint: Shared libraries store reusable code to avoid copy-paste [OK]

Common Mistakes:

• Thinking shared libraries fix errors automatically
• Believing they speed up pipeline execution
• Confusing shared libraries with Jenkins agents

2. Which is the correct syntax to load a shared library in a Jenkins pipeline script?

easy

A. import sharedLib from 'my-shared-lib'

B. loadLibrary('my-shared-lib')

C. library 'my-shared-lib'

D. @SharedLibrary('my-shared-lib')

Solution

1. Step 1: Recall Jenkins syntax for loading shared libraries

   Jenkins uses the library 'name' step to load shared libraries in pipeline scripts.

2. Step 2: Compare options to correct syntax

   Only library 'my-shared-lib' matches the official syntax; others are incorrect or invalid.

3. Final Answer:

   library 'my-shared-lib' -> Option C

4. Quick Check:

   library 'name' loads shared library [OK]

Hint: Use library 'name' to load shared libraries [OK]

Common Mistakes:

• Using loadLibrary() which is not a Jenkins step
• Confusing annotation syntax with @Library
• Trying to import like a programming language

3. Given this Jenkins pipeline snippet using a shared library:

library 'utils'

pipeline {
  agent any
  stages {
    stage('Test') {
      steps {
        script {
          def result = utils.calculateSum(2, 3)
          echo "Sum is ${result}"
        }
      }
    }
  }
}

What will be the output if calculateSum returns the sum of two numbers?

medium

A. Sum is 5

B. Sum is 23

C. Sum is utils.calculateSum(2, 3)

D. Error: calculateSum not found

Solution

1. Step 1: Understand the shared library usage

   The library 'utils' is loaded, so its functions like calculateSum are available.

2. Step 2: Evaluate the function call and output

   calculateSum(2, 3) returns 5, so echo prints "Sum is 5".

3. Final Answer:

   Sum is 5 -> Option A

4. Quick Check:

   Function call returns 5, echoed output matches [OK]

Hint: Function returns sum, echo prints it directly [OK]

Common Mistakes:

• Concatenating numbers as strings (23)
• Printing function call text instead of result
• Forgetting to load the shared library

4. You wrote this Jenkins pipeline snippet:

@Library('common-lib') _
pipeline {
  agent any
  stages {
    stage('Build') {
      steps {
        script {
          commonLib.buildApp()
        }
      }
    }
  }
}

But Jenkins reports: groovy.lang.MissingPropertyException: No such property: commonLib. What is the likely cause?

medium

A. The library name 'common-lib' is incorrect or not configured.

B. You must assign the library to a variable to use it like commonLib.

C. You forgot to add the underscore after @Library annotation.

D. Shared libraries cannot be used inside script blocks.

Solution

1. Step 1: Understand @Library usage with variable assignment

   When using @Library('name') without assignment, library classes are imported globally, but to use a variable like commonLib, you must assign it.

2. Step 2: Identify the error cause

   The error says commonLib is missing, meaning the library was not assigned to that variable.

3. Final Answer:

   You must assign the library to a variable to use it like commonLib. -> Option B

4. Quick Check:

   Assign library to variable to call methods [OK]

Hint: Assign library to variable to call methods [OK]

Common Mistakes:

• Assuming library auto-creates variables
• Thinking underscore fixes variable issues
• Believing shared libraries can't be used in script blocks

5. You have multiple Jenkins pipelines that all use the same code to send notifications and run tests. How does using a shared library improve your setup?

medium

A. It duplicates the code in each pipeline for faster execution.

B. It lets each pipeline run notifications and tests in parallel automatically.

C. It removes the need to write any pipeline scripts at all.

D. It centralizes notification and test code, so updates apply everywhere automatically.

Solution

1. Step 1: Identify the problem with duplicated code

   Having the same notification and test code copied in many pipelines causes maintenance issues.

2. Step 2: Explain how shared libraries solve this

   Shared libraries keep this code in one place, so changing it once updates all pipelines using it.

3. Final Answer:

   It centralizes notification and test code, so updates apply everywhere automatically. -> Option D

4. Quick Check:

   Central code means easier updates and less duplication [OK]

Hint: Centralize common code to update once for all pipelines [OK]

Common Mistakes:

• Thinking shared libraries run steps in parallel
• Believing shared libraries remove all scripting
• Assuming shared libraries duplicate code instead of reusing