Jenkinsfile案例

wen java案例 2026-08-02 2

本文目录导读：

Jenkinsfile案例

案例 1：最简单的声明式 Pipeline
案例 2：多分支 + 环境变量 + 参数化构建
案例 3：使用 Docker + 并行阶段
案例 4：包含 K8s 部署和审批
案例 5：复杂流程 - 多项目共享库
最佳实践建议

这里为您提供几个不同场景的 Jenkinsfile 案例，从最简单到复杂，并附带详细注释。

案例 1：最简单的声明式 Pipeline

适用于：简单的构建、测试、打包，无并行、无多环境。

// 声明式 Pipeline
pipeline {
    // 在任何可用的 Agent 上运行
    agent any
    // 定义环境变量
    environment {
        APP_NAME = 'my-app'
        VERSION = '1.0.0'
    }
    // 定义阶段
    stages {
        stage('Checkout') {
            steps {
                // 从 Git 拉取代码
                checkout scm
                echo "代码已拉取，版本: ${VERSION}"
            }
        }
        stage('Build') {
            steps {
                echo "开始构建 ${APP_NAME}..."
                // 假设是 Maven 项目
                // sh 'mvn clean package'
                // 如果没有 Maven，模拟构建
                sh 'echo "构建完成" > artifact.jar'
            }
        }
        stage('Test') {
            steps {
                echo "运行单元测试..."
                // sh 'mvn test'
            }
        }
        stage('Deploy') {
            steps {
                echo "部署到测试服务器..."
                // 模拟部署
                sh 'echo "部署成功"'
            }
        }
    }
    // 构建后操作
    post {
        always {
            echo 'Pipeline 结束，清理工作区...'
            cleanWs()
        }
        success {
            echo "构建成功！"
        }
        failure {
            echo "构建失败，请查看日志。"
        }
    }
}

案例 2：多分支 + 环境变量 + 参数化构建

适用于：开发、测试、生产多环境，需要手动或自动选择构建参数。

pipeline {
    agent any
    // 参数化构建（点击"Build with Parameters"后可选择）
    parameters {
        choice(name: 'ENVIRONMENT', choices: ['dev', 'staging', 'prod'], description: '选择部署环境')
        string(name: 'BRANCH', defaultValue: 'develop', description: '要构建的分支')
        booleanParam(name: 'SKIP_TESTS', defaultValue: false, description: '是否跳过测试')
    }
    // 设置环境变量（根据选择的参数动态设置）
    environment {
        // 根据环境设置不同的服务器地址
        DEV_SERVER = 'dev.example.com'
        PROD_SERVER = 'prod.example.com'
    }
    stages {
        stage('Checkout') {
            when {
                // 仅当分支匹配时才执行
                branch 'develop', 'main', 'release/*'
            }
            steps {
                checkout scm
                echo "检查分支: ${params.BRANCH}"
            }
        }
        stage('Build') {
            steps {
                echo "构建环境: ${params.ENVIRONMENT}"
                // 不同环境执行不同命令
                if (params.ENVIRONMENT == 'dev') {
                    sh 'echo "开发模式构建"'
                } else if (params.ENVIRONMENT == 'prod') {
                    sh 'echo "生产模式构建，使用压缩优化"'
                }
            }
        }
        stage('Test') {
            when {
                // 只有当 SKIP_TESTS 为 false 时执行
                not { expression { params.SKIP_TESTS } }
            }
            steps {
                echo "运行测试..."
            }
        }
        stage('Deploy') {
            steps {
                // 根据环境部署到不同服务器
                script {
                    def targetServer = params.ENVIRONMENT == 'dev' ? DEV_SERVER : PROD_SERVER
                    echo "正在部署到 ${targetServer}..."
                    sh "echo '部署到 ${targetServer} 成功'"
                }
            }
        }
    }
}

案例 3：使用 Docker + 并行阶段

适用于：微服务、多模块项目，需要并行构建多个子项目。

pipeline {
    agent any
    options {
        // 保留最近 5 次构建
        buildDiscarder(logRotator(numToKeepStr: '5'))
        // 超时时间 30 分钟
        timeout(time: 30, unit: 'MINUTES')
        // 不打印默认的前缀
        disableConcurrentBuilds()
    }
    stages {
        stage('准备') {
            steps {
                sh 'echo "检查环境...: $(pwd)"'
                sh 'docker --version'
                sh 'node --version'
            }
        }
        // 并行执行多个模块的构建和测试
        stage('并行构建和测试') {
            parallel {
                stage('前端 (React)') {
                    agent { label 'node-agent' }  // 使用指定标签的 agent
                    steps {
                        sh '''
                            cd frontend
                            npm install
                            npm run build
                            npm test
                        '''
                    }
                }
                stage('后端 (Spring Boot)') {
                    steps {
                        sh '''
                            cd backend
                            mvn clean package -DskipTests=false
                        '''
                    }
                }
                stage('数据库脚本') {
                    steps {
                        sh '''
                            echo "执行数据库迁移脚本..."
                            ls database/
                        '''
                    }
                }
            }
        }
        stage('构建 Docker 镜像') {
            steps {
                script {
                    // 根据后端构建的 jar 包构建镜像
                    sh '''
                        cd backend
                        docker build -t my-backend:${BUILD_NUMBER} .
                    '''
                }
            }
        }
        stage('推送镜像') {
            steps {
                sh '''
                    docker tag my-backend:${BUILD_NUMBER} myregistry.com/my-backend:latest
                    docker push myregistry.com/my-backend:latest
                '''
            }
        }
    }
    post {
        always {
            sh 'docker system prune -f'  // 清理无用镜像
        }
    }
}

