Jenkins 共享库(Shared Libraries)实战指南:从入门到精通

持续集成交付CICD:Jenkins Sharedlibrary 共享库 一、理论。 阅读详情

1. 为什么你需要一个Jenkins共享库?

如果你用过一段时间的Jenkins Pipeline,尤其是写过几个项目的 Jenkinsfile,你大概率会遇到一个头疼的问题:重复。今天给A项目写一个构建Docker镜像的步骤,明天给B项目写一个几乎一模一样的;这个项目的部署脚本是这么写的,那个项目为了图省事又抄了一份,结果后来发现有个安全漏洞要修复,你得挨个去改十几个 Jenkinsfile。这种日子我过了好几年,直到我开始用共享库,才真正从“Pipeline码农”变成了“流程设计师”。

简单说,Jenkins共享库(Shared Libraries) 就是一个专门存放你Pipeline公共代码的“宝库”。你可以把那些反复出现的、通用的操作——比如编译Java、构建Docker镜像、部署到Kubernetes、发送通知消息——都封装成一个个方法,放到这个库里。以后任何项目的 Jenkinsfile 想用这些功能,只需要像调用一个函数一样简单引用一下就行。这带来的好处是革命性的:一处修改,处处生效。你再也不用担心某个部署逻辑更新后,漏掉了哪个项目的配置文件。

我刚开始接触时也觉得有点门槛,又是Groovy又是目录结构的。但实际用下来发现,它的核心思想非常朴素:把复杂的、重复的代码打包起来,让流水线脚本变得干净、可读、好维护。无论你是管理三五个项目的小团队,还是负责几十个微服务的中大型团队,早点用上共享库,都能帮你省下大量后期维护和排查问题的时间。接下来,我就带你从零开始,手把手搭建并玩转这个“效率神器”。

2. 手把手搭建你的第一个共享库

理论说再多不如动手做一遍。搭建一个共享库,其实就像在Git上新建一个代码仓库,然后告诉Jenkins去哪找它。整个过程非常直观。

2.1 创建共享库的代码仓库

首先,你需要在你的代码托管平台(比如GitLab、GitHub或者Gitee)上创建一个新的仓库。我给这个仓库起名通常叫 jenkins-shared-library 或者 company-ci-lib,一看就知道是干什么的。

创建好后,在本地初始化这个仓库,并建立共享库要求的标准目录结构。这是最关键的一步,结构对了,Jenkins才能正确识别。打开你的终端,执行以下命令:

mkdir -p my-shared-library/{src, vars, resources}
cd my-shared-library
git init

这三个目录各有各的使命:

  • src: 这里是放“正经”Groovy类的地方,遵循Java的包管理方式。你可以在这里封装复杂的业务逻辑和工具类。比如 src/com/company/utils/BuildTool.groovy。
  • vars: 这是最常用、最直接的地方。里面放的都是可以直接在Pipeline步骤里调用的全局变量脚本。每个 .groovy 文件的名字就是你在Pipeline里调用的方法名。比如 vars/deployK8s.groovy,在Pipeline里就可以直接写 deployK8s()。
  • resources: 用来存放非Groovy的静态资源文件,比如Shell脚本、Python脚本、JSON配置文件等。这些文件可以通过库的 libraryResource 步骤加载到Pipeline中。

我建议你一开始可以先从 vars 目录玩起,因为最简单,成就感来得最快。

2.2 在Jenkins全局配置中“认领”你的库

仓库建好了,接下来得告诉Jenkins:“嘿,我的共享库在这儿,以后流水线需要就从这儿拿代码。”

  1. 登录你的Jenkins管理后台,点击 “系统管理”。
  2. 找到 “系统配置”,在里面滚动查找 “Global Pipeline Libraries”(全局流水线库)。这个功能是Jenkins内置的,不需要额外安装插件。
  3. 点击 “添加” 按钮,你会看到需要填写几个关键信息:
    • Library Name: 给你的库起个名字,比如 company-shared-lib。这个名字就是以后在 Jenkinsfile 里引用的标识符。
    • Default version: 指定默认拉取哪个分支的代码,比如 main 或 master。我强烈建议在这里填写一个稳定的分支名,比如 production,而在具体项目的 Jenkinsfile 中显式指定版本(如 @Library('company-shared-lib@v1.0') _),这样可以避免默认分支的变更意外影响所有流水线。
    • Retrieval Method: 选择 “Modern SCM”。虽然也有Legacy SCM选项,但现代的方式更通用。
    • Project Repository: 这里就填入你刚才创建的Git仓库的HTTPS或SSH地址。
    • Credentials: 如果你的仓库是私有的,需要在这里添加对应的凭据(用户名密码或SSH密钥)。

