Jenkinsfile 完全指南：从零到生产落地的实战手册

作者：一位在 CI/CD 领域摸爬滚打 5 年的工程师
读完这篇文章，你会理解 Jenkinsfile 的本质，并能独立写出生产级别的流水线

序言：为什么你需要这篇指南？

2019 年，我接手了一个“祖传”项目。发布一次需要：登录 Jenkins → 找到 20 多个参数化构建 → 按特定顺序点击 5 个任务 → 手动记录版本号 → 盯着控制台看 40 分钟。每次发布都像拆弹。

直到我引入了 Jenkinsfile。现在：提交代码 → 自动构建 → 自动测试 → 自动部署。整个团队释放了 30% 的精力去做真正有价值的事。

Jenkinsfile 不是银弹，但它一定是现代 DevOps 实践的基石。

这篇文章，我会用最直白的语言、最真实的案例，带你彻底掌握它。

第一部分：Jenkinsfile 到底是什么？（3 分钟快速理解）

1.1 一句话说清楚

Jenkinsfile 就是用代码写的“自动化脚本”，告诉 Jenkins 一步一步怎么做。

就像你做菜需要菜谱一样：

菜谱告诉你：洗菜 → 切菜 → 下锅 → 装盘
Jenkinsfile 告诉 Jenkins：拉代码 → 编译 → 测试 → 部署

1.2 和传统方式的对比

传统方式（UI 点击）：

text

登录 Jenkins → 新建任务 → 选择构建类型 → 
填一堆表单 → 配置构建步骤 → 保存 → 
手动点击“立即构建”

缺点：

❌ 配置存在 Jenkins 服务器，代码仓库里看不到
❌ 换一台 Jenkins 就要重新配一遍
❌ 团队其他人不知道构建流程
❌ 没法代码审查

Jenkinsfile 方式：

text

pipeline {
    agent any
    stages {
        stage('构建') { steps { sh 'make' } }
        stage('测试') { steps { sh 'make test' } }
        stage('部署') { steps { sh 'deploy.sh' } }
    }
}

优点：

✅ 文件存在代码仓库，和代码一起版本管理
✅ 换 Jenkins 直接指向仓库就能跑
✅ 团队成员都能看到和修改
✅ 可以提 PR 审查修改

1.3 最简示例：让第一个 Pipeline 跑起来

在你的项目根目录创建 Jenkinsfile：

text

pipeline {
    // 在任何可用的 Jenkins 节点上运行
    agent any
    
    stages {
        stage('Hello') {
            steps {
                echo 'Hello, Jenkinsfile!'
            }
        }
        stage('World') {
            steps {
                echo 'Pipeline is working!'
            }
        }
    }
}

提交到 Git，在 Jenkins 创建 Pipeline 任务指向这个文件，点击构建——恭喜，你的第一个 Pipeline 就完成了。

第二部分：核心概念（10 分钟彻底搞懂）

2.1 两种语法：声明式 vs 脚本式

这是初学者最困惑的问题。用一张表说清楚：

对比维度	声明式 Pipeline	脚本式 Pipeline
结构	固定框架 `pipeline {}`	自由编写 `node {}`
语法	像填写表格	像写程序代码
学习难度	低（1 小时上手）	中（需要 Groovy 基础）
适用场景	标准 CI/CD 流程	复杂逻辑、动态流程
官方推荐	✅ 是	特殊场景才用

我的建议： 90% 的情况下用声明式就够了。只有当你需要动态生成 stage、复杂的异常处理时，才考虑脚本式。

2.2 声明式 Pipeline 的核心元素

用一个完整示例来讲解：

text

pipeline {
    // 1. agent：在哪里运行
    agent any                    // 任意节点
    // agent { label 'linux' }   // 指定标签
    // agent { docker 'node:16' } // 在 Docker 容器里运行
    
    // 2. environment：定义环境变量
    environment {
        APP_NAME = 'myapp'
        VERSION = '1.0.0'
    }
    
    // 3. stages：所有阶段（必须）
    stages {
        // 一个 stage 就是一个阶段
        stage('代码拉取') {
            steps {               // steps：这个阶段具体做什么
                checkout scm      // 拉取代码
            }
        }
        
        stage('构建') {
            steps {
                sh 'npm install'  // sh：执行 shell 命令
                sh 'npm run build'
            }
        }
        
        stage('测试') {
            steps {
                sh 'npm test'
            }
        }
        
        stage('部署') {
            steps {
                sh './deploy.sh'
            }
        }
    }
    
    // 4. post：收尾工作（成功/失败后执行）
    post {
        success {
            echo '构建成功！'
        }
        failure {
            echo '构建失败！'
            mail to: 'team@example.com', subject: '构建失败'
        }
    }
}

