阿才的博客 首页时间线标签分类站点地图百度站点地图
Jenkins教程
|Jenkins
字数总计: 6.5k|阅读时长: 25 分钟

Jenkins安装

docker

  1. 创建网桥
    docker network create jenkins
  2. 初始化Jenkins
    docker run \
      --name jenkins-docker \
      --rm \
      --detach \
      --privileged \
      --network jenkins \
      --network-alias docker \
      --env DOCKER_TLS_CERTDIR=/certs \
      --volume jenkins-docker-certs:/certs/client \
      --volume jenkins-data:/var/jenkins_home \
      --publish 2376:2376 \
      docker:dind \
      --storage-driver overlay2
  3. 编写Dockerfile
    FROM jenkins/jenkins:2.401.2
    USER root
    RUN apt-get update && apt-get install -y lsb-release
    RUN curl -fsSLo /usr/share/keyrings/docker-archive-keyring.asc \
      https://download.docker.com/linux/debian/gpg
    RUN echo "deb [arch=$(dpkg --print-architecture) \
      signed-by=/usr/share/keyrings/docker-archive-keyring.asc] \
      https://download.docker.com/linux/debian \
      $(lsb_release -cs) stable" > /etc/apt/sources.list.d/docker.list
    RUN apt-get update && apt-get install -y docker-ce-cli
    USER jenkins
    RUN jenkins-plugin-cli --plugins "blueocean docker-workflow"
  4. 构建docker镜像
    docker build -t myjenkins-blueocean:2.401.2-1 .
  5. 运行docker容器
    docker run \
      --name jenkins-blueocean \
      --restart=on-failure \
      --detach \
      --network jenkins \
      --env DOCKER_HOST=tcp://docker:2376 \
      --env DOCKER_CERT_PATH=/certs/client \
      --env DOCKER_TLS_VERIFY=1 \
      --publish 8080:8080 \
      --publish 50000:50000 \
      --volume jenkins-data:/var/jenkins_home \
      --volume jenkins-docker-certs:/certs/client:ro \
      myjenkins-blueocean:2.401.2-1

Jenkins凭据

Jenkins支持以下几种类型的凭据：

凭据类型 描述
Secret text 保存API token
Username and password 用来保存gitlab/nexus用户和密码
Secret file 存储加密文件
SSH Username with private key ssh私钥
Certificate 存储证书

创建全局凭据

  1. 使用Linux命令获取一个随机UUID
    #uuidgen
    8f7110b4-e402-41b2-97c6-b0ebb18dcc49
  2. Dashboard》Manage Jenkins》凭据》系统》全局凭据，创建凭据

Pipeline

Jenkins Pipeline 是 Jenkins 中的一个强大功能，它允许你使用可扩展的脚本语言定义和管理持续交付（Continuous Delivery）流水线。

Jenkins Pipeline 提供了一种将软件交付过程定义为代码的方式，这使得流水线的创建、管理和版本控制变得更加灵活和可重复。它基于 Groovy 编程语言，并提供了丰富的语法和函数，用于描述和自定义不同的构建和部署阶段。

Jenkins Pipeline 的核心概念是将整个软件交付过程划分为一系列的阶段（Stage）和步骤（Step）。每个阶段代表流水线中的一个逻辑单元，而每个步骤代表具体的操作或任务。你可以定义并组合这些阶段和步骤，以构建复杂的持续交付流水线。

通过 Pipeline，你可以实现以下功能：

  1. 将整个软件交付过程定义为可执行的代码，以便在版本控制系统中进行管理和追踪。
  2. 自定义构建和部署阶段，包括编译、测试、静态代码分析、部署等。
  3. 引入并行处理，同时执行多个任务，以加速整体交付流程。
  4. 集成各种工具和插件，例如代码质量检查、部署到不同环境、自动化测试等。
  5. 创建可重复且一致的交付流程，提高团队的协作和交付质量。

声明式流水线语法