配置项看起来不少,但大部分都是一次性设置。填好后,可以点击底下的 “验证” 按钮(如果提供的话)测试一下连接,没问题就保存。这样,全局共享库就配置好了。所有有权限的Jenkins任务都可以引用它。

3. 深入核心:共享库的三大目录详解

配置好只是第一步,真正强大在于你怎么往里面“装东西”。我们来把 src、vars、resources 这三个目录彻底搞明白。

3.1 vars目录:你的Pipeline步骤“快捷指令”

vars 目录下的脚本是共享库的“门面”,使用起来最方便。每个 .groovy 文件定义一个全局变量,这个变量可以直接作为一个Pipeline步骤来调用。

举个例子,我们创建一个最常用的构建Docker镜像的步骤。在 vars 目录下新建文件 buildDockerImage.groovy:

def call(String imageName, String tag = 'latest') {
    // 这是一个简单的call方法,允许你以 buildDockerImage('my-app') 的方式调用
    echo "开始构建Docker镜像: ${imageName}:${tag}"
    sh """
        docker build -t ${imageName}:${tag} .
        docker push ${imageName}:${tag}
    """
    echo "镜像构建并推送完成"
}

这个脚本定义了一个 call 方法。在Pipeline中,你可以这样使用它:

@Library('company-shared-lib') _
pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                // 直接像使用内置步骤一样调用
                buildDockerImage('my-company/my-app', 'v1.2.3')
                // 也可以使用命名参数,更清晰
                buildDockerImage imageName: 'my-company/my-app', tag: 'v1.2.3'
            }
        }
    }
}

是不是非常简单?vars 下的脚本还支持更复杂的特性,比如定义多个方法,或者接收一个Map配置参数。我再写一个更实用的,用于Kubernetes滚动更新的:

// vars/rollingUpdate.groovy
def call(Map params) {
    // 设置默认值
    def namespace = params.namespace ?: 'default'
    def deployment = params.deployment
    def container = params.container ?: deployment // 默认容器名与部署名相同
    def image = params.image
    def tag = params.tag ?: 'latest'

    if (!deployment || !image) {
        error "参数 'deployment' 和 'image' 是必需的。"
    }

    echo "正在对命名空间 [${namespace}] 中的部署 [${deployment}] 执行滚动更新..."
    sh """
        kubectl -n ${namespace} set image deployment/${deployment} \
        ${container}=${image}:${tag} --record=true
    """
    // 可以在这里添加健康检查,等待新Pod就绪
    sh """
        kubectl -n ${namespace} rollout status deployment/${deployment} --timeout=300s
    """
    echo "滚动更新完成!"
}

在Pipeline中调用时,代码会非常清晰:

rollingUpdate(
    namespace: 'production',
    deployment: 'user-service',
    image: 'registry.company.com/user-service',
    tag: env.BUILD_NUMBER
)

踩坑提醒:vars 下的脚本会在每次Pipeline运行时被动态加载。虽然方便,但不要在里面写太复杂的逻辑,或者进行耗时的初始化操作,这会影响流水线性能。复杂的逻辑应该放到 src 目录下的类里去。

3.2 src目录:封装复杂的业务逻辑

当你的共享逻辑变得复杂,需要面向对象的设计、继承、或者工具类时,src 目录就是你的主战场。这里的代码是标准的Groovy类(实际上也是Java类),需要遵循包名目录结构。

假设我们有一个通用的工具类,用于处理不同语言的构建命令。创建文件 src/com/company/utils/BuildUtils.groovy:

package com.company.utils

class BuildUtils implements Serializable {
    // 必须实现Serializable,因为Jenkins Pipeline可能跨节点执行
    def steps
    // 构造函数,注入Pipeline的steps对象,以便使用sh, echo等内置步骤
    BuildUtils(steps) {
        this.steps = steps
    }

    void mavenBuild(String goals = 'clean package') {
        steps.echo "执行Maven构建: ${goals}"
        steps.sh "mvn -B -DskipTests ${goals}"
    }

    void npmBuild(String nodeVersion = '16', String command = 'ci') {
        steps.echo "使用Node.js ${nodeVersion} 执行NPM ${command}"
        steps.sh """
            nvm use ${nodeVersion} || true
            npm ${command}
            npm run build
        """
    }