2.3 最常用的几个指令

`sh` - 执行 Shell 命令

text

// 单行命令
sh 'ls -la'

// 多行命令（推荐）
sh '''
    echo "开始构建"
    npm install
    npm run build
    echo "构建完成"
'''

// 获取命令输出
def output = sh(script: 'git rev-parse HEAD', returnStdout: true).trim()
echo "Git commit: ${output}"

// 获取退出码
def exitCode = sh(script: 'test.sh', returnStatus: true)

`when` - 条件执行

text

stage('部署生产') {
    when {
        branch 'main'              // 只有 main 分支才执行
        // expression { env.BRANCH_NAME == 'main' }  // 等价写法
    }
    steps {
        sh 'deploy-prod.sh'
    }
}

// 更复杂的条件
stage('高级条件') {
    when {
        allOf {                    // 所有条件都满足
            branch 'main'
            environment name: 'DEPLOY', value: 'true'
        }
        anyOf {                    // 任一条件满足
            triggeredBy 'TimerTrigger'
            triggeredBy 'UserId'
        }
    }
    steps {
        sh './special-task.sh'
    }
}

`environment` - 环境变量

text

pipeline {
    environment {
        // 静态变量
        APP_VERSION = '1.0.0'
        
        // 引用其他变量
        FULL_NAME = "myapp-${APP_VERSION}"
        
        // 从凭据读取
        DOCKER_PASS = credentials('docker-hub')  // 生成 DOCKER_PASS_USR 和 DOCKER_PASS_PSW
    }
    
    stages {
        stage('使用环境变量') {
            steps {
                echo "版本: ${APP_VERSION}"
                echo "全名: ${FULL_NAME}"
                sh '''
                    # Shell 中使用
                    echo $APP_VERSION
                    echo $FULL_NAME
                '''
            }
        }
    }
}

`parameters` - 构建参数

text

pipeline {
    parameters {
        string(name: 'TAG', defaultValue: 'latest', description: '镜像标签')
        choice(name: 'ENV', choices: ['dev', 'staging', 'prod'], description: '部署环境')
        booleanParam(name: 'SKIP_TESTS', defaultValue: false, description: '跳过测试')
        password(name: 'API_KEY', defaultValue: '', description: 'API密钥')
    }
    
    stages {
        stage('部署') {
            steps {
                echo "部署环境: ${params.ENV}"
                echo "镜像标签: ${params.TAG}"
                
                if (params.SKIP_TESTS) {
                    echo '跳过测试'
                }
            }
        }
    }
}

2.4 Groovy：你其实已经在用了

很多人说“我不需要学 Groovy”，但实际上你已经在用了。

Groovy 是什么？

Jenkinsfile 的底层语言就是 Groovy
就像写 HTML 不一定要精通 JavaScript，但懂一点能写出更好的代码

只需要掌握这 4 点就够了：

text

// 1. 定义变量
def myVar = 'hello'
def myList = ['a', 'b', 'c']
def myMap = [name: 'jenkins', version: 2.0]

// 2. if/else 条件
if (env.BRANCH_NAME == 'main') {
    echo '主分支'
} else {
    echo '其他分支'
}

// 3. 循环
myList.each { item ->
    echo "元素: ${item}"
}

// 4. 字符串插值
def name = 'world'
echo "hello ${name}"   // 输出: hello world

真的够了！ 我写了 5 年 Jenkinsfile，90% 的情况只用这些。

第三部分：真实经验和最佳实践

3.1 黄金法则：让 Pipeline 快速失败

原则： 越早发现问题，修复成本越低。

text

pipeline {
    stages {
        // 第一件事：参数校验
        stage('参数校验') {
            steps {
                script {
                    if (params.ENV == 'prod' && params.TAG == 'latest') {
                        error('生产环境不允许使用 latest 标签！')
                    }
                }
            }
        }
        
        // 第二件事：代码拉取
        stage('拉取代码') {
            steps {
                checkout scm
            }
        }
        
        // 第三件事：快速检查（语法、格式）
        stage('快速检查') {
            steps {
                sh 'npm run lint'      // 几秒钟
                sh 'npm run type-check' // 几秒钟
            }
        }
        
        // 最后才执行耗时的构建和测试
        stage('完整构建') {
            steps {
                sh 'npm run build'     // 可能需要几分钟
            }
        }
    }
}

