Jenkins Pipeline 进阶:多平台账号关联与自动化部署

ahcoder 2025-06-08 18:49 1 浏览

引言

在当今快速迭代的软件开发环境中，持续集成和持续交付 (CI/CD) 已成为不可或缺的实践。Jenkins 作为一款开源的自动化服务器，凭借其强大的插件生态系统和灵活的 Pipeline 功能，成为 CI/CD 领域的佼佼者。本文将介绍如何使用 Jenkins Pipeline 实现 CI/CD，并重点讲解如何将钉钉账号与 OpenLDAP 联动，以及如何实现 Jenkins、GitLab、Harbor 和禅道等多平台的账号关联和集成。

架构图

Jenkins Pipeline CI/CD

Jenkins Pipeline 是一种将构建、测试和部署等步骤以代码形式定义的机制。它使用 Groovy DSL 语法，可以将整个 CI/CD 流程编写成一个脚本文件，方便版本控制和重复使用。

部署

如果还没有部署Jenkins，可以使用下面的docker-compose.yml配置快速拉起一个Jenkins

docker-compose.yml

version: '3.7'
services:
  jenkins:
    image: jenkins/jenkins:lts
    container_name: jenkins
    environment:
      - TZ=Asia/Shanghai
    volumes:
      - /data/jenkins/jenkins_home:/var/jenkins_home
      - /var/run/docker.sock:/var/run/docker.sock
      - /usr/bin/docker:/usr/bin/docker
    ports:
      - "8080:8080"
      - "50000:500000"
    expose:
      - "8080"
      - "50000"
    privileged: true
    user: root
    restart: always

配置共享库

系统管理 ->系统配置-> Global Trusted Pipeline Libraries

Jenkins Pipeline CI

CI代码

下面是使用maven构建linux/win平台docker镜像的流程

@Library('jenkins-shared-library@main') _
// 引入 Jenkins 共享库，名称为 'jenkins-shared-library'，使用 'main' 分支。