    void gradleBuild(String tasks = 'build') {
        steps.echo "执行Gradle任务: ${tasks}"
        steps.sh "./gradlew --no-daemon ${tasks}"
    }
}

要在Pipeline中使用这个类,你需要先实例化它:

@Library('company-shared-lib') _
pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                script {
                    // 实例化工具类,将当前流水线的steps传进去
                    def buildTools = new com.company.utils.BuildUtils(this)
                    // 根据项目类型调用不同方法
                    if (env.PROJECT_TYPE == 'java') {
                        buildTools.mavenBuild('clean package -DskipTests')
                    } else if (env.PROJECT_TYPE == 'nodejs') {
                        buildTools.npmBuild('16', 'ci')
                    }
                }
            }
        }
    }
}

使用 src 目录的类,代码结构更清晰,可测试性也更强。你可以为这些类编写单元测试,这是 vars 脚本不太容易做到的。

3.3 resources目录:存放你的脚本和配置文件

有些操作用Groovy写起来啰嗦,或者本来就是现成的Shell/Python脚本,这时就可以放到 resources 目录。比如,一个清理旧Docker镜像的脚本 resources/scripts/cleanup_images.sh:

#!/bin/bash
# 清理超过7天的旧镜像
echo "清理旧的Docker镜像..."
docker image prune -a --force --filter "until=168h"

在共享库的Groovy代码中,你可以这样读取和使用它:

// vars/cleanup.groovy
def call() {
    // 将资源文件读取为字符串
    def cleanupScript = libraryResource 'scripts/cleanup_images.sh'
    // 写入到一个临时文件并执行
    writeFile file: 'cleanup.sh', text: cleanupScript
    sh 'chmod +x cleanup.sh && ./cleanup.sh'
}

resources 目录保证了你的脚本文件也能像代码一样被版本化管理,并且能跟随共享库一起分发。

4. 在真实项目中玩转共享库:四大实战场景

知道了怎么造轮子,更要知道轮子用在哪。下面我结合自己趟过的坑,分享几个共享库最能发挥价值的典型场景。

4.1 场景一:统一构建流程,告别复制粘贴

这是最普遍的需求。公司里可能有Java、Go、Node.js、Python各种项目,每个项目组的 Jenkinsfile 里都有一套自己的 mvn clean package 或 npm run build。时间一长,参数不一致,有的跳过了测试,有的没跳过,混乱不堪。

解决方案:在共享库里创建一个“构建工厂”。比如,在 vars 下创建一个 standardBuild.groovy:

def call(String projectType, Map options = [:]) {
    def defaultOptions = [
        skipTests: true,
        buildArgs: '',
        outputDir: 'target'
    ]
    // 合并默认参数和用户传入参数
    def config = defaultOptions << options

    echo "开始执行标准化构建,项目类型: ${projectType}"

    switch(projectType.toLowerCase()) {
        case 'java-maven':
            sh "mvn clean package -DskipTests=${config.skipTests} ${config.buildArgs}"
            break
        case 'java-gradle':
            sh "./gradlew clean build ${config.skipTests ? '-x test' : ''} ${config.buildArgs}"
            break
        case 'nodejs':
            sh """
                npm ci
                npm run build
            """
            // 假设构建输出在dist目录
            config.outputDir = 'dist'
            break
        case 'go':
            sh "go build -o ${config.outputDir}/app ./..."
            break
        default:
            error "不支持的构建类型: ${projectType}"
    }
    echo "构建完成,输出目录: ${config.outputDir}"
    // 返回构建产出物路径等信息,供后续步骤使用
    return [artifactDir: config.outputDir]
}

这样,所有项目的 Jenkinsfile 的构建阶段,都变成了一行清晰明了的调用:

stage('构建') {
    steps {
        // Java项目调用
        standardBuild('java-maven', skipTests: false)
        // Node.js项目调用
        standardBuild('nodejs')
    }
}

构建逻辑的任何改动,比如想统一在Maven构建里增加一个 -U 参数(强制更新快照),只需要改共享库这一处地方。

4.2 场景二:标准化Kubernetes部署,降低运维风险

手动写 kubectl set image 或者 kubectl apply -f 很容易出错,特别是镜像标签、命名空间、配置映射这些参数。通过共享库,我们可以把部署抽象成一个安全、可控的“黑盒”。