3.2 超时和重试：让 Pipeline 更健壮

text

stage('不稳定的测试') {
    steps {
        // 重试 3 次
        retry(3) {
            sh './flaky-test.sh'
        }
        
        // 10 分钟超时
        timeout(time: 10, unit: 'MINUTES') {
            sh './long-task.sh'
        }
        
        // 组合使用
        retry(2) {
            timeout(time: 5, unit: 'MINUTES') {
                sh './unreliable-download.sh'
            }
        }
    }
}

3.3 并行执行：节省一半时间

text

stage('测试') {
    parallel {
        stage('单元测试') {
            steps {
                sh 'npm run test:unit'
            }
        }
        stage('集成测试') {
            steps {
                sh 'npm run test:integration'
            }
        }
        stage('端到端测试') {
            steps {
                sh 'npm run test:e2e'
            }
        }
    }
}

真实效果： 三个测试串行需要 30 分钟，并行只需要 12 分钟（取决于最慢的那个）。

3.4 正确处理构建状态

text

stage('可能失败的步骤') {
    steps {
        script {
            try {
                sh './risky-operation.sh'
            } catch (Exception e) {
                // 标记为不稳定，但不中断构建
                currentBuild.result = 'UNSTABLE'
                echo "操作失败但继续: ${e.message}"
            }
        }
    }
}

stage('必须成功的步骤') {
    steps {
        sh './critical-step.sh'  // 失败会中断构建
    }
}

3.5 调试技巧：快速定位问题

text

// 技巧1：打印所有环境变量
stage('调试信息') {
    steps {
        sh 'env | sort'
    }
}

// 技巧2：打印当前工作目录
steps {
    echo "工作目录: ${pwd()}"
    sh 'ls -la'
}

// 技巧3：条件暂停（仅调试）
stage('手动确认') {
    when {
        expression { return env.DEBUG_MODE == 'true' }
    }
    steps {
        input message: '继续执行？', ok: '是'
    }
}

3.6 常见坑和解决方案

坑1：sh 中的变量问题

text

def version = '1.0.0'

// ❌ 错误：单引号中变量不会被解析
sh './deploy.sh ${version}'

// ✅ 正确：双引号让 Groovy 先解析
sh "./deploy.sh ${version}"

// ✅ 更好：混合使用
sh '''
    # shell 变量
    VERSION="1.0.0"
    echo $VERSION
    
    # Groovy 变量通过双引号传入
    ./deploy.sh "''' + version + '''"
'''

坑2：字符串比较

text

// Groovy 中 == 默认比较内容
if (env.BRANCH_NAME == 'main') {  // ✅ 正确
    // ...
}

// 不需要用 .equals()
if (env.BRANCH_NAME.equals('main')) {  // 也能工作，但啰嗦
    // ...
}

坑3：withCredentials 的作用域

text

// ❌ 错误：凭据只在大括号内有效
withCredentials([string(credentialsId: 'api-key', variable: 'API_KEY')]) {
    sh 'deploy.sh'  // $API_KEY 可用
}
sh 'another.sh'     // ❌ $API_KEY 不可用

// ✅ 正确：将凭据赋值给环境变量
environment {
    API_KEY = credentials('api-key')
}
stages {
    stage('部署') {
        steps {
            sh 'deploy.sh'  // 所有步骤都可用
        }
    }
}

第四部分：生产实践模板（可直接使用）

下面是一个经过多个生产项目验证的 Jenkinsfile 模板。你可以直接复制，修改其中的构建命令即可使用。

4.1 通用模板（适用于大多数项目）

text