pipeline {
    agent any
    // 指定 Pipeline 在任何可用的 Jenkins Agent 上运行。


    parameters {
        string(name: 'BRANCH_NAME', defaultValue: 'master', description: 'Git分支名称')
        // 定义一个字符串参数，用于指定 Git 分支名称，默认值为 'master'。


        string(name: 'ZENTAO_REPOPATH', defaultValue: '', description: 'gitlab 项目链接')
        // 定义一个字符串参数，用于指定 GitLab 项目的 URL。


        string(name: 'ZENTAO_ACCOUNT', defaultValue: '', description: 'zentao 用户')
        // 定义一个字符串参数，用于指定禅道（Zentao）的用户名。


        choice(name: 'BUILD_PLATFORM', choices: ['linux', 'windows'], description: '构建平台')
        // 定义一个选择参数，用于指定构建平台，可选值为 'linux' 或 'windows'。
    }


    environment {
        CURRENT_DATE = sh(script: "date +'%Y%m%d%H%M%S'", returnStdout: true).trim()
        // 定义一个环境变量 CURRENT_DATE，值为当前日期时间，格式为 'YYYYMMDDHHMMSS'。


        BUILD_COMMIT = ''
        // 定义一个环境变量 BUILD_COMMIT，初始值为空，后续会存储 Git 提交 ID。


        ImageName = ''
        // 定义一个环境变量 ImageName，初始值为空，后续会存储 Docker 镜像名称。


        GITLAB_GROUP = ''
        // 定义一个环境变量 GITLAB_GROUP，初始值为空，后续会存储 GitLab 项目组名称。


        GITLAB_PROJECT = ''
        // 定义一个环境变量 GITLAB_PROJECT，初始值为空，后续会存储 GitLab 项目名称。
    }


    stages {
        stage("提取项目和项目名") {
            steps {
                script {
                    def res = getGitLabGroupAndProject.extractGitLabInfo(params.ZENTAO_REPOPATH)
                    // 调用共享库中的方法 extractGitLabInfo，从 GitLab 项目 URL 中提取项目组和项目名称。


                    GITLAB_GROUP = res.group
                    // 将提取到的 GitLab 项目组名称赋值给环境变量 GITLAB_GROUP。


                    GITLAB_PROJECT = res.project
                    // 将提取到的 GitLab 项目名称赋值给环境变量 GITLAB_PROJECT。
                }
            }
        }


        stage("构建邮件通知") {
            steps {
                script {
                    // 触发构建消息。
                }
            }
        }


        stage('拉取代码并构建') {
            agent {
                docker {
                    image "${GlobalVars.MavenBuildImage}"
                    // 使用共享库中定义的 Maven 构建镜像。


                    args '-v /data/.m2:/root/.m2 -v /data/jar-package:/data/jar-package'
                    // 挂载宿主机的 Maven 缓存目录和构建产物目录到容器中。


                    reuseNode true
                    // 重用当前节点，避免切换到其他节点。
                }
            }
            steps {
                checkout scmGit(
                    branches: [[name: "*/${params.BRANCH_NAME}"]],
                    // 指定要拉取的分支名称，使用参数 BRANCH_NAME。


                    extensions: [],
                    // 无额外的 Git 扩展配置。


                    userRemoteConfigs: [[
                        credentialsId: "${GlobalVars.GitLabcredentialsId}",
                        // 使用共享库中定义的 GitLab 凭据 ID。


                        url: "https://${GlobalVars.GitlabUrl}/${GITLAB_GROUP}/${GITLAB_PROJECT}.git"
                        // 指定 GitLab 项目的 URL。
                    ]]
                )
                script {
                    sh 'mvn -B -DskipTests clean package'
                    // 使用 Maven 进行构建，跳过测试。


                    sh "cp ruoyi-admin/target/ruoyi-admin.jar /data/jar-package/${GITLAB_GROUP}-${GITLAB_PROJECT}-${CURRENT_DATE}.jar"
                    // 将构建产物（JAR 文件）复制到宿主机的指定目录，并重命名。
                }
            }
        }


        stage('保存构建产物') {
            steps {
                stash includes: 'ruoyi-admin/target/ruoyi-admin.jar', name: 'jar-package'
                // 将构建产物（JAR 文件）保存为 Jenkins 的 stash，供后续阶段使用。
            }
        }


        stage('构建信息') {
            steps {
                script {
                    wrap([$class: 'BuildUser']) {
                        // 使用 Jenkins 的 BuildUser 插件获取构建用户信息。


                        BUILD_USER = "${ZENTAO_ACCOUNT}"
                        // 将禅道用户赋值给环境变量 BUILD_USER。


                        BUILD_NAME = "${GITLAB_GROUP}/${GITLAB_PROJECT}"
                        // 将项目组和项目名称拼接后赋值给环境变量 BUILD_NAME。


                        BUILD_BRANCH = "${BRANCH_NAME}"
                        // 将分支名称赋值给环境变量 BUILD_BRANCH。


                        BUILD_COMMIT = "${getCommitId()}"
                        // 调用共享库中的方法 getCommitId，获取当前 Git 提交 ID，并赋值给环境变量 BUILD_COMMIT。


                        BUILD_PLATFORM = "${params.BUILD_PLATFORM}"
                        // 将构建平台赋值给环境变量 BUILD_PLATFORM。
                    }
                    currentBuild.description = """构建用户: ${BUILD_USER}\n构建项目: ${BUILD_NAME}\n构建分支: ${BUILD_BRANCH}\n构建平台: ${BUILD_PLATFORM}\nMessageID: ${BUILD_COMMIT}
                    """
                    // 设置当前构建的描述信息，包含构建用户、项目、分支、平台和提交 ID。
                }
            }
        }


        stage('构建镜像名称') {
            steps {
                script {
                    ImageName = "${GlobalVars.HarborUrl}/${GITLAB_GROUP}/${GITLAB_PROJECT}:${CURRENT_DATE}-${BUILD_COMMIT}-${params.BUILD_PLATFORM}"
                    // 根据 Harbor 地址、项目组、项目名称、日期、提交 ID 和构建平台生成 Docker 镜像名称。
                }
            }
        }


        stage('打包镜像') {
            steps {
                script {
                    if (params.BUILD_PLATFORM == 'linux') {
                        buildDockerImage.LinuxRuoyiBuild(ImageName)
                        // 如果构建平台是 Linux，调用共享库中的方法 LinuxRuoyiBuild 打包 Docker 镜像。
                    } else if (params.BUILD_PLATFORM == 'windows') {
                        node('win-agent') {
                            unstash 'jar-package'
                            // 如果构建平台是 Windows，切换到 Windows 节点，并恢复之前保存的构建产物。


                            buildDockerImage.WindowsRuoyiBuild(ImageName)
                            // 调用共享库中的方法 WindowsRuoyiBuild 打包 Docker 镜像。
                        }
                    }
                }
            }
        }


        stage('推送镜像') {
            steps {
                script {
                    if (params.BUILD_PLATFORM == 'linux') {
                        withDockerRegistry(credentialsId: "${GlobalVars.HarborcredentialsId}", url: "https://${GlobalVars.HarborUrl}") {
                            sh "docker push ${ImageName}"
                            // 如果构建平台是 Linux，推送 Docker 镜像到 Harbor。


                            sh "docker rmi ${ImageName}"
                            // 删除本地 Docker 镜像以释放空间。
                        }
                    } else if (params.BUILD_PLATFORM == 'windows') {
                        node('win-agent') {
                            withDockerRegistry(credentialsId: "${GlobalVars.HarborcredentialsId}", url: "https://${GlobalVars.HarborUrl}") {
                                bat "docker push ${ImageName}"
                                // 如果构建平台是 Windows，推送 Docker 镜像到 Harbor。


                                bat "docker rmi ${ImageName}"
                                // 删除本地 Docker 镜像以释放空间。
                            }
                        }
                    }
                }
            }
        }
    }


    post {
        always {
            cleanWs()
            // 无论构建成功与否，始终清理工作空间。
        }
        success {
            script {
                // 构建成功时发送通知。
            }
        }
        unsuccessful {
            script {
                // 构建失败时发送通知。
            }
        }
    }
}

