Jenkins SpringBoot Docker 搭建CICD流水线部署

Jenkinsfile文件

pipeline {
    agent any

    environment {
        // 定义Docker仓库相关环境变量
        DOCKER_REGISTRY_URL = 'dockerhub.kubekey.local'  // Docker仓库地址
        DOCKER_NAMESPACE = 'huanfa-wy-test'  // 镜像命名空间
        DOCKER_USERNAME = 'admin'  // 仓库用户名
        DOCKER_PASSWORD = 'Harbor12345'  // 仓库密码
        
        // 构建版本号，使用Jenkins构建编号
        BASE_VERSION = "1.0.${BUILD_NUMBER}"
        
        // Maven配置文件路径
        MAVEN_SETTINGS = '/opt/maven/apache-maven-3.9.9/conf/settings-nexus-wuye.xml'
        
        // 应用目标端口
        TARGET_PORT = '8080'
    }

    // 定义构建工具
    tools {
        maven '3.9.9'  // Maven版本
        jdk '17'       // JDK版本
    }

    // 流水线参数定义
    parameters {
        // 模块选择参数
        choice(
            name: 'MODULE_TO_BUILD',
            choices: [
                'wy-workflow'  // 可构建的模块列表
            ],
            description: '选择要构建Docker镜像的模块'
        )
        
        // 环境选择参数
        choice(
            name: 'DEPLOY_PROFILE',
            choices: ['dev', 'test', 'prod'],  // Spring Boot环境配置
            description: 'Spring Boot激活的profile'
        )
    }

    // 流水线阶段定义
    stages {
        // 第一阶段：代码检出
        stage('Checkout') {
            steps {
                git branch: 'master',
                    url: 'http://192.168.2.10:3000/wuye_v2.0/hf-wy-workflow-biz.git',
                    credentialsId: 'huanfa-git'  // Git凭据ID
            }
        }

        // 第二阶段：构建所有模块
        stage('Build All Modules') {
            steps {
                // 使用Maven跳过测试执行构建
                sh "mvn clean install -Dmaven.test.skip=true -s ${MAVEN_SETTINGS}"
            }
        }

        // 第三阶段：更新Dockerfile中的环境配置
        stage('Update Dockerfile Profiles') {
            steps {
                script {
                    echo "🔄 更新Dockerfile中的Spring Profile"
                    echo "目标Profile: ${params.DEPLOY_PROFILE}"
                    echo "目标端口: ${TARGET_PORT}"

                    // 获取需要构建的模块列表
                    def modulesToBuild = getModulesToBuild()
                    
                    // 遍历每个模块，更新其Dockerfile
                    for (module in modulesToBuild) {
                        updateDockerfileProfile(module)
                    }
                }
            }
        }

        // 第四阶段：构建Docker镜像
        stage('Build Docker Images') {
            steps {
                script {
                    // 获取需要构建的模块列表
                    def modulesToBuild = getModulesToBuild()
                    
                    // 遍历每个模块，构建Docker镜像
                    for (module in modulesToBuild) {
                        buildDockerImage(module)
                    }
                }
            }
        }
    }

    // 流水线后置处理
    post {
        // 构建成功后的处理
        success {
            echo "🎉 流水线执行成功！"
            script {
                def modules = getModulesToBuild()
                echo "📋 构建的镜像列表："
                modules.each { module ->
                    def imageName = "${DOCKER_REGISTRY_URL}/${DOCKER_NAMESPACE}/${module}:${BASE_VERSION}"
                    echo "  - ${imageName}"
                }
                echo "🌐 激活Profile: ${params.DEPLOY_PROFILE}"
                echo "🔌 服务端口: ${TARGET_PORT}"
            }
        }
        
        // 构建失败后的处理
        failure {
            echo "❌ 流水线执行失败"
        }
        
        // 无论成功失败都会执行的处理
        always {
            echo "📊 构建信息："
            echo "  构建编号: #${BUILD_NUMBER}"
            echo "  版本标签: ${BASE_VERSION}"
            echo "  构建时间: ${new Date().format('yyyy-MM-dd HH:mm:ss')}"
        }
    }
}

// 函数：获取要构建的模块列表
def getModulesToBuild() {
    // 如果选择ALL则构建所有模块，否则构建指定的单个模块
    if (params.MODULE_TO_BUILD == 'ALL') {
        return [
            'wy-workflow'
        ]
    } else {
        return [params.MODULE_TO_BUILD]
    }
}