pipeline {
    // 配置运行环境
    agent any
    
    // 全局环境变量
    environment {
        // 项目信息
        PROJECT_NAME = 'my-project'
        
        // 构建版本（自动生成）
        BUILD_VERSION = "${env.BUILD_NUMBER}-${env.GIT_COMMIT_SHORT}"
        
        // 时间戳
        BUILD_TIMESTAMP = sh(script: 'date +%Y%m%d-%H%M%S', returnStdout: true).trim()
    }
    
    // 构建参数（用户可配置）
    parameters {
        choice(
            name: 'ENVIRONMENT',
            choices: ['dev', 'staging', 'production'],
            description: '部署环境'
        )
        booleanParam(
            name: 'RUN_TESTS',
            defaultValue: true,
            description: '是否运行测试'
        )
        string(
            name: 'VERSION',
            defaultValue: '',
            description: '版本号（留空则自动生成）'
        )
    }
    
    // 触发方式
    triggers {
        // 每天凌晨 2 点构建
        cron('0 2 * * *')
        // 代码变更时触发（需安装 Poll SCM 插件）
        pollSCM('H/5 * * * *')
    }
    
    // 构建阶段
    stages {
        // 阶段1：准备和校验
        stage('准备') {
            steps {
                script {
                    // 获取 Git 信息
                    env.GIT_COMMIT_SHORT = sh(
                        script: 'git rev-parse --short HEAD',
                        returnStdout: true
                    ).trim()
                    
                    env.GIT_BRANCH = sh(
                        script: 'git rev-parse --abbrev-ref HEAD',
                        returnStdout: true
                    ).trim()
                    
                    // 确定版本号
                    if (params.VERSION && params.VERSION.trim()) {
                        env.RELEASE_VERSION = params.VERSION
                    } else {
                        env.RELEASE_VERSION = "${env.BUILD_NUMBER}-${env.GIT_COMMIT_SHORT}"
                    }
                    
                    echo """
                        项目: ${PROJECT_NAME}
                        分支: ${env.GIT_BRANCH}
                        Commit: ${env.GIT_COMMIT_SHORT}
                        版本: ${env.RELEASE_VERSION}
                        环境: ${params.ENVIRONMENT}
                    """.stripIndent()
                }
            }
        }
        
        // 阶段2：代码拉取
        stage('代码拉取') {
            steps {
                checkout scm
            }
        }
        
        // 阶段3：依赖安装
        stage('依赖安装') {
            steps {
                script {
                    // 根据项目类型选择
                    if (fileExists('package.json')) {
                        sh 'npm ci --cache .npm --prefer-offline'
                    } else if (fileExists('pom.xml')) {
                        sh 'mvn dependency:resolve'
                    } else if (fileExists('requirements.txt')) {
                        sh 'pip install -r requirements.txt'
                    } else if (fileExists('go.mod')) {
                        sh 'go mod download'
                    }
                }
            }
        }
        
        // 阶段4：代码质量检查
        stage('代码检查') {
            when {
                expression { return params.ENVIRONMENT != 'dev' }
            }
            steps {
                parallel {
                    stage('代码风格') {
                        steps {
                            script {
                                if (fileExists('package.json')) {
                                    sh 'npm run lint'
                                } else if (fileExists('.eslintrc')) {
                                    sh 'npx eslint .'
                                }
                            }
                        }
                    }
                    stage('类型检查') {
                        steps {
                            script {
                                if (fileExists('tsconfig.json')) {
                                    sh 'npm run type-check'
                                }
                            }
                        }
                    }
                }
            }
        }
        
        // 阶段5：单元测试
        stage('单元测试') {
            when {
                expression { return params.RUN_TESTS == true }
            }
            steps {
                script {
                    if (fileExists('package.json')) {
                        sh 'npm run test:unit -- --coverage'
                    } else if (fileExists('pom.xml')) {
                        sh 'mvn test'
                    } else if (fileExists('Makefile')) {
                        sh 'make test'
                    }
                }
            }
            post {
                always {
                    // 收集测试报告
                    junit '**/test-results/**/*.xml'
                    junit '**/target/surefire-reports/*.xml'
                    
                    // 归档测试覆盖率
                    publishHTML([
                        reportDir: 'coverage',
                        reportFiles: 'index.html',
                        reportName: '测试覆盖率报告'
                    ])
                }
            }
        }
        
        // 阶段6：构建（编译/打包）
        stage('构建') {
            steps {
                script {
                    if (fileExists('package.json')) {
                        sh 'npm run build'
                    } else if (fileExists('pom.xml')) {
                        sh 'mvn package -DskipTests'
                    } else if (fileExists('Makefile')) {
                        sh 'make build'
                    } else if (fileExists('Dockerfile')) {
                        sh """
                            docker build -t ${PROJECT_NAME}:${env.RELEASE_VERSION} .
                            docker tag ${PROJECT_NAME}:${env.RELEASE_VERSION} \
                                ${PROJECT_NAME}:latest
                        """
                    }
                }
            }
            post {
                success {
                    // 归档构建产物
                    archiveArtifacts artifacts: '**/target/*.jar', allowEmptyArchive: true
                    archiveArtifacts artifacts: '**/dist/**', allowEmptyArchive: true
                }
            }
        }
        
        // 阶段7：集成测试
        stage('集成测试') {
            when {
                allOf {
                    expression { return params.RUN_TESTS == true }
                    expression { return params.ENVIRONMENT != 'production' }
                }
            }
            steps {
                sh '''
                    # 启动服务
                    docker-compose -f docker-compose.test.yml up -d
                    
                    # 等待服务就绪
                    sleep 10
                    
                    # 运行集成测试
                    npm run test:integration
                    
                    # 清理
                    docker-compose -f docker-compose.test.yml down
                '''
            }
        }
        
        // 阶段8：部署
        stage('部署') {
            when {
                expression { return params.ENVIRONMENT != 'dev' }
            }
            steps {
                script {
                    echo "部署到 ${params.ENVIRONMENT} 环境"
                    
                    // 根据不同环境使用不同部署策略
                    switch(params.ENVIRONMENT) {
                        case 'staging':
                            sh "./scripts/deploy-staging.sh ${env.RELEASE_VERSION}"
                            break
                        case 'production':
                            // 生产环境需要确认
                            input message: '确认部署到生产环境？', ok: '确认部署'
                            sh "./scripts/deploy-prod.sh ${env.RELEASE_VERSION}"
                            break
                    }
                }
            }
        }
        
        // 阶段9：健康检查
        stage('健康检查') {
            when {
                expression { return params.ENVIRONMENT == 'production' }
            }
            steps {
                script {
                    def maxRetries = 30
                    def retryCount = 0
                    def healthy = false
                    
                    while (retryCount < maxRetries && !healthy) {
                        try {
                            sh 'curl -f http://localhost:8080/health || exit 1'
                            healthy = true
                            echo "服务健康检查通过"
                        } catch (Exception e) {
                            retryCount++
                            echo "第 ${retryCount} 次检查失败，等待 10 秒..."
                            sleep 10
                        }
                    }
                    
                    if (!healthy) {
                        error("健康检查失败，请检查服务状态")
                    }
                }
            }
        }
    }
    
    // 收尾工作
    post {
        // 无论成功还是失败都执行
        always {
            script {
                // 清理工作空间
                cleanWs()
                
                // 记录构建信息
                def duration = currentBuild.durationString
                def result = currentBuild.currentResult
                
                echo """
                    构建结束
                    结果: ${result}
                    耗时: ${duration}
                    版本: ${env.RELEASE_VERSION}
                """.stripIndent()
            }
        }
        
        // 成功时执行
        success {
            script {
                echo "🎉 构建和部署成功！"
                
                // 发送成功通知（示例：钉钉/飞书/企业微信）
                sh """
                    curl -X POST '${WEBHOOK_URL}' \
                        -H 'Content-Type: application/json' \
                        -d '{
                            "msgtype": "text",
                            "text": {
                                "content": "✅ ${PROJECT_NAME} 部署成功\n环境: ${params.ENVIRONMENT}\n版本: ${env.RELEASE_VERSION}\n查看: ${env.BUILD_URL}"
                            }
                        }'
                """
            }
        }
        
        // 失败时执行
        failure {
            script {
                echo "💥 构建失败！"
                
                // 发送失败通知
                sh """
                    curl -X POST '${WEBHOOK_URL}' \
                        -H 'Content-Type: application/json' \
                        -d '{
                            "msgtype": "text",
                            "text": {
                                "content": "❌ ${PROJECT_NAME} 部署失败\n环境: ${params.ENVIRONMENT}\n阶段: ${env.STAGE_NAME}\n日志: ${env.BUILD_URL}"
                            }
                        }'
                """
                
                // 生产环境失败自动回滚
                if (params.ENVIRONMENT == 'production') {
                    sh "./scripts/rollback.sh"
                    echo "已触发自动回滚"
                }
            }
        }
        
        // 状态不稳定时执行
        unstable {
            echo "⚠️ 构建状态不稳定，请检查测试报告"
        }
        
        // 构建被中止时执行
        aborted {
            echo "构建被用户中止"
        }
    }
}