该 Jenkins Pipeline 脚本实现了一个完整的 CI 流程

参数化构建：支持动态指定 Git 分支、GitLab 项目、禅道用户和构建平台。
代码拉取与构建：从 GitLab 拉取代码并使用 Maven 进行构建。
镜像打包与推送：根据构建平台（Linux 或 Windows）打包 Docker 镜像并推送到 Harbor。
构建信息记录：记录构建用户、项目、分支、平台和提交 ID 等信息。
通知与清理：支持构建成功或失败时发送通知，并始终清理工作空间。

通过共享库的使用，脚本的逻辑更加简洁和模块化，便于维护和扩展。

创建构建流程

写好CI流程，下面在Jenkins添加构建流程

基于禅道关联Jenkins任务

禅道平台配置关联jenkins，方便用户调用触发

Jenkins Pipeline CD

CD 代码

@Library('jenkins-shared-library@main') _
// 引入 Jenkins 共享库，名称为 'jenkins-shared-library'，使用 'main' 分支。


pipeline {
    agent any
    // 指定 Pipeline 在任何可用的 Jenkins Agent 上运行。


    parameters {
        string(name: 'SSH_USER', defaultValue: 'root', description: 'SSH User')
        // 定义一个字符串参数，用于指定 SSH 用户，默认值为 'root'。


        string(name: 'TARGET_IP', defaultValue: '', description: '部署机器 IP 地址')
        // 定义一个字符串参数，用于指定目标机器的 IP 地址。


        string(name: 'DOCKER_IMAGE', defaultValue: '', description: '运行服务镜像地址')
        // 定义一个字符串参数，用于指定 Docker 镜像的名称。


        string(name: 'IMAGE_VERSION', defaultValue: '', description: '运行服务镜像版本号')
        // 定义一个字符串参数，用于指定 Docker 镜像的版本号。


        string(name: 'SERVICE_NAME', defaultValue: '', description: '容器运行名称')
        // 定义一个字符串参数，用于指定 Docker 容器的名称。


        string(name: 'PORT_MAPPING', defaultValue: '', description: '端口映射,eg: 8080:8080')
        // 定义一个字符串参数，用于指定 Docker 容器的端口映射。


        string(name: 'ENV_VARIABLES', defaultValue: '', description: '环境变量,eg: KEY="VALUE",KEY2="VALUE2"')
        // 定义一个字符串参数，用于指定 Docker 容器的环境变量。
    }


    environment {
        SEND_BUILD_USER_EMAIL = ''
        // 定义一个环境变量 SEND_BUILD_USER_EMAIL，初始值为空，后续会存储构建用户的邮箱。
    }


    stages {
        stage('获取参数') {
            steps {
                script {
                    withBuildUser {
                        SEND_BUILD_USER_EMAIL = env.BUILD_USER_EMAIL
                        // 使用 Jenkins 的 BuildUser 插件获取构建用户的邮箱，并赋值给环境变量 SEND_BUILD_USER_EMAIL。
                    }


                    // 检查参数是否为空
                    if (!params.SSH_USER?.trim()) {
                        error "SSH 用户不能为空！"
                        // 如果 SSH 用户为空，抛出错误并终止 Pipeline。
                    }
                    if (!params.TARGET_IP?.trim()) {
                        error "目标机器 IP 地址不能为空！"
                        // 如果目标机器 IP 地址为空，抛出错误并终止 Pipeline。
                    }
                    if (!params.SERVICE_NAME?.trim()) {
                        error "服务名称不能为空！"
                        // 如果服务名称为空，抛出错误并终止 Pipeline。
                    }
                    if (!params.DOCKER_IMAGE?.trim()) {
                        error "Docker 镜像名称不能为空！"
                        // 如果 Docker 镜像名称为空，抛出错误并终止 Pipeline。
                    }
                    if (!params.IMAGE_VERSION?.trim()) {
                        error "Docker 镜像版本号不能为空！"
                        // 如果 Docker 镜像版本号为空，抛出错误并终止 Pipeline。
                    }
                    if (!params.PORT_MAPPING?.trim()) {
                        error "端口映射不能为空！"
                        // 如果端口映射为空，抛出错误并终止 Pipeline。
                    }
                }
            }
        }


        stage('部署服务') {
            steps {
                script {
                    def envVariables = ""
                    if (params.ENV_VARIABLES?.trim()) {
                        def envList = params.ENV_VARIABLES.split(',')
                        envVariables = envList.collect { envVar ->
                            "-e ${envVar.trim()}"
                        }.join(' ')
                        // 如果环境变量参数不为空，将其拆分为多个环境变量，并格式化为 Docker 命令中的 `-e` 参数。
                    }


                    def dockerCommand = ""
                    withCredentials([usernamePassword(credentialsId: 'devops_harbor', passwordVariable: 'HARBOR_PASSWORD', usernameVariable: 'HARBOR_USERNAME')]) {
                        // 使用 Jenkins 的 Credentials 插件获取 Harbor 仓库的用户名和密码。


                        dockerCommand = """
                            docker login harbor.wuyinit.com -u $HARBOR_USERNAME -p $HARBOR_PASSWORD &&
                            docker pull ${params.DOCKER_IMAGE}:${params.IMAGE_VERSION} &&
                            docker stop ${params.SERVICE_NAME} || true &&
                            docker rm ${params.SERVICE_NAME} || true &&
                            docker run -itd --name ${params.SERVICE_NAME} -p ${params.PORT_MAPPING} ${envVariables} ${params.DOCKER_IMAGE}:${params.IMAGE_VERSION}
                        """
                        // 构建 Docker 命令，包括：
                        // 1. 登录 Harbor 仓库。
                        // 2. 拉取指定版本的 Docker 镜像。
                        // 3. 停止并删除已存在的同名容器。
                        // 4. 启动新的容器，并指定名称、端口映射和环境变量。
                    }


                    sshagent(['deploy-agent-key']) {
                        // 使用 Jenkins 的 SSH Agent 插件，加载指定的 SSH 私钥（'deploy-agent-key'）。


                        sh """
                        ssh -o StrictHostKeyChecking=no ${params.SSH_USER}@${params.TARGET_IP} << 'EOF'
                        ${dockerCommand}
EOF
                        """
                        // 通过 SSH 连接到目标机器，并执行 Docker 命令。
                    }
                }
            }
        }
    }


    post {
        success {
            script {
                // 构建成功时发送邮件通知。
            }
        }


        unsuccessful {
            script {
                // 构建失败时发送邮件通知。
            }
        }
    }
}