// 函数：更新Dockerfile中的Spring Profile配置
def updateDockerfileProfile(String moduleName) {
    echo "📝 更新模块 ${moduleName} 的Dockerfile Profile"

    // 模块路径映射表
    def modulePathMap = [
        'wy-workflow': 'blade-service/wy-workflow'  // 模块名与实际路径的映射
    ]

    // 获取模块对应的实际路径
    def modulePath = modulePathMap[moduleName]
    
    // 获取目标环境配置
    def targetProfile = params.DEPLOY_PROFILE

    if (!modulePath) {
        echo "❌ 未找到模块 ${moduleName} 的路径配置"
        return
    }

    // 切换到模块目录执行操作
    dir("${modulePath}") {
        if (fileExists('Dockerfile')) {
            try {
                // 备份原始Dockerfile，使用构建编号作为备份标识
                sh "cp Dockerfile Dockerfile.backup.${BUILD_NUMBER}"

                echo "原始Dockerfile内容："
                sh "head -20 Dockerfile"

                // 使用sed命令更新Dockerfile中的Spring Profile配置
                sh """
                    # 备份原始内容
                    cp Dockerfile Dockerfile.original

                    # 匹配--spring.profiles.active=后面的值并替换为目标Profile
                    # 处理格式如：["--spring.profiles.active=xxx","--server.port=8080"]
                    sed -i 's/--spring.profiles.active=[^,\"]*/--spring.profiles.active=${targetProfile}/g' Dockerfile

                    # 验证修改结果
                    echo "Profile修改后检查："
                    grep -- "--spring.profiles.active" Dockerfile
                """

                echo "✅ ${moduleName} 的Dockerfile更新成功"
                echo "更新后的相关行："
                sh "grep -n 'spring.profiles.active\\|CMD\\|ENTRYPOINT' Dockerfile"

            } catch (Exception e) {
                // 更新失败时的异常处理
                echo "❌ 更新Dockerfile失败: ${e.getMessage()}"
                echo "恢复备份文件..."
                sh "cp Dockerfile.backup.${BUILD_NUMBER} Dockerfile"
            }
        } else {
            echo "⚠️  ${modulePath}/Dockerfile 不存在"
        }
    }
}

// 函数：构建Docker镜像
def buildDockerImage(String moduleName) {
    echo "🚀 开始构建模块: ${moduleName}"

    // 模块路径映射表
    def modulePathMap = [
        'wy-workflow': 'blade-service/wy-workflow'
    ]

    // 获取模块对应的实际路径
    def modulePath = modulePathMap[moduleName]

    if (!modulePath) {
        echo "❌ 未找到模块 ${moduleName} 的路径配置"
        return
    }

    // 切换到模块目录执行操作
    dir("${modulePath}") {
        if (fileExists('pom.xml')) {
            try {
                echo "📄 执行Docker构建..."
                echo "🏷️  镜像: ${DOCKER_REGISTRY_URL}/${DOCKER_NAMESPACE}/${moduleName}:${BASE_VERSION}"
                echo "⚙️  Profile: ${params.DEPLOY_PROFILE}"

                // 验证Dockerfile中的配置是否正确更新
                echo "🔍 验证Dockerfile配置:"
                sh """
                    echo "Dockerfile中的profile配置:"
                    grep -i "spring.profiles.active" Dockerfile || echo "未找到profile配置"
                    echo ""
                    echo "完整的CMD/ENTRYPOINT行:"
                    grep -E "CMD|ENTRYPOINT" Dockerfile || echo "未找到启动命令"
                """

                // 使用Maven Docker插件构建和推送镜像
                sh """
                    mvn docker:build docker:push \
                        -s ${MAVEN_SETTINGS} \
                        -Ddocker.fabric.skip=false \
                        -Ddocker.registry.url=${DOCKER_REGISTRY_URL} \
                        -Ddocker.username=${DOCKER_USERNAME} \
                        -Ddocker.password=${DOCKER_PASSWORD} \
                        -Ddocker.namespace=${DOCKER_NAMESPACE} \
                        -Ddocker.image.tag=${BASE_VERSION}
                """
                
                echo "✅ ${moduleName} 构建成功"
                echo "📦 镜像地址: ${DOCKER_REGISTRY_URL}/${DOCKER_NAMESPACE}/${moduleName}:${BASE_VERSION}"
                echo "⚙️  运行时参数: --spring.profiles.active=${params.DEPLOY_PROFILE} --server.port=${TARGET_PORT}"

            } catch (Exception e) {
                // 构建失败时的异常处理
                echo "❌ ${moduleName} 构建失败: ${e.getMessage()}"
                // 注意：这里只是记录错误，不会中断其他模块的构建
            }
        } else {
            echo "⚠️  ${modulePath}/pom.xml 不存在"
        }
    }
}