4.2 不同项目类型的快速配置

Node.js 项目

text

stage('安装') { steps { sh 'npm ci' } }
stage('检查') { steps { sh 'npm run lint' } }
stage('测试') { steps { sh 'npm test' } }
stage('构建') { steps { sh 'npm run build' } }

Java/Maven 项目

text

stage('安装') { steps { sh 'mvn dependency:resolve' } }
stage('测试') { steps { sh 'mvn test' } }
stage('构建') { steps { sh 'mvn package -DskipTests' } }

Python 项目

text

stage('安装') { steps { sh 'pip install -r requirements.txt' } }
stage('检查') { steps { sh 'flake8 .' } }
stage('测试') { steps { sh 'pytest' } }
stage('构建') { steps { sh 'python setup.py sdist' } }

Go 项目

text

stage('安装') { steps { sh 'go mod download' } }
stage('检查') { steps { sh 'golangci-lint run' } }
stage('测试') { steps { sh 'go test -v ./...' } }
stage('构建') { steps { sh 'go build -o app .' } }

第五部分：常见问题速查表

问题	解决方案
变量在 sh 中不生效	使用双引号 `sh "echo ${var}"`
如何获取命令输出	`def out = sh(script: 'cmd', returnStdout: true).trim()`
如何忽略命令失败	`sh 'cmd
如何传递文件到其他 stage	使用 `stash` 和 `unstash`
如何在多个节点运行	使用 `agent { label 'xxx' }` 指定不同节点
如何调试 Pipeline	添加 `echo`、`sh 'env'`、使用 `input` 暂停
凭据不生效	检查 `withCredentials` 作用域，或使用 `environment`
构建日志太大	使用 `set +x` 关闭回显，或只输出最后 N 行

写在最后：一个过来人的建议

1. 不要过度设计

开始的时候，用一个 Jenkinsfile 包含所有 stage 就够了。等真正需要了再去拆分共享库。

2. 从声明式开始

脚本式很强大，但你很可能用不上。声明式已经覆盖了 90% 的场景。

3. 版本控制是底线

Jenkinsfile 一定要提交到 Git，这是"流水线即代码"的核心价值。

4. 让团队所有人都能修改

CI/CD 不是运维一个人的事。让开发也能方便地修改 Jenkinsfile，才能真正实现 DevOps。

5. 持续优化

定期 review 你的 Pipeline：

哪些 stage 可以并行？
哪些测试可以只跑必要部分？
能否缓存依赖加快速度？

学习路径建议

第 1 周：用声明式语法，写出一个能跑通的 Pipeline（拉代码 → 构建 → 测试）
第 2 周：学习 when、environment、parameters，让 Pipeline 更灵活
第 3 周：掌握 parallel、retry、timeout，提升效率和稳定性
第 1 个月：了解 Groovy 基础，能写简单的条件判断和循环
第 3 个月：开始使用共享库，抽离公共逻辑

最后，记住一句话：

Jenkinsfile 是工具，不是目的。它存在的意义是让团队更高效地交付软件，而不是成为新的负担。

希望这篇指南能帮到你。如果有任何问题或建议，欢迎交流讨论。

Happy CI/CD! 🚀

Jenkinsfile 完全指南：从零到生产落地的实战手册

序言：为什么你需要这篇指南？

第一部分：Jenkinsfile 到底是什么？（3 分钟快速理解）

1.1 一句话说清楚

1.2 和传统方式的对比

1.3 最简示例：让第一个 Pipeline 跑起来

第二部分：核心概念（10 分钟彻底搞懂）

2.1 两种语法：声明式 vs 脚本式

2.2 声明式 Pipeline 的核心元素

2.3 最常用的几个指令

sh - 执行 Shell 命令

when - 条件执行

environment - 环境变量

parameters - 构建参数

2.4 Groovy：你其实已经在用了

第三部分：真实经验和最佳实践

3.1 黄金法则：让 Pipeline 快速失败

3.2 超时和重试：让 Pipeline 更健壮

3.3 并行执行：节省一半时间

3.4 正确处理构建状态

3.5 调试技巧：快速定位问题

3.6 常见坑和解决方案

坑1：sh 中的变量问题

坑2：字符串比较

坑3：withCredentials 的作用域

第四部分：生产实践模板（可直接使用）

4.1 通用模板（适用于大多数项目）

4.2 不同项目类型的快速配置

Node.js 项目

Java/Maven 项目

Python 项目

Go 项目

第五部分：常见问题速查表

写在最后：一个过来人的建议

1. 不要过度设计

2. 从声明式开始

3. 版本控制是底线

4. 让团队所有人都能修改

5. 持续优化

学习路径建议

评论

`sh` - 执行 Shell 命令

`when` - 条件执行

`environment` - 环境变量

`parameters` - 构建参数