该 Jenkins Pipeline 脚本实现了一个完整的服务部署流程，包括：

参数化构建：支持动态指定 SSH 用户、目标机器 IP、Docker 镜像、版本号、服务名称、端口映射和环境变量。
参数检查：确保所有必填参数不为空。
服务部署：
登录 Harbor 仓库并拉取 Docker 镜像。
停止并删除已存在的同名容器。
启动新的容器，并指定名称、端口映射和环境变量。
通知与清理：支持构建成功或失败时发送通知。

通过共享库和 Jenkins 插件（如 Credentials、SSH Agent）的使用，脚本的逻辑更加简洁和模块化，便于维护和扩展。

钉钉与OpenLDAP的联动

为了实现统一身份认证，并基于现有的钉钉组织和人员信息，将Jenkins、GitLab、Harbor 和禅道等多平台的账号关联，我们可以使用 OpenLDAP 作为统一的用户认证中心。具体步骤如下：

1.配置 Go-Ldap-Admin 等服务：将钉钉通讯录中的用户和组织结构同步到 OpenLDAP 服务器。

2.配置各平台使用 OpenLDAP 认证： 在 Jenkins、GitLab、Harbor 和禅道的系统设置中，配置 LDAP 认证，并指定 OpenLDAP 服务器的地址、端口、Base DN 等信息。

