Jenkins共享库使用

简单使用

共享库（Shared libraries）是一种可以用来封装函数、变量甚至整个 Pipeline 的机制。通过共享库，可以将常用的功能和流程逻辑定义在单独的 Groovy 脚本中，然后在多个 Pipeline 中重复使用，从而实现代码重用和统一管理

比如说复用这个转成json的方法

//tool.groovy
import groovy.json.JsonSlurper

def toJson(result){
    def jsonSlurper = new JsonSlurper()
    return jsonSlurper.parseText(result)
}

//流水线
 steps {
   script {
        def body = tool.toJson("${result.body}")
   }
 }

封装stage

//myStep.groovy
def myStep(param1, param2) {
    // 执行特定操作的代码逻辑
}
//流水线
@Library('my-shared-library') _
pipeline {
    agent any
    stages {
        stage('My Stage') {
            steps {
                script {
                    myStep(param1: 'value1', param2: 'value2')
                }
            }
        }
    }
}

封装变量，比如Linux和windows的变量

// linux.groovy
def myVariable = 'Linux value'
def param = 'linux'

// windows.groovy
def myVariable = 'Windows value'
def param = 'windows'

//流水线
steps {
    script {
        def config
        //jenkins自带的方法
        if (isUnix()) {
            config = load 'linux.groovy'
        } else if (isWindows()) {
            config = load 'windows.groovy'
        }

        // 使用变量
        def value1 = config.myVariable
        def value2 = config.param
    }
}

可以通过在共享库根目录创建Jenkinsfile，来动态加载pipeline

//Jenkinfile
@Library('[email protected]') _

def env = 'dev' // 根据实际情况设置环境参数

//通过参数调用不同的流水线脚本
if (env == 'dev') {
    deployPipeline = libraryResource('deployDev.groovy')
} else if (env == 'test') {
    deployPipeline = libraryResource('deployTest.groovy')
} else {
    echo "Unsupported environment: ${env}"
}

deployPipeline(appName: 'my-app', deploy: true)

// deployDev.groovy
def deployPipeline(Map params) {
    pipeline {
        agent any
        stages {
            stage('Deploy to Dev') {
                when {
                    expression { params.deploy == true }
                }
                steps {
                    sh 'echo "Deploying ${params.appName} to Dev environment..."
                }
            }
        }
    }
}

// deployTest.groovy
def deployPipeline(Map params) {
    pipeline {
        agent any
        stages {
            stage('Deploy to Test') {
                when {
                    expression { params.deploy == true }
                }
                steps {
                    sh 'echo "Deploying ${params.appName} to Test environment..."'
                }
            }
        }
    }
}

通过共享库，可以将复杂的流水线拆分，可以复用函数和动态组合等等，非常灵活

项目结构

project/
├── Jenkinsfile
└── my-shared-library/
    ├── vars/
    │   ├── deployPipeline.groovy
    │   └── ...
    ├── src/
    │   ├── com/
    │   │   ├── example/
    │   │   │   ├── MyClass.groovy
    │   │   │   └── ...
    │   │   └── ...
    │   └── ...
    ├── resources/
    │   ├── deployDev.groovy
    │   ├── deployTest.groovy
    │   └── ...
    └── README.md

vars/ 目录用于存放定义全局变量和流程函数的 Groovy 文件，比如上边复用的函数和封装step的函数

resources/ 目录用于存放资源文件，比如环境变量、配置文件等。比如上边的变量文件

src/ 目录用于存放如自定义的类、函数等，一般是写更复杂的类

需要注意的是vars下的groovy可以使用 Jenkins Pipeline的语法，比如echo、error等函数，在src下，只能写groovy语法的函数

src和resources都可以被vars调用

// 使用 load 方法加载 src/com/example/MyClass.groovy
load 'com/example/MyClass.groovy'

// 在 vars/deployPipeline.groovy 中调用 resources/deployDev.groovy
libraryResource 'my-shared-library/deployDev.groovy'

配置共享库

首先要将共享库上传到代码仓库中，Jenkins会拉取共享库并编译加载注意，在jenkins也要安装对应的scm插件

在系统配置中找到Global Pipeline Libraries，选择一个Retrieval method，一般是选择Modern method，需要安装scm插件，这里才有有选项，比如git插件

然后在流水线中配置

如果要使用共享库的Jenkinsfile，需要指定路径

使用方式

//引入库
@Library('lib')
import com.mycorp.pipeline.somelib.Helper'

//加 _ 就不用import
@Library('lib') _
//使用
def method = new com.mycorp.pipeline.Utils.someStaticMethod()

https://www.jenkins.io/doc/book/pipeline/shared-libraries/