pipeline {
    agent any 
    stages {
        stage('Build') { 
            steps {
                // 
            }
        }
        stage('Test') { 
            steps {
                // 
            }
        }
        stage('Deploy') { 
            steps {
                // 
            }
        }
    }
}

脚本式流水线语法

node {  
    stage('Build') { 
        // 
    }
    stage('Test') { 
        // 
    }
    stage('Deploy') { 
        // 
    }
}

声明式流水线

agent

在 Jenkins Pipeline 中，agent 是用来指定运行 Pipeline 的代理（执行代理或者构建代理）。它决定了 Pipeline 在哪个节点（计算机或者容器）上运行，并且可以控制运行 Pipeline 的环境和工具。 agent 有多种形式，每种形式都对应不同的运行环境。以下是 agent 的一些常见形式及其作用：
下面是使用 Markdown 表格展示不同 agent 形式的示例：

agent 形式 描述
agent any 在任意可用节点上运行 Pipeline。
agent none 不在任何节点上运行 Pipeline，需要手动触发或外部触发。
agent { label 'label_name' } 只在具有指定标签（label_name）的节点上运行。
agent { docker { image 'docker_image_name' } } 在 Docker 容器中运行 Pipeline，指定 Docker 镜像。
agent { dockerfile { filename 'Dockerfile' } } 在使用指定 Dockerfile 构建的 Docker 容器中运行。
agent { kubernetes { label 'kubernetes_label' } } 在 Kubernetes 集群中运行 Pipeline，指定运行的节点标签。
agent { docker { reuseNode true } } 在 Docker 容器中运行 Pipeline，并允许复用已存在的节点。

示例：agent用法

pipeline {
    agent any // 在任意可用节点上运行

    stages {
        stage('Build') {
            agent {
                label 'build_node' // 仅在带有 "build_node" 标签的节点上运行
            }
            steps {
                // 构建步骤
                echo 'Building...'
            }
        }
        stage('Test') {
            agent {
                docker {
                    image 'maven:3.8.1' // 在 Maven 3.8.1 镜像的 Docker 容器中运行
                }
            }
            steps {
                // 测试步骤
                echo 'Testing...'
            }
        }
        stage('Deploy') {
            agent {
                kubernetes {
                    label 'kubernetes_label' // 在带有 "kubernetes_label" 标签的 Kubernetes 节点上运行
                }
            }
            steps {
                // 部署步骤
                echo 'Deploying...'
            }
        }
    }
}

options