我们可以扩展之前提到的 rollingUpdate 方法,或者创建一个更强大的 deployToK8s 方法。这个方法不仅可以更新镜像,还可以处理ConfigMap、Secret、Ingress等资源的差异更新。

// vars/deployToK8s.groovy
def call(Map params) {
    def defaults = [
        namespace: 'default',
        environment: 'dev',
        waitForRollout: true,
        timeoutSeconds: 300
    ]
    def config = defaults << params

    // 1. 检查必要的工具和上下文
    checkKubectl()
    checkNamespace(config.namespace)

    // 2. 根据环境,可能注入不同的配置(如ConfigMap)
    injectConfigurations(config.environment, config.namespace)

    // 3. 应用Kubernetes清单文件
    // 假设清单文件在项目根目录的 k8s/ 文件夹下
    sh "kubectl apply -f k8s/ -n ${config.namespace} --prune -l app=${config.appName}"

    // 4. 等待部署就绪
    if (config.waitForRollout) {
        sh """
            kubectl rollout status deployment/${config.appName} \
            -n ${config.namespace} \
            --timeout=${config.timeoutSeconds}s
        """
    }

    // 5. 执行部署后检查(如健康端点检查)
    postDeploymentHealthCheck(config.appName, config.namespace)

    echo "应用 ${config.appName} 已成功部署到 ${config.namespace} 命名空间。"
}

在Pipeline中,部署阶段变得极其简洁和一致:

stage('部署到测试环境') {
    steps {
        deployToK8s(
            appName: 'invoice-service',
            namespace: 'test',
            environment: 'test'
        )
    }
}
stage('部署到生产环境') {
    when { branch 'main' }
    steps {
        input message: '确认部署到生产环境?'
        deployToK8s(
            appName: 'invoice-service',
            namespace: 'production',
            environment: 'prod',
            waitForRollout: true,
            timeoutSeconds: 600 // 生产环境等待时间长一些
        )
    }
}

4.3 场景三:集成代码质量与安全扫描门禁

现代CI/CD流程离不开代码质量检查(SonarQube)、安全扫描(Trivy, OWASP Dependency-Check)、许可证审查等。这些工具的命令行参数往往很复杂,把它们封装进共享库,可以确保所有项目都使用相同的、最新的扫描策略。

创建一个 runSecurityScan.groovy:

def call(String scanType) {
    def scannerHome = tool name: 'sonar-scanner', type: 'hudson.plugins.sonar.SonarRunnerInstallation'
    def projectKey = "${env.JOB_BASE_NAME}:${env.BRANCH_NAME}"

    switch(scanType) {
        case 'sonarqube':
            withSonarQubeEnv('My-SonarQube-Server') { // 配置在Jenkins中的Sonar服务器ID
                sh """
                    ${scannerHome}/bin/sonar-scanner \
                    -Dsonar.projectKey=${projectKey} \
                    -Dsonar.sources=. \
                    -Dsonar.host.url=\${SONAR_HOST_URL} \
                    -Dsonar.login=\${SONAR_AUTH_TOKEN}
                """
            }
            // 可以在这里添加质量阈检查,失败则中止流水线
            timeout(time: 5, unit: 'MINUTES') {
                waitForQualityGate abortPipeline: true
            }
            break
        case 'dependency-check':
            sh 'dependency-check.sh --scan . --format HTML --out reports/'
            archiveArtifacts artifacts: 'reports/*.html'
            // 可以解析报告,如果发现高危漏洞则令构建失败
            break
        case 'container-vulnerability':
            sh 'trivy image --exit-code 1 --severity HIGH,CRITICAL my-image:latest'
            break
    }
}

在Pipeline中,只需要根据项目阶段调用即可:

stage('代码质量分析') {
    steps {
        runSecurityScan('sonarqube')
    }
}
stage('依赖安全检查') {
    steps {
        runSecurityScan('dependency-check')
    }
}
stage('容器镜像扫描') {
    steps {
        script {
            docker.build('my-image:latest')
            runSecurityScan('container-vulnerability')
        }
    }
}

4.4 场景四:智能通知与报告聚合

流水线成功或失败后,给团队发送通知是刚需。但通知格式五花八门,有的发钉钉,有的发企业微信,有的发Slack,消息内容也乱七八糟。用共享库可以统一通知模板和渠道。

创建一个 notifyPipelineStatus.groovy:

def call(String status, Map extra = [:]) {
    // 构建消息内容
    def subject = "[Jenkins构建] ${env.JOB_NAME} #${env.BUILD_NUMBER} - ${status}"
    def details = """
        **构建状态**: ${status}
        **项目**: ${env.JOB_NAME}
        **构建编号**: ${env.BUILD_NUMBER}
        **分支**: ${env.GIT_BRANCH}
        **提交者**: ${env.CHANGE_AUTHOR ?: '未知'}
        **构建链接**: ${env.BUILD_URL}
        **控制台日志**: ${env.BUILD_URL}console
    """.stripIndent()

    // 可以根据状态附加额外信息,比如失败时附加错误日志片段
    if (status == 'FAILURE' && extra.logSnippet) {
        details += "\n**错误摘要**:\n```\n${extra.logSnippet}\n```"
    }

    // 发送到不同渠道(示例为钉钉Webhook)
    if (env.DINGTALK_WEBHOOK_URL) {
        sendToDingTalk(subject, details)
    }
    // 可以继续添加其他通知渠道,如邮件、Slack等
    echo "已发送${status}通知。"
}

// 一个简单的钉钉发送方法示例
private void sendToDingTalk(String subject, String text) {
    def message = """
        {
            "msgtype": "markdown",
            "markdown": {
                "title": "${subject}",
                "text": "${text}"
            }
        }
    """
    // 使用Jenkins的HTTP Request插件或shell命令发送
    sh """
        curl '${env.DINGTALK_WEBHOOK_URL}' \
        -H 'Content-Type: application/json' \
        -d '${message}'
    """
}

在Pipeline的 post 部分统一调用:

post {
    always {
        // 总是发送通知,包含构建状态
        script {
            def logSnippet = ''
            if (currentBuild.result == 'FAILURE') {
                // 可以尝试捕获最后几行错误日志
                logSnippet = sh(script: 'tail -50 console.log', returnStdout: true).trim()
            }
            notifyPipelineStatus(currentBuild.currentResult, [logSnippet: logSnippet])
        }
    }
}

5. 进阶技巧与避坑指南

用了一段时间共享库后,我积累了一些让库更健壮、更好用的经验,也踩过不少坑,这里一并分享给你。

5.1 版本管理:稳定大于一切

共享库的版本管理至关重要。永远不要在项目的 Jenkinsfile 中引用不稳定的分支(如 @Library('mylib@master') _)。master 分支的代码随时在变,今天能跑通的流水线,明天可能就失败了。

正确做法:

  1. 为共享库打标签:当共享库开发并测试完成一个稳定版本后,像发布软件一样打上Git标签,例如 v1.0.0, v1.1.0。
  2. 在Pipeline中显式指定版本:在 Jenkinsfile 中,使用标签或特定的稳定分支名。
    // 好:使用具体的版本标签
    @Library('company-shared-lib@v1.2.0') _
    // 也可以:使用一个专门的稳定分支,如 `stable`
    @Library('company-shared-lib@stable') _
    
  3. 升级需要测试:当共享库发布新版本(如 v1.3.0)后,不要急着把所有项目都升级。可以先在一个测试项目中升级引用,验证无误后,再逐步推广到其他项目。

5.2 编写可测试的代码与调试

共享库的代码一旦出错,影响的是所有引用它的流水线,所以可测试性和可调试性非常重要。

  • 为 src 目录的类编写单元测试:可以使用 Jenkins Pipeline Unit 测试框架。它允许你在不启动真实Jenkins的情况下,模拟Pipeline环境,测试你的工具类逻辑。虽然配置稍麻烦,但对于核心逻辑的保障是值得的。
  • 善用 println 或 echo 调试:在开发共享库方法时,多使用 echo 打印关键变量的值。这些日志会输出到流水线控制台,是定位问题的第一手资料。
  • 利用 @NonCPS 注解处理复杂数据结构:如果你的共享库方法需要操作复杂的Groovy集合(如List、Map)并进行序列化,可能会遇到 NotSerializableException 异常。这时可以在方法上添加 @NonCPS 注解,告诉Jenkins这个方法不需要被序列化。但要注意,@NonCPS 方法内不能调用任何Jenkins的步骤(如 sh, echo)。

5.3 性能优化与缓存

