上一篇学会了 Pipeline 语法，但当团队有十几个项目时，每个项目都维护一份完整的 Jenkinsfile，重复代码多、维护成本高。本篇讲两个关键能力：多分支流水线（Multibranch Pipeline）和共享库（Shared Library），解决规模化 CI/CD 的代码复用问题。

一、多分支流水线（Multibranch Pipeline）

传统 Jenkins Job 是"一个 Job 对应一个分支"。如果有 10 个分支要跑 CI，就要创建 10 个 Job。多分支流水线解决了这个问题：

传统方式：                          多分支流水线：
main    → Job-1                     Multibranch Job
develop → Job-2                      ├── main     (自动发现)
feature/A→ Job-3                      ├── develop  (自动发现)
feature/B→ Job-4                      ├── feature/A (自动发现)
hotfix-1 → Job-5                      ├── feature/B (自动发现)
                                      └── hotfix-1  (自动发现)

Repository URL: https://github.com/your-org/your-repo.git
Credentials: your-git-credential

策略选择：
- Discover branches: 所有分支
- Discover tags: 也发现 Tag
- Discover PRs from origin: 合并到 main 的 PR 也触发
- Filter by name (with wildcards): feature/*, hotfix/*, develop, main

Mode: by Jenkinsfile
Script Path: Jenkinsfile  // 仓库根目录的 Jenkinsfile

Branch Sources → Git → Behaviors:
  → Discover branches
  → Discover tags
  → Discover pull requests from origin:
      策略: Merging the PR with the current target branch
      合并PR和目标分支一起构建，确保PR合并后不会出问题
  → Filter by name (with wildcards):
      Include: main develop feature/* hotfix/* release/*
      Exclude: experiment/*

// Jenkinsfile
pipeline {
    agent any
    
    environment {
        // 根据分支自动确定环境
        DEPLOY_ENV = env.BRANCH_NAME == 'main' ? 'prod' :
                     env.BRANCH_NAME == 'develop' ? 'staging' :
                     env.BRANCH_NAME?.startsWith('release/') ? 'pre-prod' : 'dev'
        
        // 根据环境确定命名空间
        K8S_NAMESPACE = "myapp-${DEPLOY_ENV}"
    }
    
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package -DskipTests'
            }
        }
        
        stage('Deploy') {
            when {
                anyOf {
                    branch 'main'
                    branch 'develop'
                    branch 'release/*'
                }
            }
            steps {
                sh "kubectl apply -f k8s/ -n ${K8S_NAMESPACE}"
                sh "kubectl set image deployment/myapp app=myapp:${env.BUILD_NUMBER} -n ${K8S_NAMESPACE}"
            }
        }
    }
}

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                sh 'mvn clean package -DskipTests'
            }
        }
        
        stage('Full Test (PR only)') {
            when {
                changeRequest()  // 只在 PR 构建时执行
            }
            steps {
                // PR 构建跑完整测试套件
                sh 'mvn verify'
                // 代码覆盖率检查
                sh 'mvn jacoco:report'
                publishCoverage adapters: [jacocoAdapter('target/site/jacoco/')]
            }
        }
        
        stage('Quick Test (Branch)') {
            when {
                not { changeRequest() }  // 非PR构建只跑快速测试
            }
            steps {
                sh 'mvn test -Dtest=*UnitTest'
            }
        }
    }
}

当多个项目有相似的流水线逻辑时：

项目A的 Jenkinsfile:
  1. Maven 构建
  2. 单元测试
  3. Docker 镜像构建
  4. 部署到 K8s

项目B的 Jenkinsfile:
  1. Maven 构建
  2. 单元测试
  3. Docker 镜像构建
  4. 部署到 K8s

→ 90% 代码重复，只有项目名和部署目标不同

共享库让你把公共逻辑封装成函数，各项目只调用：

// 项目A的 Jenkinsfile（简化后）
@Library('jenkins-shared-lib') _
myPipeline {
    appName = 'service-a'
    deployTarget = 'prod'
}

1. 创建 Git 仓库 `jenkins-shared-lib`：

jenkins-shared-lib/
├── vars/           // 全局变量/函数
│   ├── myPipeline.groovy
│   ├── mavenBuild.groovy
│   ├── dockerBuild.groovy
│   └── k8sDeploy.groovy
├── src/            // 类定义
│   └── org/mycompany/
│       ├── Deployer.groovy
│       └── Notifier.groovy
└── resources/      // 资源文件
    └── templates/
        └── deployment.yaml

2. 编写核心函数 `vars/myPipeline.groovy`：

// vars/myPipeline.groovy
def call(Map config = [:]) {
    // 默认配置
    def appName = config.appName ?: 'myapp'
    def deployTarget = config.deployTarget ?: 'dev'
    def skipTests = config.skipTests ?: false
    def dockerRegistry = config.dockerRegistry ?: 'registry.mycompany.com'
    
    pipeline {
        agent any
        
        environment {
            APP_NAME = appName
            DEPLOY_TARGET = deployTarget
            DOCKER_REGISTRY = dockerRegistry
            IMAGE_TAG = "${env.BUILD_NUMBER}"
        }
        
        options {
            timeout(time: 30, unit: 'MINUTES')
            buildDiscarder(logRotator(numToKeepStr: '20'))
            disableConcurrentBuilds()
        }
        
        stages {
            stage('Build') {
                steps {
                    mavenBuild()
                }
            }
            
            stage('Test') {
                when { expression { !skipTests } }
                steps {
                    sh 'mvn test'
                    junit 'target/surefire-reports/TEST-*.xml'
                }
            }
            
            stage('Docker Build') {
                steps {
                    dockerBuild()
                }
            }
            
            stage('Deploy') {
                steps {
                    k8sDeploy(deployTarget)
                }
            }
        }
        
        post {
            failure {
                emailext to: 'team@mycompany.com',
                    subject: "Build Failed: ${env.JOB_NAME} #${env.BUILD_NUMBER}",
                    body: "Check: ${env.BUILD_URL}"
            }
            success {
                echo "Pipeline succeeded! App=${appName}, Env=${deployTarget}"
            }
        }
    }
}

3. 编写子函数 `vars/mavenBuild.groovy`：

// vars/mavenBuild.groovy
def call() {
    sh 'mvn clean package -DskipTests'
    archiveArtifacts artifacts: 'target/*.jar', fingerprint: true
}

4. 编写子函数 `vars/dockerBuild.groovy`：

// vars/dockerBuild.groovy
def call() {
    sh """
        docker build -t ${DOCKER_REGISTRY}/${APP_NAME}:${IMAGE_TAG} .
        docker push ${DOCKER_REGISTRY}/${APP_NAME}:${IMAGE_TAG}
    """
}

5. 编写子函数 `vars/k8sDeploy.groovy`：

// vars/k8sDeploy.groovy
def call(String env) {
    def namespace = "myapp-${env}"
    sh """
        kubectl set image deployment/${APP_NAME} \
            app=${DOCKER_REGISTRY}/${APP_NAME}:${IMAGE_TAG} \
            -n ${namespace}
        kubectl rollout status deployment/${APP_NAME} \
            -n ${namespace} --timeout=180s
    """
}

Manage Jenkins → System → Global Pipeline Libraries：

Library Name: jenkins-shared-lib
Default version: main
Retrieval method: Modern SCM
  → Git
  → Project Repository: https://github.com/your-org/jenkins-shared-lib.git
  → Credentials: your-git-credential

// 项目的 Jenkinsfile（极简版）
@Library('jenkins-shared-lib') _

myPipeline {
    appName = 'order-service'
    deployTarget = 'prod'
    skipTests = false
}

// 另一个项目可以自定义配置
@Library('jenkins-shared-lib@v2.0') _  // 指定版本

myPipeline {
    appName = 'payment-service'
    deployTarget = 'staging'
    dockerRegistry = 'registry.staging.com'
}

// src/org/mycompany/Deployer.groovy
package org.mycompany

class Deployer implements Serializable {
    def script
    String appName
    String registry
    
    Deployer(script, String appName, String registry) {
        this.script = script
        this.appName = appName
        this.registry = registry
    }
    
    void deploy(String env, String tag) {
        def namespace = "${appName}-${env}"
        script.sh """
            kubectl set image deployment/${appName} \
                app=${registry}/${appName}:${tag} -n ${namespace}
            kubectl rollout status deployment/${appName} \
                -n ${namespace} --timeout=180s
        """
    }
    
    void rollback(String env) {
        script.sh "kubectl rollout undo deployment/${appName} -n ${appName}-${env}"
    }
}

// vars/myPipeline.groovy
import org.mycompany.Deployer

def call(Map config = [:]) {
    pipeline {
        agent any
        stages {
            stage('Deploy') {
                steps {
                    script {
                        def deployer = new Deployer(
                            this,
                            config.appName,
                            config.dockerRegistry
                        )
                        deployer.deploy(config.deployTarget, env.BUILD_NUMBER)
                    }
                }
            }
        }
    }
}

共享库分支策略:
main     ← 稳定版本，所有项目默认使用
develop  ← 开发分支，测试新功能
v1.x     ← 维护旧版本
v2.x     ← 当前版本

项目使用方式:
@Library('jenkins-shared-lib') _        // 用 main（默认）
@Library('jenkins-shared-lib@v2.0') _  // 固定版本
@Library('jenkins-shared-lib@develop') _ // 开发版（不推荐生产用）

：《多节点构建：Agent 配置与任务分发策略》——深入 Agent 管理，学习如何根据构建任务类型智能分发到不同节点。

前言 上一篇学会了 Pipeline 语法，但当团队有十几个项目时，每个项目都维护一份完整的 Jenkinsfile，重复代码多、维护成本高。本篇讲两个关键能力：多分支流水线（Multibranch Pipeline）和共享库（Shared Library），解决规模化 CI/CD 的代码复用问题。 一、多分支流水线（Multibranch Pipeline） 解决什么问题 传统 Jenkins ...

【CI/CD·Jenkins篇】Jenkinsfile 最佳实践：多分支流水线与共享库

研发部经理

人工智能

本文介绍了Jenkins多分支流水线与共享库两大核心能力，解决规模化CI/CD代码复用问题。多分支流水线通过一个Job自动管理所有分支构建，支持wildcard过滤；共享库将公共逻辑封装为函数，通过vars/、src/目录实现代码复用，并强调Serializable接口与Git分支版本管理最佳实践。

Agent

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

【CI/CD·Jenkins篇】Jenkinsfile 最佳实践：多分支流水线与共享库

【CI/CD·Jenkins篇】Jenkinsfile 最佳实践：多分支流水线与共享库

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