选项 中文描述
buildDiscarder 保留特定数量最近的 Pipeline 运行的构建结果和控制台输出。例如：options { buildDiscarder(logRotator(numToKeepStr: '1')) }
checkoutToSubdirectory 将自动的源代码控制检出放置在工作空间的子目录中。例如：options { checkoutToSubdirectory('foo') }
disableConcurrentBuilds 禁止 Pipeline 的并发执行。这对于防止对共享资源的同时访问等情况可能很有用。例如：options { disableConcurrentBuilds() } 或 options { disableConcurrentBuilds(abortPrevious: true) }
disableResume 如果控制器重启，则不允许 Pipeline 恢复。例如：options { disableResume() }
newContainerPerStage 与 docker 或 dockerfile 顶级代理一起使用。当指定时，每个阶段将在同一节点上的一个新容器实例中运行，而不是所有阶段在同一个容器实例中运行。
overrideIndexTriggers 允许覆盖默认的分支索引触发器处理方式。如果在多分支或组织标签处禁用了分支索引触发器，则 options { overrideIndexTriggers(true) } 会仅为此作业启用它们。否则，options { overrideIndexTriggers(false) } 会仅为此作业禁用分支索引触发器。
preserveStashes 保留已完成构建的暂存内容，以供阶段重新启动时使用。例如：options { preserveStashes() } 保留最近完成的构建的暂存内容，或者 options { preserveStashes(buildCount: 5) } 保留最近五次完成构建的暂存内容。
quietPeriod 设置 Pipeline 的静默期（quiet period），以秒为单位，覆盖全局默认值。例如：options { quietPeriod(30) }
retry 失败时，重试整个 Pipeline 的指定次数。例如：options { retry(3) }
skipDefaultCheckout 在 agent 指令中默认跳过从源代码控制中检出代码。例如：options { skipDefaultCheckout() }
skipStagesAfterUnstable 一旦构建状态变为 UNSTABLE，跳过后续阶段。例如：options { skipStagesAfterUnstable() }
timeout 为 Pipeline 运行设置超时时间，超过该时间 Jenkins 将中止 Pipeline。例如：options { timeout(time: 1, unit: 'HOURS') }
timestamps 在 Pipeline 运行生成的所有控制台输出前加上输出时间。例如：options { timestamps() }
parallelsAlwaysFailFast 为 Pipeline 中后续的所有并行阶段设置 failfast 为 true。例如：options { parallelsAlwaysFailFast() }
disableRestartFromStage 完全禁用“从阶段重新启动”选项，该选项在经典 Jenkins UI 和 Blue Ocean 中可见。例如：options { disableRestartFromStage() }。此选项不能在 stage 内部使用。
customWorkspace 自定义workspace工作路径
示例：pipeline打印时间戳 
properties([parameters([string(name: 'branch', defaultValue: 'master')])])
pipeline {
    agent any
    options {
        // 在 options 块中使用 timestamps，将会在整个 Pipeline 输出中加入时间戳
        timestamps()
    }
    stages {
        stage('Hello') {
            steps {
                git branch: branch, credentialsId: '8918B00D-5DE0-489C-9D32-EC790E5ED4D1', 
                url: 'https://gitee.com/acaiblog/libraries.git'
            }
        }
    }
}

parameters

可用参数类型：

参数名称 描述
string 字符串
text 一般用于多行文本
booleanParam 定义参数为true或false
choice 选择参数
password 用来加密用户的密码

parameters可以用两种方式表示：
写在pipeline{}外层，示例：

properties([parameters([string(name: 'branch', defaultValue: 'master')])])

写在pipeline{}内

pipeline {
    agent any
    parameters {
        string(name: 'version', defaultValue: 'master', description: '')
        text(name: 'info', defaultValue: '', description: '')
        booleanParam(name: 'enable', defaultValue: true, description: '')
        choice(name: 'choice', choices: ['dev', 'sit', 'pat'], description: '')
        password(name: 'password', defaultValue: 'SECRET', description: '')
    }
}

environment

指定一系列键值对，这些键值对将被定义为所有步骤或特定于阶段的步骤的环境变量，具体取决于环境指令在管道中的位置。该指令支持特殊的辅助方法credentials()，该方法可用于通过 Jenkins 环境中的标识符来访问预定义的凭证。
支持的Credentials类型：

参数 中文描述
Secret Text 指定的环境变量将设置为“Secret Text”的内容。
Secret File 指定的环境变量将设置为“File”文件的位置，该文件是临时创建的。
Username and password 指定的环境变量将设置为“username:password”，并且会自动定义两个额外的环境变量：分别是 MYVARNAME_USR 和 MYVARNAME_PSW。
SSH with Private Key 指定的环境变量将设置为 SSH 密钥文件的位置，该文件是临时创建的，并且会自动定义两个额外的环境变量：分别是 MYVARNAME_USR 和 MYVARNAME_PSW（包含密钥的密码）。

用户名和密码

pipeline {
    agent any
    environment {
        MY_CREDENTIALS = credentials('my_username_and_password')
    }
    stages {
        stage('Build') {
            steps {
                // 使用 MY_CREDENTIALS 环境变量进行构建
                sh 'echo $MY_CREDENTIALS'
                sh 'echo $MY_CREDENTIALS_USR'
                sh 'echo $MY_CREDENTIALS_PSW'
            }
        }
    }
}