如果共享库仓库很大,或者网络不佳,每次流水线都去拉取库代码可能会成为性能瓶颈。

  • 启用库缓存:在Jenkins系统配置的“Global Pipeline Libraries”设置中,有一个 “缓存” 选项。启用后,Jenkins会在主节点上缓存库的代码,而不是每次构建都重新克隆,可以极大提升加载速度。
  • 精简库内容:只把真正需要共享的代码放入库中。避免放入大型二进制文件或无关的文档。保持仓库轻量。
  • 按需加载:你可以在Pipeline中只加载特定版本的库,或者通过 @Library('mylib@branch') _ 的语法在脚本中动态加载,但通常全局配置的默认版本已经足够。

5.4 安全最佳实践

共享库权限很高,因为它能在所有引用它的流水线中执行代码,所以安全不容忽视。

  • 代码审查是必须的:共享库的仓库应该像你的业务代码仓库一样,实施严格的代码审查(Merge Request/Pull Request)机制,禁止直接向主分支推送代码。
  • 谨慎处理凭证:绝对不要在共享库的代码中硬编码任何密码、密钥、令牌。所有敏感信息都应该使用Jenkins的 “凭据” 功能来管理,在共享库中通过 withCredentials 绑定来安全地使用。
  • 最小权限原则:控制好谁有权限向共享库仓库提交代码。同时,在Jenkins中,也要通过“项目矩阵授权策略”等权限控制,限制哪些流水线任务有权加载和使用特定的共享库。

从我自己的经验来看,引入共享库的初期会有一个学习和适应成本,但一旦团队熟悉了这种模式,CI/CD流程的维护效率会得到质的提升。它让Pipeline从一堆杂乱无章的脚本,变成了由标准化、可复用的“乐高积木”搭建起来的清晰蓝图。当你需要修改一个通用的部署逻辑时,再也不用提心吊胆地到处搜索和替换了,这种掌控感,是提升DevOps体验的关键一步。

基于Jenkins的DevOps工程实践之Jenkins共享库 共享库这并不是一个全新的概念,其实在编程语言Python中,我们可以将Python代码写到一个文件中,当代码数量增加,我们可以将代码打包成模块然后再以import的方式使用此模块中的方法。在Jenkins中使用Groovy语法,共享库中存储的每个文件都是一个groovy的类,每个文件(类)中包含一个或多个方法。每个方法包含groovy语句块。创建共享库,共享库的目的就是将一些反复使用的模块进行封装,比如拉取代码模块,邮件通知模块,这样使得你的Jenkinsfile看起来更加简洁,减少代码量。 阅读详情

相关推荐

Jenkins 共享库(Shared Libraries)使用说明文档

Jenkins 共享库是提升 CI/CD 代码复用性和可维护性的核心机制,尤其适用于中大型团队和复杂流水线场景。合理使用时,可显著降低维护成本并增强流程一致性,但需注意版本控制和代码质量。建议结合代码审查和自动化测试,确保共享库的稳定性和可靠性。

demonlg0112的博客 2490

jenkins扩展你的流水线(共享库)

jenkins扩展你的流水线

运维@小兵的博客 2694

Jenkins Pipeline共享库(Shared Library)完全指南

Jenkins的是实现“流水线即代码”的关键,它通过**共享库(Shared Library)**机制,让团队能将通用的Pipeline逻辑(如构建、部署步骤)封装起来,供所有项目复用,从而大幅提升代码的维护性和标准化水平。*Pipeline: Groovy Libraries插件**是Jenkins实现高效、标准化CI/CD的基石。通过将通用逻辑抽象到共享库中,不仅能减少重复代码,还能推动团队工程技术实践的统一。

weixin_30777913的博客 1435

Jenkins 进阶:Jenkins共享库(ShareLibrary)

Jenkins Shared Libraries 是一种高级特性,允许用户将常用的 Pipeline 脚本代码抽取到单独的 Git 仓库中进行管理和重用。这不仅提高了代码的可维护性,还促进了团队间最佳实践的分享。下面详细介绍如何创建和使用 Jenkins Shared Libraries。

qq_33240556的博客 2132

Jenkins Pipeline 使用 Jenkins Shared Libraries (共享库)