docker-compose参考，详情查看

version: '3'


networks:
  go-ldap-admin:
    driver: bridge


services:
  go-ldap-admin:
    image: registry.cn-hangzhou.aliyuncs.com/eryajf/go-ldap-admin
    container_name: go-ldap-admin
    hostname: go-ldap-admin
    restart: always
    environment:
      WAIT_HOSTS: openldap:389
    configs:
      - source: go_ldap_admin_config
        target: /app/config.yml
    ports:
      - 8888:8888
    volumes:
      - ./data/go-ldap-admin:/app/data
    depends_on:
      - openldap
    links:
      - openldap:go-ldap-admin-openldap
    networks:
      - go-ldap-admin


  openldap:
    image: registry.cn-hangzhou.aliyuncs.com/eryajf/openldap:1.4.1
    container_name: go-ldap-admin-openldap
    hostname: go-ldap-admin-openldap
    restart: always
    environment:
      TZ: Asia/Shanghai
      LDAP_ORGANISATION: "eryajf.net"
      LDAP_DOMAIN: "eryajf.net"
      LDAP_ADMIN_PASSWORD: "123456"
    command: [ '--copy-service' ]
    volumes:
      - ./data/openldap/database:/var/lib/ldap
      - ./data/openldap/config:/etc/ldap/slapd.d
    ports:
      - 389:389
    networks:
      - go-ldap-admin

总结

通过 Jenkins Pipeline、OpenLDAP 和钉钉的集成，我们可以实现高效的 CI/CD 流程，并统一管理多平台的用户账号。本文提供的方案只是一个简单的示例，实际应用中可以根据具体需求进行调整和扩展。

未来展望

未来，我们可以探索以下方向：

使用 Kubernetes 进行容器化部署，进一步提高资源利用率和部署效率。
引入代码质量分析工具，例如 SonarQube，提升代码质量。
实现自动化测试，例如使用 Selenium 进行 UI 自动化测试。

如有相关问题，请在文章后面给小编留言，小编安排作者第一时间和您联系，为您答疑解惑。

参考文献

Jenkins 官方文档: https://www.jenkins.io/doc/
OpenLDAP 官方文档:https://www.openldap.org/doc/
钉钉开发者文档:https://open.dingtalk.com/document/orgapp-server
Go-Ldap-Admin: https://ldapdoc.eryajf.net/

linux sh

Jenkins Pipeline 进阶:多平台账号关联与自动化部署

配置共享库

Jenkins Pipeline CI

CI代码

创建构建流程

基于禅道关联Jenkins任务

Jenkins Pipeline CD

CD 代码

相关推荐

为什么有人认为Linux不如macOS?

linux系统实用篇-8、系统配置与优化

Linux中如何启用root用户

执手的Linux运维小知识:sshpass工具简化ssh密码输入

6款Linux常用远程连接工具，你最中意哪一款?

如何远程执行Linux命令和脚本?大技霸来教你

Windows如何远程linux(桌面版)

如何使用 Linux find 命令查找文件?

Rackspace的所有平台将支持Ubuntu Linux

这次答应我，一举拿下 I/O 多路复用