Jenkins Pipeline 進階：多平臺賬號關(guān)聯(lián)與自動化部署

作者：徐凱 2025-02-13 07:58:21

本文將介紹如何使用 Jenkins Pipeline 實現(xiàn) CI/CD，并重點講解如何將釘釘賬號與 OpenLDAP 聯(lián)動，以及如何實現(xiàn) Jenkins、GitLab、Harbor 和禪道等多平臺的賬號關(guān)聯(lián)和集成。

引言

在當今快速迭代的軟件開發(fā)環(huán)境中，持續(xù)集成和持續(xù)交付 (CI/CD) 已成為不可或缺的實踐。Jenkins 作為一款開源的自動化服務器，憑借其強大的插件生態(tài)系統(tǒng)和靈活的 Pipeline 功能，成為 CI/CD 領域的佼佼者。本文將介紹如何使用 Jenkins Pipeline 實現(xiàn) CI/CD，并重點講解如何將釘釘賬號與 OpenLDAP 聯(lián)動，以及如何實現(xiàn) Jenkins、GitLab、Harbor 和禪道等多平臺的賬號關(guān)聯(lián)和集成。

架構(gòu)圖

Jenkins Pipeline CI/CD

Jenkins Pipeline 是一種將構(gòu)建、測試和部署等步驟以代碼形式定義的機制。它使用 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

配置共享庫

系統(tǒng)管理 ->系統(tǒng)配置-> Global Trusted Pipeline Libraries。

Jenkins Pipeline CI

CI代碼