案例 4：包含 K8s 部署和审批

适用于：生产环境，需要手动审批才部署。

pipeline {
    agent any
    environment {
        REGISTRY = 'registry.example.com'
        IMAGE_NAME = 'my-service'
        IMAGE_TAG = "${GIT_COMMIT.take(8)}"  // 使用 Git 短哈希作为标签
        K8S_NAMESPACE = 'production'
    }
    stages {
        stage('构建和推送镜像') {
            steps {
                script {
                    sh "docker build -t ${REGISTRY}/${IMAGE_NAME}:${IMAGE_TAG} ."
                    sh "docker push ${REGISTRY}/${IMAGE_NAME}:${IMAGE_TAG}"
                }
            }
        }
        stage('部署到 K8s') {
            steps {
                script {
                    // 使用 kubectl 更新部署
                    sh """
                        kubectl set image deployment/${IMAGE_NAME} \
                            ${IMAGE_NAME}=${REGISTRY}/${IMAGE_NAME}:${IMAGE_TAG} \
                            -n ${K8S_NAMESPACE}
                        kubectl rollout status deployment/${IMAGE_NAME} -n ${K8S_NAMESPACE}
                    """
                }
            }
        }
        stage('冒烟测试') {
            steps {
                sh '''
                    echo "运行冒烟测试..."
                    curl -f http://localhost:8080/health || exit 1
                '''
            }
        }
    }
    post {
        success {
            echo "✨ 部署成功！访问 http://my-service.example.com"
        }
        failure {
            echo "❌ 部署失败，正在回滚..."
            // 模拟回滚
            sh 'echo "执行回滚操作"'
        }
    }
}

案例 5：复杂流程 - 多项目共享库

// 加载共享库
@Library('my-shared-library') _
def buildDocker(String module, String env) {
    // 使用共享库中的函数
    utils.buildDockerImage(module, env)
}
pipeline {
    agent any
    tools {
        maven 'M3'
        jdk 'JDK11'
    }
    environment {
        // 从 Credentials 获取敏感信息
        DOCKER_REGISTRY = credentials('docker-registry')
        K8S_CREDENTIALS = credentials('k8s-prod')
    }
    stages {
        stage('多模块并行构建') {
            parallel {
                stage('Module A') {
                    steps { buildDocker('module-a', 'dev') }
                }
                stage('Module B') {
                    steps { buildDocker('module-b', 'dev') }
                }
            }
        }
        stage('分布式测试') {
            steps {
                script {
                    // 使用插件
                    catchError(buildResult: 'UNSTABLE', stageResult: 'FAILURE') {
                        script {
                            // 执行测试
                            if (params.RUN_PERFORMANCE_TEST) {
                                // 跑性能测试
                            }
                        }
                    }
                }
            }
        }
    }
}

特性	推荐用法
声明式 vs 脚本式	推荐声明式，更易读、易维护
Agent	根据阶段使用不同 agent：`agent any`、`agent { label 'docker' }`
参数化	用 `parameters` 定义用户输入
环境变量	用 `environment` 定义全局环境变量
条件执行	用 `when` 块控制阶段是否执行
并行执行	用 `parallel` 块实现并行构建
错误处理	用 `post` 和 `catchError` 处理失败情况
敏感信息	用 `credentials` 存储用户名密码/Token
超时控制	用 `options` 中的 `timeout` 防止卡死

最佳实践建议

保持简单 - 不要过度设计，只写需要的 Stage
使用插件 - 优先使用 Jenkins 生态中成熟的插件
错误处理 - 重要步骤要加 catchError 或 post 处理
清晰命名 - Stage 名称要能清晰表达其功能
共享库 - 多个 Pipeline 复用的代码抽取到共享库
安全 - 敏感信息绝对不要硬编码在 Pipeline 中
日志 - 在关键步骤添加清晰的日志输出

需要针对特定场景的详细配置（GitLab、Gitee、K8s、Docker 等），告诉我您的具体需求，我可以提供更详细的配置。