Jenkins Shared Library Guidance

Encapsulate functions across Jenkins pipelines using the Jenkins shared library

Introduction

Jenkins library has emerged as a powerful tool in the ecosystem, enabling developers to encapsulate and reuse functions within a library, effortlessly reducing code duplication. Its versatility and effectiveness make it a valuable asset for agile development teams seeking increased efficiency. Imagine the scenario where you need to create a new pipeline for a microservice; traditionally, this requires duplicating and customizing an existing Jenkinsfile. However, with Jenkins library, you can bid farewell to repetitive copy-pasting and opt for a more streamlined approach by simply invoking the necessary functions tailored to your new pipeline.

What’s Jenkins library?

A Jenkins library can contain several functions that you can encapsulate into a library and include in a Jenkinsfile pipeline to reduce duplicate code. you can learn more about it at this link.

Why Use a Jenkins Library?

A Jenkins library is useful for reducing duplicate code and increasing your agility. Let’s suppose you want to create a new pipeline for one of your new microservices. In this case, you would need to copy the content of one of your previous Jenkinsfile and customize it for the new pipeline. However, if you use a Jenkins library, you can avoid copying and pasting all the time. You just need to call the necessary functions for your new pipeline.

How to Create a Jenkins Library?

Creating a Jenkins library is quite easy. You just need to create a Git repository like this:

.
├── .git
├── README.md
├── src
│   └── AddSidebarLinkAction.groovy
└── vars
    └── devops.groovy

As you can see in the above directory structure, I created a devops.groovy file inside the vars directory to contain my functions. Jenkins libraries should be written in Groovy scripts. Below is the content of the /vars/devops.groovy file:

def verifyK8sManifests() {

    sh """
        set -xe;
        cd /tmp; 
        curl -Lk https://github.com/stackrox/kube-linter/releases/download/v0.6.5/kube-linter-linux.tar.gz -O; 
        tar -xvzf kube-linter-linux.tar.gz;
        
        cd -;
        for manifest_file in \$(find . -name '*.yaml'); do
            /tmp/kube-linter lint \${manifest_file}
        done

        echo 'verified'
    """
}

In the aforementioned function, I’ve created an sh block to use Kube-Linter, which is a simple tool for verifying security concerns in my manifest files. I can call this function in the middle of my pipeline to check if there are any security problems with my manifests.

You can find this Jenkins library in the following GitHub repository:

GitHub - mlkmhd/jenkins-shared-library

Using Jenkins library

There are two ways to include and use a Jenkins library inside a Jenkinsfile. In the following sections, I’ll describe how you can use a Jenkins library:

1. Using the Library Directive

The first method involves using the library directive. You can include a Jenkins library like this:

library identifier: 'jenkinslib@master', retriever: modernSCM([
    $class: 'GitSCMSource',
    credentialsId: 'devops-creds',
    remote: 'https://github.com/mlkmhd/jenkins-shared-library.git'
])

pipeline {
    
    agent any
    
    stages {

        stage('test1') {

            steps {
                
                script {

                    dir("${buildOutputDir}") {
                        devops.verifyK8sManifests();
                    }
                }
            }
        }
    }
}

As you can see in the above simple pipeline, I included the Jenkins library using the library directive. This requires specifying your Git repository address and credentials to clone it before your pipeline execution. I called my function using devops.verifyK8sManifests(). Here, devops refers to the name of your script file (in my case, it's devops.groovy), and within that file, I have a function called verifyK8sManifests().

2. Using the Jenkins Admin Dashboard

There’s another way to include a function in your Jenkinsfile without the need for explicit inclusion. You need to navigate to Dashboard -> Manage Jenkins -> Configure System -> Global Pipeline Libraries and add the library like this:

As shown in the image above, I’ve added my Jenkins library to the Jenkins admin dashboard, enabling its inclusion within the Jenkinsfile. An important option in the above image is Load implicitly. When this option is selected, there is no need to explicitly include the Jenkins library in your Jenkinsfile. Jenkins will automatically load the library in all your pipelines without the need for manual inclusion. Consequently, you can modify the Jenkinsfile as follows (without needing to include library implicitly):

pipeline {
    
    agent any
    
    stages {

        stage('test1') {

            steps {
                
                script {

                    dir("${buildOutputDir}") {
                        devops.verifyK8sManifests();
                    }
                }
            }
        }
    }
}

As you can see in the content above, I did not include any library directives because the library will be included automatically when the pipeline executes.

Conclusion

Harnessing the power of Jenkins library fuels productivity gains by minimizing code repetition and enhancing development agility. It facilitates the creation of streamlined and maintainable pipelines, ultimately enabling teams to focus on delivering quality software. By adopting either the explicit library directive or leveraging the implicit loading capability, developers can seamlessly integrate Jenkins library into their workflows and enjoy the benefits it brings to their CI/CD processes.

Support My Blog ☕️

If you enjoy my technical blog posts and find them valuable, please consider buying me a coffee at here. Your support goes a long way in helping me produce more quality articles and content. If you have any feedback or suggestions for improving my code, please leave a comment on this post or send me a message on my LinkedIn.