tools

定义自动安装并放在 PATH 中的工具的部分。如果未指定代理，则忽略此选项。支持以下几种：

工具 作用
Maven Maven 是一个项目管理和构建工具，主要用于 Java 项目。它通过使用一个项目对象模型（POM）文件来描述项目的配置和依赖，并能够自动下载依赖、编译、测试、打包和部署项目。
JDK JDK（Java Development Kit）是 Java 开发工具包，它包含了 Java 编译器、运行时环境（JRE）和其他开发工具，用于开发、编译和运行 Java 应用程序。 JDK 是 Java 开发的核心。
Gradle Gradle 是一个灵活、高效的构建自动化工具，支持多种编程语言，但主要用于构建和管理 Java 项目。它使用 Groovy 或 Kotlin 作为脚本语言，并能够自动化执行编译、测试、打包等任务。

stage

在 Jenkins Pipeline 中，stage 是一个用于组织和划分 Pipeline 执行的重要块。stage 块用于将 Pipeline 分成不同的阶段，并允许您在 Jenkins 中可视化地查看每个阶段的执行结果。每个 stage 块通常表示一个构建阶段或一个功能单元。示例：

stage('Build') {
  // 构建阶段的步骤
}

step

在 Jenkins Pipeline 中，step 是一个用于执行具体构建任务的基本块。step 块用于定义单个构建步骤，每个步骤代表了 Pipeline 中的一个具体操作，例如构建代码、运行测试、部署应用等。示例：

stage('Test') {
  step('Run Unit Tests') {
    // 运行单元测试的步骤
  }
}

Pipeline示例

pipeline {
    agent any
    options {
        skipStagesAfterUnstable()
    }
    stages {
        stage('Build') {
            steps {
                sh 'make'
            }
        }
        stage('Test'){
            steps {
                sh 'make check'
                junit 'reports/**/*.xml'
            }
        }
        stage('Deploy') {
            steps {
                sh 'make publish'
            }
        }
    }
}

triggers

触发器定义了如何自动触发pipeline执行流水线任务，触发器可用参数如下：

参数 描述
cron 根据时间表达式触发job，例如：triggers { cron('H */4 * * 1-5') }
pollSCM pollSCM是Jenkins流水线中的触发器函数，用于轮询源代码管理系统，检测是否有新的代码提交，并触发流水线执行。
upstream 通过触发器调用job任务，例如：triggers { upstream(upstreamProjects: 'job1,job2', threshold: hudson.model.Result.SUCCESS) } 当上游job运行成功之后触发器才会执行job1和job2

结果处理post

Pipeline运行之后根据运行结果要进行的操作，比如发送邮件等信息

参数 描述
always 无论 Pipeline 或 stage 运行的完成状态如何，都执行后续步骤。
changed 仅在当前 Pipeline 的运行状态与上一次运行状态不同时执行后续步骤。
fixed 仅在当前 Pipeline 的运行成功且上一次运行失败或不稳定时执行后续步骤。
regression 仅在当前 Pipeline 或状态为失败、不稳定或中止，且上一次运行成功时执行后续步骤。
aborted 仅在当前 Pipeline 的运行状态为 “aborted” 时执行后续步骤，通常是由于手动中止 Pipeline。在网页界面中通常以灰色显示。
failure 仅在当前 Pipeline 或 stage 的运行状态为 “failed” 时执行后续步骤，通常以红色在网页界面中显示。
success 仅在当前 Pipeline 或 stage 的运行状态为 “success” 时执行后续步骤，通常以蓝色或绿色在网页界面中显示。
unstable 仅在当前 Pipeline 的运行状态为 “unstable” 时执行后续步骤，通常由于测试失败、代码违规等导致。在网页界面中通常以黄色显示。
unsuccessful 仅在当前 Pipeline 或 stage 的运行状态不为 “success” 时执行后续步骤。在网页界面中通常根据前面提到的状态进行显示（对于 stages 可能会在构建本身不稳定时触发）。
cleanup 在所有其他后续条件评估完毕后，无论 Pipeline 或 stage 的状态如何，都执行后续步骤。