在vars/目录下创建文件。call方法是默认入口。if (!patch) {returnecho "正在使用模型${model进行 AI 评审..."// 这里封装你之前的脚本逻辑${patchecho "AI 评审结果:${resultpatch) {

u013171130的博客 230

Jenkins Pipeline报错“WorkflowScript: LoadScript“的共享库配置指南

摘要: Jenkins Pipeline中"WorkflowScript: LoadScript"错误通常与共享库配置或权限问题相关。本文分析了主要错误类型(权限不足、配置错误、版本不匹配等),提供了共享库的标准目录结构配置指南(src/vars/resources),详细介绍了Jenkins全局配置步骤(添加共享库、脚本审批)及Pipeline调用示例。针对典型案例(加载失败、权限不足、版本问题)给出具体解决方案,并推荐了版本控制、文档化等最佳实践。这些方法可有效解决共享库加载问题,提

shejizuopin的博客 1066

Jenkins Groovy Pipeline 完全指南:从基础语法到高阶实战

Jenkins Pipeline 的核心执行引擎基于解释器实现。这意味着你的 Pipeline 脚本本质上就是一个 Groovy 程序,但它经过特殊处理,能够支持构建状态的持久化与恢复——即使 Jenkins 在构建中途重启,也能够从中断位置继续执行。💡核心区别:Pipeline 脚本虽然使用 Groovy 语法,但并不能完全等同于普通 Groovy 程序。Pipeline 的 CPS 转换机制会在编译时拦截大部分操作,将代码转换为可序列化的状态机。

✨ 欢迎来到【Seal ^_^ 的优快云博客】!✨ 2201

jenkins-shared-libraries:Jenkins共享库

詹金斯共享图书馆 Jenkins共享库 寄件人 @Library('jenkins-shared-library') _ ... slackSender.post(buildResult, resultMessages, "${SLACK_TOKEN}")

Jenkins DevOps Shared Libraries 使用指南

Jenkins DevOps Shared Libraries 使用指南 项目介绍 本项目是Jenkins DevOps Shared Libraries,一个专为简化和标准化Jenkins Pipeline开发而设计的共享库集合。它涵盖了多个常见DevOps工具(如Ansible、Puppet、Packer、Terraform、Helm、Goss等),并支持集成在Jenkins的持续集成/持续部...

gitblog_00457的博客 574

手把手调试Android 14 ShellTransitions:用Log追踪ActiveTransition与Handler匹配过程

本文详细介绍了在Android 14中调试ShellTransitions机制的方法,重点通过Log追踪ActiveTransition与Handler的匹配过程。文章提供了关键日志点植入策略、Handler匹配机制解析及实战调试案例,帮助开发者解决窗口转场动画中的卡顿和错乱问题,提升系统动画性能。

weixin_42652674的博客 434

AI 小说生成器本地部署完全指南

这篇文章介绍了本地部署AI小说生成器的完整指南,主要面向网文作者、内容创作者和AI爱好者。文章从环境搭建到创作实践,详细讲解了三种主流部署方案:Ollama(推荐新手)、LMStudio(图形界面)和text-generation-webui(高级定制)。内容涵盖硬件需求、系统架构、模型选择、API对接、提示词工程等关键技术环节,并提供了小说创作的特制提示词模板和参数调优建议。文章还讨论了长篇小说管理、多模型协作等进阶技巧,以及版权伦理等法律问题。最后推荐了相关工具资源和社区论坛,帮助读者实现安全、高效、可

珂珂可爱多 2304

DevOps实战系列【第十二章】:详解Shared Libraries共享库

手把手教你玩转DevOps全栈技术

lijie1051的专栏 1370

从CentOS迁移到openEuler 24.03 LTS:手把手教你部署Java+MySQL+Redis+Nginx全栈环境

本文详细指导如何从CentOS迁移到openEuler 24.03 LTS,并部署Java+MySQL+Redis+Nginx全栈环境。涵盖系统配置、软件安装、性能优化及环境验证,助力企业级用户高效完成服务器迁移与部署。

weixin_26938645的博客 390

Jenkins shared libraries

Jenkins shared libraries

莫问前程 584

测试工程师玩转DeepSeek之Prompt

掌握这些提示词技巧,测试工程师可提升与DeepSeek的协作效率至少3倍。建议结合具体项目上下文进行二次优化,并建立团队内部的提示词知识共享库。✅ “为电商支付接口生成包含幂等性验证的测试用例,覆盖网络中断重试场景”❌ “帮我写测试用例”

weixin_44872675的博客 2262

一键开关机电路

一键开关机电路

让你爱上电路设计 4182

如何用Job DSL实现Jenkins配置即代码:从入门到精通指南

在现代DevOps实践中,Jenkins作为最流行的自动化服务器之一,其配置管理方式直接影响团队的开发效率。传统的手动配置任务不仅耗时,还容易出现不一致性问题。而**Jenkins配置即代码**(Configuration as Code)通过将任务定义转化为可版本控制的代码,彻底解决了这些痛点。本文将详细介绍如何使用**Job DSL插件**实现Jenkins任务的程序化管理,让你的CI/CD流

gitblog_00483的博客 981

Autosar MCAL-S32K324 Fee配置-基于EB

Autosar MCAL S32K324 Fee配置详解

赞的博客 1546

Jenkins Shared Library 实战(共享库)

说明:写流水线久了你会发现,每个 Job 都要做「发通知、打镜像、做审批」这些一模一样的事,于是每个 Jenkinsfile 里都粘了几十行重复的 Groovy,改一处要改所有 Job。共享库就是把这些公共逻辑抽到一个独立仓库,多个 Job 共用。这份文档讲清楚三件事:库怎么组织、Jenkins 怎么配置、流水线里怎么用。

Light91011的博客 385

STM32入门教程:智能储物柜控制

在这个例子中,我们将使用一个4x4的储物柜,共有16个储物格。我们了解了硬件准备、储物柜电路设计、STM32的基本配置、储物柜控制代码的编写以及测试和调试等方面的知识。根据我们的电路设计,我们需要将一些引脚配置为输出,并将其他引脚配置为输入。在本教程中,我们将使用STM32微控制器来实现一个基本的智能储物柜控制系统。在主函数中,我们将不断循环读取传感器数据,并根据数据的变化来控制储物柜的开关和显示相关信息。这个函数将读取人体感应传感器、温湿度传感器和光照传感器的数据,并将数据存储到相应的变量中。

m0_75244442的博客 663

RHCA III之路---EX436-1

由于ha这门课有大量命令需要在3个节点上同步执行.如果执行history会出现前面数字,复制多行会有些麻烦.lab环境是nodea,nodeb,nodec 考试环境是node1,node2,node3。就可以快速将历史命令实现可多行复制,当然也可以用awk进行分割,个人喜好随意。技巧只能加快答题速度,对考试得分帮助不大。确认3个红框内容一致,且没报错即可。再执行一个histrory。3个node节点上运行。这样就能1次复制3行。

Q先生 1012

Jenkins DevOps Libraries 使用指南

Jenkins DevOps Libraries 使用指南 本指南旨在帮助您了解并有效利用 mschuchard/jenkins-devops-libs 这一开源项目,它是一套用于 Jenkins Pipeline 的共享库,专为常见的DevOps软件设计。 1. 项目目录结构及介绍 该项目采用了典型的Git仓库结构,其中包含了多个关键子目录和文件,确保了组织上的清晰性以及功能模块的可重用性。以下...

gitblog_00170的博客 570

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

避坑指南:Jenkins Shared Libraries从配置到调试的7个常见错误

本文深入剖析Jenkins Shared Libraries在配置与调试过程中的7个常见错误,包括版本管理、Groovy语法陷阱、调试技巧、安全边界、性能优化、跨平台兼容及依赖管理。通过实战案例和解决方案,帮助开发者高效避坑,提升CI/CD流程的稳定性和效率。特别针对Jenkins共享库的高频问题提供专业指导。

oo7890的博客 165

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

解决90%重复工作:Jenkins共享库让Pipeline复用更简单

你是否还在为每个Jenkins Pipeline重复编写相同的构建步骤而烦恼?是否因为团队内Pipeline风格不一、维护成本高而头疼?本文将带你通过Jenkins共享库(Shared Libraries)实现Pipeline代码的复用,一次编写、处处调用,大幅提升DevOps效率。读完你将掌握:共享库的核心价值、三步搭建流程、实战应用技巧以及最佳实践。 ### 为什么需要Jenkins共享库?...

gitblog_00390的博客 1207

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

避坑指南:Jenkins Shared Libraries配置中的7个常见错误及解决方法

本文深入剖析Jenkins Shared Libraries配置中的7个常见错误,提供专业解决方案。从目录结构、版本控制到安全边界和调试技巧,帮助团队规避共享库使用中的陷阱,提升持续交付效率。特别针对Jenkins Pipeline和Groovy开发中的实际问题,给出实战建议。

yolo5detector的博客 157
上一篇: GNSS星历数据下载全攻略:从最终到超快速产品的获取与应用
下一篇: ImGUI项目构建指南:从零搭建cmake+MinGW64开发环境
Python
博客等级 码龄26年 1973粉丝 1567原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值