Can I "import" the stages in a Jenkins Declarative pipeline

Question

I have several pipeline jobs, which are configured very similarly. They all have the same stages (of which there are about 10).

I am now I am thinking about moving to the declarative pipeline (https://jenkins.io/blog/2016/09/19/blueocean-beta-declarative-pipeline-pipeline-editor/).

But I do not want to define the ~10 stages in every pipeline. I want to define them at one place, and "import" them somehow.

Is this possible with declarative pipelines at all? I see that there are Libraries, but it does not seem like I could include the stage definition using them.

Answer 1

You will have to create a shared-library to implement what i am about to suggest. For shared-library implementation, you may check the following posts:

Using Building Blocks in Jenkins Declarative Pipeline

Upload file in Jenkins input step to workspace (Mainly for images so one can easily figure out things)

Now if you want to use a Jenkinsfile (kind of a template) which can be reused across multiple projects (jobs), then that is indeed possible.

Once you have created a shared-library repository with vars directory in it, then you just have to create a Groovy file (let's say, commonPipeline.groovy) inside vars directory.

Here's an example that works because I have used it earlier in multiple jobs.

---

$ cat shared-lib/vars/commonPipeline.groovy

// You can create function(s) as shown below, if required
def someFunctionA() {
    // Your code
}

// This is where you will define all the stages that you want
// to run as a whole in multiple projects (jobs)
def call(Map config) {
    pipeline {
        agent {
            node { label 'slaveA || slaveB' }
        }

        environment {
            myvar_Y = 'apple'
            myvar_Z = 'orange'
        }

        stages {
            stage('Checkout') {
                steps {
                    deleteDir()
                    checkout scm
                }
            }

            stage ('Build') {
                steps {
                    script {
                        check_something = someFunctionA()

                        if (check_something) {
                            echo "Build!"
                            # your_build_code
                        } else {
                            error "Something bad happened! Exiting..."
                        }
                    }
                }
            }

            stage ('Test') {
                steps {
                    echo "Running tests..."
                    // your_test_code
                }
            }

            stage ('Deploy') {
                steps {
                    script {
                        sh '''
                            # your_deploy_code
                        '''
                    }
                }
            }
        }
        post {
            failure {
                sh '''
                    # anything_you_need_to_perform_in_failure_step
                ''' 
            }

            success {
                sh '''
                    # anything_you_need_to_perform_in_success_step
                '''
            }
        }
    }
}

With above Groovy file in place, all you have to do now is to call it in your various Jenkins projects. Since you might already be having an existing Jenkinsfile (if not, create it) in your Jenkins project, you just have to replace the existing content of that file with the following:

$ cat Jenkinsfile
// Assuming you have named your shared-library as `my-shared-lib` & `Default version` to `master` branch in 
// `Manage Jenkins` » `Configure System` » `Global Pipeline Libraries` section
@Library('my-shared-lib@master')_

def params = [:]

params=[
    jenkins_var: "${env.JOB_BASE_NAME}",
]

commonPipeline params

Note: As you can see above, I am calling commonPipeline.groovy file. So, all your bulky Jenkinsfile will get reduced to just five or six lines of code, and those few lines are also going to be common across all those projects. Also note that I have used jenkins_var above. It can be any name. It's not actually used but is required for pipeline to run. Some Groovy expert can clarify that part.

Ref: https://www.jenkins.io/blog/2017/10/02/pipeline-templates-with-shared-libraries/