示例：

pipeline {
    agent any
    stages {
        stage('Example') {
            steps {
                echo 'Hello World'
            }
        }
    }
    post {
        always {
            echo 'I will always say Hello again!'
        }
    }
}

input

在 Jenkins Pipeline 中，input 步骤用于在流水线执行过程中暂停，并等待用户的交互输入。它允许用户对流水线的执行进行确认或提供其他必要的信息，然后再继续执行后续的流程。
当流水线执行到 input 步骤时，Jenkins 将会暂停执行，并在 Jenkins 界面上显示一个输入对话框，等待用户输入。在输入对话框中，用户可以看到定义好的输入消息（可以是提示信息、问题或其他需要用户响应的信息），然后根据提示进行输入。用户可以点击 “Proceed” 或 “Abort” 按钮来确认或中止流水线的执行。
input 步骤通常用于需要人工干预或批准的场景，例如：

  1. 在执行部署操作前，确认是否继续执行；
  2. 在触发发布步骤后，确认发布的版本号或部署目标；
  3. 在执行关键任务前，确保具备必要的条件或资源；
  4. 在某个阶段执行失败后，决定是否继续执行后续步骤等。

input可用参数如下：

参数 描述
message 必填项。在用户提交输入时，将显示此消息。
id 可选项。用于此输入的标识符。默认值基于阶段名称。
ok 可选项。输入表单上 “ok” 按钮的文本。
submitter 可选项。允许提交此输入的用户或外部组名的逗号分隔列表。默认允许任何用户。
submitterParameter 可选项。如果存在，用于设置提交者名称的环境变量的名称。
parameters 可选项。提示提交者提供的参数列表。有关更多信息，请参阅参数（parameters）的说明。

示例：

pipeline {
    agent any
    stages {
        stage('Example') {
            steps {
                script {
                    def userInput = input message: '确认上传安装包', parameters: [
                        [$class: 'ChoiceParameterDefinition',
                        choices: '确认\n取消', 
                        description: '请选择你要执行的类型',
                        name: 'operation']
                    ]
                    if(userInput == '确认'){
                        echo '确认上传'
                    }else if(userInput == '取消'){
                        echo '取消上传'
                    }
                }
            }
        }
    }
}

when

When 指令允许 Pipeline 根据给定条件确定是否应执行该阶段。 When 指令必须至少包含一个条件。 如果when指令包含多个条件，则所有子条件都必须返回true才能执行该阶段。 这与子条件嵌套在 allOf 条件中相同（请参阅下面的示例）。 如果使用 anyOf 条件，请注意，一旦找到第一个“true”条件，该条件就会跳过剩余的测试。内置参数：