下面是使用maven構(gòu)建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分支名稱')
        // 定義一個字符串參數(shù)，用于指定 Git 分支名稱，默認值為 'master'。

        string(name: 'ZENTAO_REPOPATH', defaultValue: '', description: 'gitlab 項目鏈接')
        // 定義一個字符串參數(shù)，用于指定 GitLab 項目的 URL。

        string(name: 'ZENTAO_ACCOUNT', defaultValue: '', description: 'zentao 用戶')
        // 定義一個字符串參數(shù)，用于指定禪道（Zentao）的用戶名。

        choice(name: 'BUILD_PLATFORM', choices: ['linux', 'windows'], description: '構(gòu)建平臺')
        // 定義一個選擇參數(shù)，用于指定構(gòu)建平臺，可選值為 'linux' 或 'windows'。
    }

    environment {
        CURRENT_DATE = sh(script: "date +'%Y%m%d%H%M%S'", returnStdout: true).trim()
        // 定義一個環(huán)境變量 CURRENT_DATE，值為當前日期時間，格式為 'YYYYMMDDHHMMSS'。

        BUILD_COMMIT = ''
        // 定義一個環(huán)境變量 BUILD_COMMIT，初始值為空，后續(xù)會存儲 Git 提交 ID。

        ImageName = ''
        // 定義一個環(huán)境變量 ImageName，初始值為空，后續(xù)會存儲 Docker 鏡像名稱。

        GITLAB_GROUP = ''
        // 定義一個環(huán)境變量 GITLAB_GROUP，初始值為空，后續(xù)會存儲 GitLab 項目組名稱。

        GITLAB_PROJECT = ''
        // 定義一個環(huán)境變量 GITLAB_PROJECT，初始值為空，后續(xù)會存儲 GitLab 項目名稱。
    }

    stages {
        stage("提取項目和項目名") {
            steps {
                script {
                    def res = getGitLabGroupAndProject.extractGitLabInfo(params.ZENTAO_REPOPATH)
                    // 調(diào)用共享庫中的方法 extractGitLabInfo，從 GitLab 項目 URL 中提取項目組和項目名稱。

                    GITLAB_GROUP = res.group
                    // 將提取到的 GitLab 項目組名稱賦值給環(huán)境變量 GITLAB_GROUP。

                    GITLAB_PROJECT = res.project
                    // 將提取到的 GitLab 項目名稱賦值給環(huán)境變量 GITLAB_PROJECT。
                }
            }
        }

        stage("構(gòu)建郵件通知") {
            steps {
                script {
                    // 觸發(fā)構(gòu)建消息。
                }
            }
        }

        stage('拉取代碼并構(gòu)建') {
            agent {
                docker {
                    image "${GlobalVars.MavenBuildImage}"
                    // 使用共享庫中定義的 Maven 構(gòu)建鏡像。

                    args '-v /data/.m2:/root/.m2 -v /data/jar-package:/data/jar-package'
                    // 掛載宿主機的 Maven 緩存目錄和構(gòu)建產(chǎn)物目錄到容器中。

                    reuseNode true
                    // 重用當前節(jié)點，避免切換到其他節(jié)點。
                }
            }
            steps {
                checkout scmGit(
                    branches: [[name: "*/${params.BRANCH_NAME}"]],
                    // 指定要拉取的分支名稱，使用參數(shù) BRANCH_NAME。

                    extensions: [],
                    // 無額外的 Git 擴展配置。

                    userRemoteConfigs: [[
                        credentialsId: "${GlobalVars.GitLabcredentialsId}",
                        // 使用共享庫中定義的 GitLab 憑據(jù) ID。

                        url: "https://${GlobalVars.GitlabUrl}/${GITLAB_GROUP}/${GITLAB_PROJECT}.git"
                        // 指定 GitLab 項目的 URL。
                    ]]
                )
                script {
                    sh 'mvn -B -DskipTests clean package'
                    // 使用 Maven 進行構(gòu)建，跳過測試。

                    sh "cp ruoyi-admin/target/ruoyi-admin.jar /data/jar-package/${GITLAB_GROUP}-${GITLAB_PROJECT}-${CURRENT_DATE}.jar"
                    // 將構(gòu)建產(chǎn)物（JAR 文件）復制到宿主機的指定目錄，并重命名。
                }
            }
        }

        stage('保存構(gòu)建產(chǎn)物') {
            steps {
                stash includes: 'ruoyi-admin/target/ruoyi-admin.jar', name: 'jar-package'
                // 將構(gòu)建產(chǎn)物（JAR 文件）保存為 Jenkins 的 stash，供后續(xù)階段使用。
            }
        }

        stage('構(gòu)建信息') {
            steps {
                script {
                    wrap([$class: 'BuildUser']) {
                        // 使用 Jenkins 的 BuildUser 插件獲取構(gòu)建用戶信息。

                        BUILD_USER = "${ZENTAO_ACCOUNT}"
                        // 將禪道用戶賦值給環(huán)境變量 BUILD_USER。

                        BUILD_NAME = "${GITLAB_GROUP}/${GITLAB_PROJECT}"
                        // 將項目組和項目名稱拼接后賦值給環(huán)境變量 BUILD_NAME。

                        BUILD_BRANCH = "${BRANCH_NAME}"
                        // 將分支名稱賦值給環(huán)境變量 BUILD_BRANCH。

                        BUILD_COMMIT = "${getCommitId()}"
                        // 調(diào)用共享庫中的方法 getCommitId，獲取當前 Git 提交 ID，并賦值給環(huán)境變量 BUILD_COMMIT。

                        BUILD_PLATFORM = "${params.BUILD_PLATFORM}"
                        // 將構(gòu)建平臺賦值給環(huán)境變量 BUILD_PLATFORM。
                    }
                    currentBuild.description = """構(gòu)建用戶: ${BUILD_USER}\n構(gòu)建項目: ${BUILD_NAME}\n構(gòu)建分支: ${BUILD_BRANCH}\n構(gòu)建平臺: ${BUILD_PLATFORM}\nMessageID: ${BUILD_COMMIT}
                    """
                    // 設置當前構(gòu)建的描述信息，包含構(gòu)建用戶、項目、分支、平臺和提交 ID。
                }
            }
        }

        stage('構(gòu)建鏡像名稱') {
            steps {
                script {
                    ImageName = "${GlobalVars.HarborUrl}/${GITLAB_GROUP}/${GITLAB_PROJECT}:${CURRENT_DATE}-${BUILD_COMMIT}-${params.BUILD_PLATFORM}"
                    // 根據(jù) Harbor 地址、項目組、項目名稱、日期、提交 ID 和構(gòu)建平臺生成 Docker 鏡像名稱。
                }
            }
        }

        stage('打包鏡像') {
            steps {
                script {
                    if (params.BUILD_PLATFORM == 'linux') {
                        buildDockerImage.LinuxRuoyiBuild(ImageName)
                        // 如果構(gòu)建平臺是 Linux，調(diào)用共享庫中的方法 LinuxRuoyiBuild 打包 Docker 鏡像。
                    } else if (params.BUILD_PLATFORM == 'windows') {
                        node('win-agent') {
                            unstash 'jar-package'
                            // 如果構(gòu)建平臺是 Windows，切換到 Windows 節(jié)點，并恢復之前保存的構(gòu)建產(chǎn)物。


                            buildDockerImage.WindowsRuoyiBuild(ImageName)
                            // 調(diào)用共享庫中的方法 WindowsRuoyiBuild 打包 Docker 鏡像。
                        }
                    }
                }
            }
        }

        stage('推送鏡像') {
            steps {
                script {
                    if (params.BUILD_PLATFORM == 'linux') {
                        withDockerRegistry(credentialsId: "${GlobalVars.HarborcredentialsId}", url: "https://${GlobalVars.HarborUrl}") {
                            sh "docker push ${ImageName}"
                            // 如果構(gòu)建平臺是 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}"
                                // 如果構(gòu)建平臺是 Windows，推送 Docker 鏡像到 Harbor。

                                bat "docker rmi ${ImageName}"
                                // 刪除本地 Docker 鏡像以釋放空間。
                            }
                        }
                    }
                }
            }
        }
    }

    post {
        always {
            cleanWs()
            // 無論構(gòu)建成功與否，始終清理工作空間。
        }
        success {
            script {
                // 構(gòu)建成功時發(fā)送通知。
            }
        }
        unsuccessful {
            script {
                // 構(gòu)建失敗時發(fā)送通知。
            }
        }
    }
}