参数 描述
branch 当构建的分支匹配指定的分支模式（ANT 风格的路径通配符）时执行该阶段。例如：when { branch 'master' }。请注意，该条件仅适用于多分支 Pipeline。
buildingTag 当构建正在构建一个标签时执行该阶段。例如：when { buildingTag() }。
changelog 当构建的 SCM 变更日志包含给定的正则表达式模式时执行该阶段。例如：when { changelog '.*^\\[DEPENDENCY\\] .+$' }。
changeset 当构建的 SCM 变更集包含与给定模式匹配的一个或多个文件时执行该阶段。例如：when { changeset "**/*.js” }。
environment 当指定的环境变量的值等于给定的值时执行该阶段。例如：when { environment name: 'DEPLOY_TO', value: 'production' }。
equals 当期望的值等于实际值时执行该阶段。例如：when { equals expected: 2, actual: currentBuild.number }。
expression 当指定的 Groovy 表达式求值为 true 时执行该阶段。例如：when { expression { return params.DEBUG_BUILD } }。
tag 当 TAG_NAME 变量匹配给定的模式时执行该阶段。例如：when { tag "release-*" }。如果提供了空模式，则在 TAG_NAME 变量存在时执行该阶段（等同于 buildingTag()）。
not 当嵌套条件为 false 时执行该阶段。必须包含一个条件。例如：when { not { branch 'master' } }。
allOf 当所有嵌套条件都为 true 时执行该阶段。必须包含至少一个条件。例如：when { allOf { branch 'master'; environment name: 'DEPLOY_TO', value: 'production' } }。
anyOf 当至少有一个嵌套条件为 true 时执行该阶段。必须包含至少一个条件。例如：when { anyOf { branch 'master'; branch 'staging' } }。
triggeredBy 当当前构建是由指定的参数触发时执行该阶段。

示例：当分支为production或staging时执行

stage('Example Deploy') {
    when {
        expression { BRANCH_NAME ==~ /(production|staging)/ }
    }
    steps {
        echo 'Deploying'
    }
}

script

在 Jenkins Pipeline 中，script 是一个重要的步骤，它允许您在 Pipeline 中执行任意的 Groovy 脚本代码。script 步骤非常灵活，可以用于执行复杂的逻辑、调用外部插件或执行其他 Jenkins Pipeline 支持的操作。
示例：

pipeline {
    agent any
    stages {
        stage('Example') {
            steps {
                script {
                    def browsers = ['chrome', 'firefox']
                    println(browsers)
                }
            }
        }
    }
}

git

拉取代码可用参数：

参数 描述
url Git 仓库的 URL。
branch 要拉取的分支名称。
credentialsId 使用凭据 ID 来访问私有 Git 仓库。
changelog 是否生成更改日志。
clean 是否在拉取之前清理工作目录。
cloneOptions 传递给 git clone 命令的额外选项。
shallow 是否执行浅克隆（只拉取最近的历史记录）。
depth 设置浅克隆的深度（历史记录的数量）。
submodules 是否拉取并初始化 Git 子模块。
poll 是否在拉取之前执行 SCM 轮询。
disableSubmodules 是否禁用 Git 子模块。
extensions 传递给 git 命令的额外扩展选项。
reference 使用已有的 Git 仓库作为引用进行克隆。
lfs 是否使用 Git LFS（大文件存储）。
lfsSkipSmudge 是否跳过 Git LFS 清除过滤器。
lfsInclude 包含哪些文件用于 Git LFS。
lfsExclude 排除哪些文件不用于 Git LFS。
lfsFetchInclude 包含哪些文件在拉取时使用 Git LFS。
lfsFetchExclude 排除哪些文件在拉取时不使用 Git LFS。
name 设置远程仓库的名称。

示例：

stage('Git Checkout') {
    steps {
        // 使用 git 步骤拉取代码
        git branch: 'main', url: 'https://github.com/your-repo.git'
    }
}

checkout

checkout可用参数：

参数 描述
branch 要拉取的分支名称。
changelog 是否生成更改日志。
credentialId 使用凭据 ID 来访问私有仓库。
poll 是否在拉取之前执行 SCM 轮询。
submoduleCfg 是否启用子模块的配置数据。
submoduleUpdate 是否更新子模块。
depth 设置浅克隆的深度，即拉取的历史记录数量。
quiet 是否在控制台中输出更少的信息。
sparseCheckoutPaths 用于设置 Sparse Checkout 的路径，仅拉取指定路径的文件。
git 用于更细粒度地指定 Git 操作，如 fetch 和 clone。

示例：

stage('Checkout Code') {
    steps {
        // 使用 checkout 步骤来拉取代码
        checkout([$class: 'GitSCM', 
            branches: [[name: 'main']], 
            userRemoteConfigs: [[url: 'https://github.com/yourusername/your-repo.git']], 
            credentialsId: 'your-credentials'])
    }
}

withEnv

withEnv 是 Jenkins Pipeline 中的一个步骤指令，用于临时设置环境变量。它允许您在指定的代码块中使用自定义的环境变量，而在代码块之外，环境变量不会生效。

基本语法

pipeline {
    agent any
    stages {
        stage('Example Stage') {
            steps {
                withEnv(['JAVA_HOME=${WORKSPACE}/jdk1.8.0_131', 'ANT_HOME=${WORKSPACE}/apache-ant-1.9.4']) {
                    // 在这里的代码块中使用 VAR1 和 VAR2 环境变量
                }
                // 这里不会使用 VAR1 和 VAR2 环境变量
            }
        }
    }
}

withCredentials

withCredentials 是 Jenkins Pipeline 中的一个步骤指令，用于在 Pipeline 中使用敏感凭据，如用户名、密码、SSH 密钥等。它允许您在指定的代码块中使用凭据，而在代码块之外，凭据不会被暴露。

基本语法

pipeline {
    agent any
    stages {
        stage('Example Stage') {
            steps {
                withCredentials([
                    usernamePassword(credentialsId: 'xxxxxxxxxx', usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD')
                ]) {
                    // 在这里的代码块中使用 USERNAME 和 PASSWORD 凭据
                }
                // 这里不会使用 USERNAME 和 PASSWORD 凭据
            }
        }
    }
}

Jenkins Shared Libraries

Jenkins Shared Libraries（共享库）是一种在Jenkins中共享和重用代码的机制。它允许你在Jenkins Pipeline中引入自定义的Groovy代码，使得你可以在多个Pipeline脚本中共享和重用这些代码逻辑。

  1. Libraries目录结构：
目录 描述
vars 包含可在Pipeline中直接调用的全局变量脚本
src 包含供全局变量脚本使用的辅助类和方法
resources 可选，包含共享库使用的资源文件
  1. 引入共享库：要在Jenkins中使用共享库，需要在Jenkins系统配置中设置共享库的全局配置。可以通过指定库的名称、库的来源（如Git仓库）和版本等来配置共享库。
  2. 定义全局变量：在共享库的vars/目录下，可以创建多个Groovy脚本文件，每个文件定义一个全局变量。这些全局变量可在Pipeline中直接调用，类似于Jenkins内置的全局变量（如sh、echo等）。
  3. 辅助类和方法：在共享库的src/目录下，可以创建Groovy类和方法，供全局变量脚本使用。这些辅助类和方法可以提供更复杂的逻辑和功能，用于支持全局变量的实现。
  4. 版本管理：共享库可以使用版本控制系统进行管理，例如Git。通过指定库的版本，可以确保Pipeline使用特定版本的共享库代码。
  5. 用例：共享库适用于需要在多个Pipeline中共享和重用相同的代码逻辑的场景。通过使用共享库，可以提高代码的可维护性、重用性和一致性，减少重复编写代码的工作量。

构建Libraries groovy项目

  1. 创建groovy项目
    img.png
  2. 在项目根目录下创建vars和resources目录，目录结构如下：
    ├── lib
    ├── resources
    ├── src
    └── vars
  3. 在vars/log.groovy定义日志lib库
    def info(message) {
        echo "INFO: ${message}"
    }
    def debug(message) {
        echo "DEBUG: ${message}"
    }
    def error(message) {
        echo "ERROR: ${message}"
    }
  4. 在src/Helper.groovy中定义：
    package com.example

    class Helper {
        static void printMessage(String message) {
            echo "Helper: ${message}"
        }
    }
  5. Jenkins中配置gitee用户和密码凭据
  6. 在配置全局共享库
    img.png
  7. Jenkinsfile测试调用定义的方法
    @Library('ops-lib@master') _
    log.info "info"
    log.debug "debug"
  8. 修改时区，用户》设置》用户定义的时区，选择Asia/ShangHai
  9. Jenkins执行结果
    [2023-07-07 07:00:18] INFO: info
    [2023-07-07 07:00:18] DEBUG: debug
    Finished: SUCCESS
  10. 使用动态参数引入library
    properties([parameters([string(name: 'LIB_VERSION', defaultValue: 'master')])])
    library "ops-lib@${params.LIB_VERSION}"
    log.info "info"
    log.debug "debug"
  11. 动态检索Library
    properties([parameters([string(name: 'LIB_VERSION', defaultValue: 'master')])])
    library identifier: "ops-lib@${params.LIB_VERSION}", retriever: modernSCM(
      [$class: 'GitSCMSource',
       remote: 'https://gitee.com/acaiblog/libraries.git',
       credentialsId: '8918B00D-5DE0-489C-9D32-EC790E5ED4D1'])
    log.info "info"
    log.debug "debug"

    汇总

    打印文件下载路径

    // 获取当前构建的url
    def buildUrl = env.BUILD_URL
    // 构建文件下载地址
    def fileUrl = "${buildUrl}/excution/node/3/ws/devops/utils/xxx.xlsx"
    echo "File: ${fileUrl}"

    args序列化为json

    import groovy.json.JsonOutput
    def paramsJson = JsonOutput.toJson(args)

    向列表添加元素

    def paramsList = ['a','b','c']
    paramsList.add('d')

    解析JSON数据

    def jsonString = '{"key1": "value1", "key2": "value2", "key3": {"nested_key": "nested_value"}}'

    def jsonSlurper = new JsonSlurper()
    def jsonData = jsonSlurper.parseText(jsonString)

    echo "Value of key1: ${jsonData.key1}"
    echo "Value of key2: ${jsonData.key2}"
    echo "Value of nested_key: ${jsonData.key3.nested_key}"

    Pipeline调用其他Job

    pipeline{
     agent{ label Master }
     states{
      stage("Running Job"){
       steps{
        script{
         if(xxx in xxx_list){
           jobName = "aaa"
         }else{
           jobName = "bbb"
         }
         build(
          job: jobName,
          paramters:[
          // name参数为需要传递给job的参数名称，value是给job传递变量的名称
           string(name: 'xxx', value: xxx)
          ]
         )
        }
       }
      }
     }
    }

    给GIT打TAG

    pipeline{
     stages{
      stage('Check Tag'){
       steps{
        dir("${WORKSPACE}"){
         script{
          def tagExists = sh(script: "git rev-parse ${TAG_NAME}", returnStatus: true) == 0
          if (tagExists) {
            println "tag ${TAG_NAME} is exist"
          } else {
            sh """
            git checkout ${branch}
            git tag ${TAG_NAME}
            git push --tags http://xxxxxxx.git ${TAG_NAME}
            """
          }
         }
        }
       }
      }
     }
    }

    Maven发布包到Nexus

    设置env.VERSION可以让不同stage获取该变量
    pipeline {
        agent any
        stages {
            stage('Get Version') {
                steps {
                    script {
                        env.VERSION = sh(script: 'mvn -q help:evaluate -Dexpression=project.version', returnStdout: true)
                        echo "Project Version: ${env.VERSION}"
                    }
                }
            }
            stage('Deploy') {
             steps {
               echo "Project Version: ${env.VERSION}"
               sh "mvn deploy:deploy-file \
                  -Durl=https://your-nexus-repo-url/repository/maven-releases/ \
                  -DrepositoryId=your-nexus-repo-id \
                  -DgroupId=your.groupId \
                  -DartifactId=your-artifactId \
                  -Dversion=${env.VERSION} \
                  -Dpackaging=jar \
                  -Dfile=/path/to/your-artifact.jar \
                  -DpomFile=pom.xml"
             }
            }
        }
    }
文章作者: 慕容峻才
文章链接: https://www.acaiblog.top/Jenkins教程/
版权声明: 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 阿才的博客！
Pipeline
微信打赏
支付宝打赏