該 Jenkins Pipeline 腳本實現(xiàn)了一個完整的 CI 流程

參數(shù)化構(gòu)建：支持動態(tài)指定 Git 分支、GitLab 項目、禪道用戶和構(gòu)建平臺。
代碼拉取與構(gòu)建：從 GitLab 拉取代碼并使用 Maven 進行構(gòu)建。
鏡像打包與推送：根據(jù)構(gòu)建平臺（Linux 或 Windows）打包 Docker 鏡像并推送到 Harbor。
構(gòu)建信息記錄：記錄構(gòu)建用戶、項目、分支、平臺和提交 ID 等信息。
通知與清理：支持構(gòu)建成功或失敗時發(fā)送通知，并始終清理工作空間。

通過共享庫的使用，腳本的邏輯更加簡潔和模塊化，便于維護和擴展。

創(chuàng)建構(gòu)建流程

寫好CI流程，下面在Jenkins添加構(gòu)建流程。

基于禪道關(guān)聯(lián)Jenkins任務

禪道平臺配置關(guān)聯(lián)jenkins，方便用戶調(diào)用觸發(fā)。

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')
        // 定義一個字符串參數(shù)，用于指定 SSH 用戶，默認值為 'root'。

        string(name: 'TARGET_IP', defaultValue: '', description: '部署機器 IP 地址')
        // 定義一個字符串參數(shù)，用于指定目標機器的 IP 地址。

        string(name: 'DOCKER_IMAGE', defaultValue: '', description: '運行服務鏡像地址')
        // 定義一個字符串參數(shù)，用于指定 Docker 鏡像的名稱。

        string(name: 'IMAGE_VERSION', defaultValue: '', description: '運行服務鏡像版本號')
        // 定義一個字符串參數(shù)，用于指定 Docker 鏡像的版本號。

        string(name: 'SERVICE_NAME', defaultValue: '', description: '容器運行名稱')
        // 定義一個字符串參數(shù)，用于指定 Docker 容器的名稱。

        string(name: 'PORT_MAPPING', defaultValue: '', description: '端口映射,eg: 8080:8080')
        // 定義一個字符串參數(shù)，用于指定 Docker 容器的端口映射。

        string(name: 'ENV_VARIABLES', defaultValue: '', description: '環(huán)境變量,eg: KEY="VALUE",KEY2="VALUE2"')
        // 定義一個字符串參數(shù)，用于指定 Docker 容器的環(huán)境變量。
    }

    environment {
        SEND_BUILD_USER_EMAIL = ''
        // 定義一個環(huán)境變量 SEND_BUILD_USER_EMAIL，初始值為空，后續(xù)會存儲構(gòu)建用戶的郵箱。
    }

    stages {
        stage('獲取參數(shù)') {
            steps {
                script {
                    withBuildUser {
                        SEND_BUILD_USER_EMAIL = env.BUILD_USER_EMAIL
                        // 使用 Jenkins 的 BuildUser 插件獲取構(gòu)建用戶的郵箱，并賦值給環(huán)境變量 SEND_BUILD_USER_EMAIL。
                    }

                    // 檢查參數(shù)是否為空
                    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(' ')
                        // 如果環(huán)境變量參數(shù)不為空，將其拆分為多個環(huán)境變量，并格式化為 Docker 命令中的 `-e` 參數(shù)。
                    }

                    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}
                        """
                        // 構(gòu)建 Docker 命令，包括：
                        // 1. 登錄 Harbor 倉庫。
                        // 2. 拉取指定版本的 Docker 鏡像。
                        // 3. 停止并刪除已存在的同名容器。
                        // 4. 啟動新的容器，并指定名稱、端口映射和環(huán)境變量。
                    }

                    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 連接到目標機器，并執(zhí)行 Docker 命令。
                    }
                }
            }
        }
    }

    post {
        success {
            script {
                // 構(gòu)建成功時發(fā)送郵件通知。
            }
        }

        unsuccessful {
            script {
                // 構(gòu)建失敗時發(fā)送郵件通知。
            }
        }
    }
}

該 Jenkins Pipeline 腳本實現(xiàn)了一個完整的服務部署流程，包括：

參數(shù)化構(gòu)建：支持動態(tài)指定 SSH 用戶、目標機器 IP、Docker 鏡像、版本號、服務名稱、端口映射和環(huán)境變量。
參數(shù)檢查：確保所有必填參數(shù)不為空。
服務部署：

a.登錄 Harbor 倉庫并拉取 Docker 鏡像。

b.停止并刪除已存在的同名容器。

c.啟動新的容器，并指定名稱、端口映射和環(huán)境變量。

通知與清理：支持構(gòu)建成功或失敗時發(fā)送通知。

通過共享庫和 Jenkins 插件（如 Credentials、SSH Agent）的使用，腳本的邏輯更加簡潔和模塊化，便于維護和擴展。

釘釘與OpenLDAP的聯(lián)動

為了實現(xiàn)統(tǒng)一身份認證，并基于現(xiàn)有的釘釘組織和人員信息，將Jenkins、GitLab、Harbor 和禪道等多平臺的賬號關(guān)聯(lián)，我們可以使用 OpenLDAP 作為統(tǒng)一的用戶認證中心。具體步驟如下：

配置 Go-Ldap-Admin 等服務：將釘釘通訊錄中的用戶和組織結(jié)構(gòu)同步到 OpenLDAP 服務器。
配置各平臺使用 OpenLDAP 認證： 在 Jenkins、GitLab、Harbor 和禪道的系統(tǒng)設置中，配置 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

總結(jié)

通過 Jenkins Pipeline、OpenLDAP 和釘釘?shù)募桑覀兛梢詫崿F(xiàn)高效的 CI/CD 流程，并統(tǒng)一管理多平臺的用戶賬號。本文提供的方案只是一個簡單的示例，實際應用中可以根據(jù)具體需求進行調(diào)整和擴展。

未來展望

未來，我們可以探索以下方向：

使用 Kubernetes 進行容器化部署，進一步提高資源利用率和部署效率。
引入代碼質(zhì)量分析工具，例如 SonarQube，提升代碼質(zhì)量。
實現(xiàn)自動化測試，例如使用 Selenium 進行 UI 自動化測試。

參考文獻

Jenkins 官方文檔: https://www.jenkins.io/doc/。
OpenLDAP 官方文檔:https://www.openldap.org/doc/。
釘釘開發(fā)者文檔:https://open.dingtalk.com/document/orgapp-server。
Go-Ldap-Admin: https://ldapdoc.eryajf.net/。

責任編輯：姜華來源：新鈦云服