当前位置： 首页 > news >正文

二十、DevOps落地：Jenkins基础入门（一）

news 2025/9/15 17:23:34

二十、DevOps落地：Jenkins基础入门（一）

目录
  • 二十、DevOps落地：Jenkins基础入门（一）
    • 1、DevOps初识
      • 1.1 什么是DevOps
      • 1.2 DevOps相关工具链
      • 1.3 什么是CICD？
      • 1.4 持续集成CI介绍
      • 1.5 持续交付和持续部署CD介绍
      • 1.6 什么是Pipeline（流水线）？
      • 1.7 Pipeline编排任务的优势
      • 1.8 Pipeline相关工具介绍
      • 1.9 Jenkins介绍及核心功能
      • 1.10 Jenkins Pipeline介绍
    • 2、Jenkins部署
      • 2.1 集群规划
      • 2.2 Jenkins 安装
      • 2.3 插件安装
      • 2.4 Jenkins Pipeline 初体验
    • 3、声明式 Pipeline 语法
      • 3.1 Sections
        • 3.1.1 Stages
        • 3.1.2 Steps
        • 3.1.3 Agent
        • 3.1.4 Agent 配置示例
        • 3.1.5 Post
        • 3.1.6 Post 配置示例
      • 3.2 Directives
        • 3.2.1 Environment
        • 3.2.2 Options
        • 3.2.3 Parameters
        • 3.2.4 Triggers
        • 3.2.5 Input
        • 3.2.6 When
      • 3.3 Parallel
    • 4、Pipeline 常用变量处理
      • 4.1 内置环境变量
      • 4.2 凭证管理
        • 4.2.1 用户名密码
        • 4.2.2 加密文件

1、DevOps初识

1.1 什么是DevOps

DevOps是Development和Operations的组合，是一种重视开发人员（Dev）和运维人员（Ops）之间的沟通合作的方法论。DevOps打破了传统开发与运维之间的壁垒，强调跨团队协作与工具链整合。

DevOps核心目标：

  • 加速交付：快速迭代，频繁发布新功能
  • 提高质量：通过自动化任务减少错误
  • 增强协助：开发、运维、测试等角色紧密配合
  • 全自动化：减少手动操作，提升效率

一句话总结：DevOps是跨部门沟通的桥梁，利用相关工具的融合提升整个团队的工作效率。

1.2 DevOps相关工具链

阶段 工具示例
代码管理 Git、GitLab、Gitee、Github
代码扫描 Sonarqube
持续集成 Jenkins、Tekton、GitLab CI
持续部署 Jenkins、Tekton、ArgoCD
容器化 Docker、Containerd、Kaniko
制品管理 Harbor、Nexus
服务编排 Kubernetes

1.3 什么是CICD？

CI/CD是DevOps中尤为重要的一个环节，主要是通过自动化流程实现代码从开发到生产的快速和可靠的交付。

CI/CD主要分为了三个方面：

  • 持续集成（CI, Continuous Integration）
  • 持续交付（CD, Continuous Delivery）
  • 持续部署（CD, Continuous Deployment）

1.4 持续集成CI介绍

CI/CD中的CI指持续集成，它属于开发人员的自动化流程，可以帮助开发人员更加频繁地将代码合并到共享分支或主干中，并触发一系列测试和构建的工作。

持续集成相关流程：

  • 代码提交：开发者推送代码到版本控制系统（如GitHub）
  • 自动化构建：Jenkins自动编译并打包应用（生成镜像或产物）
  • 自动化测试：运行单元测试、集成测试等（如Sonarqube）
  • 任务反馈：每个环节集成通知和反馈机制

1.5 持续交付和持续部署CD介绍

持续交付：用于把持续集成过程中的产物（代码、镜像、包）转变为可随时发布的状态，主要目的是拥有一个可以随时部署到生产环境的产物。

持续部署：持续部署时CI/CD最后一个环节，作为持续交付的延伸，用于把产物自动发布到生产环境中。利用持续部署可以让开发人员在修改代码后几分钟就能把新功能全自动部署到生产环境中。

持续交付和持续部署流程：

  • 制品交付：把CI阶段的产物交付到制品仓库（如Harbor）
  • 制品发布：将制品自动发布到开发、测试和生产环境
  • 验收测试：验证发布后的功能是否正常

1.6 什么是Pipeline（流水线）？

Pipeline（流水线）是一种自动化流程框架，用于定义、管理和执行一系列有序的任务。

在软件开发中，从代码开发到部署，也会经过一系列有序的任务，把这些任务串起来自动化执行，也属于流水线。

1.7 Pipeline编排任务的优势

  • 标准化流程：通过声明式方式确保每个环节的一致性，避免人工操作差异导致的错误
  • 自动化执行：Pipeline由多个任务组成，每个任务均可以自动完整，可完整无需人工操作
  • 流程可视化：Pipeline工具可以清晰的看到流水线中的每个环节
  • 可追溯性：流水线的每个环节都有执行的过程、日志和结果，方便追溯和排查问题
  • 支持并行：Pipeline支持多个任务同时运行，减少任务等待时间
  • 重复执行：Pipeline中的任务执行错误重试，无需特殊处理
  • 灵活性高：无需编写过多代码，即可完成对任务的编排

1.8 Pipeline相关工具介绍

Jenkins

  • 优点
    • 长期占据CI/CD市场头部
    • 社区支持强大，可扩展性和可集成性强，插件生态系统丰富（超2000+插件）
    • 基本可以满足企业内的任何场景需求
    • 支持跨平台：Windows、Linux、Mac、容器、K8s等
  • 缺点
    • 配置稍复杂
    • 需要手动管理插件依赖和版本兼容性

Tekton

  • 优点
    • 转为K8s设计，以CI/CD方式运行，天然支持容器化和动态资源分配
    • Pipeline定义与底层K8s解耦，迁移方便，扩展性强
    • 方便集成与企业内部平台进行二次开发
  • 缺点
    • 插件支持较少
    • 学习难度较大，部分功能需要自行开发集成
    • 需要K8s基座支持

GitLab CI/CD

  • 优点
    • 与GitLab代码仓库深度集成，无需额外配置
    • 使用.gitlab-ci.yaml
  • 缺点
    • 高功能需付费
    • 扩展性一般
    • 需要自行维护Runner
    • 无权限隔离

1.9 Jenkins介绍及核心功能

Jenkins是一个开源的CI/CD工具，用于自动化构建、测试和部署软件。Jenkins支持多种编程语言和版本控制系统，并可以通过插件扩展功能，是DevOps流程中最流行的自动化工具之一。

Jenkins架构为主从架构，Master节点为主节点，主要用于管理任务调度、任务配置、提供Web UI。Agent节点为从节点，主要用于执行具体的任务，可动态扩展。

Jenkins核心功能：

  • 持续集成：Jenkins可以集成各种工具完成CI过程，比如GitLab、Sonarqube等
  • 持续部署：Jenkins支持自动化部署至各种平台，比如K8s、物理机等
  • 插件生态：执行2000+插件，无需自行开发即可集成各种平台
  • 流水线：支持声明式和脚本试Pipeline，用于定制CICD中的各个阶段
  • 分布式：Jenkins支持主从架构，可以跨多台机器执行任务，也可以结合K8s实现动态slave

1.10 Jenkins Pipeline介绍

Jenkins Pipeline分为声明式（Declarative Pipeline）和脚本式（Scripted Pipeline）

声明式流水线采用结构化语法实现，格式固定、易读性强，并且内置错误处理机制，可以不需要掌握Groovy语言可以完成编写，同时可以与Blue Ocean结合实现可视化，是目前比较推荐的实现方式。

2、Jenkins部署

2.1 集群规划

主机名称 物理IP 系统 资源配置
jenkins 192.168.200.54 Rocky9.4 2核4g

2.2 Jenkins 安装

安装 Docker

# 添加docker的yum源配置文件
[root@jenkins ~]# yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo# 安装docker
[root@jenkins ~]# yum install docker-ce docker-ce-cli -y# 启动docker
[root@jenkins ~]# systemctl daemon-reload && systemctl enable --now docker

创建 Jenkins 的数据目录，防止容器重启后数据丢失：

[root@jenkins ~]# mkdir /data/jenkins_data -p
[root@jenkins ~]# chmod -R 777 /data/jenkins_data

启动 Jenkins，并配置管理员账号密码为 admin/admin123：

# 拉取镜像
[root@jenkins ~]# docker pull crpi-q1nb2n896zwtcdts.cn-beijing.personal.cr.aliyuncs.com/ywb01/jenkins:2.504.3-debian-12-r1# 启动容器
[root@jenkins ~]# docker run -d --name=jenkins --restart=always -e JENKINS_PASSWORD=admin123 -e JENKINS_USERNAME=admin -e JENKINS_HTTP_PORT_NUMBER=8080 -p 8080:8080 -p 50000:50000 -v /usr/bin/docker:/usr/bin/docker -v /var/run/docker.sock:/var/run/docker.sock -v /data/jenkins_data:/bitnami/jenkins crpi-q1nb2n896zwtcdts.cn-beijing.personal.cr.aliyuncs.com/ywb01/jenkins:2.504.3-debian-12-r1# 查看容器
[root@jenkins ~]# docker ps -a
CONTAINER ID   IMAGE                                                                                          COMMAND                  CREATED         STATUS         PORTS                                                                                                    NAMES
8e44a0ba9584   crpi-q1nb2n896zwtcdts.cn-beijing.personal.cr.aliyuncs.com/ywb01/jenkins:2.504.3-debian-12-r1   "/opt/bitnami/script…"   2 minutes ago   Up 2 minutes   0.0.0.0:8080->8080/tcp, [::]:8080->8080/tcp, 0.0.0.0:50000->50000/tcp, [::]:50000->50000/tcp, 8443/tcp   jenkins

其中 8080 端口为 Jenkins Web 界面的端口，50000 是 jnlp 使用的端口，后期 Jenkins Slave 需要使用 50000 端口和 Jenkins 主节点通信。

查看 Jenkins 日志：

# 查看到这条日志说明 Jenkins 已完成启动
[root@jenkins ~]# docker logs -f Jenkins
....
INFO	hudson.lifecycle.Lifecycle#onReady: Jenkins is fully up and running

之后通过 Jenkins 宿主机的 IP+8080 即可访问 Jenkins

image.png-617.9kB

2.3 插件安装

登录后点击 Manage Jenkins → Manage Plugins 安装需要使用的插件：
image.png-106.7kB

image.png-129.5kB

在安装之前首先配置国内的插件源，点击 Advanced，将插件源更改为国内插件源（https://mirrors.huaweicloud.com/jenkins/updates/update-center.json）

image.png-85.2kB

点击 Submit 后在 Available 可以看到所有的可用插件：
image.png-134.5kB

Git
Git Parameter
Git Pipeline for Blue Ocean
GitLab
Credentials
Credentials Binding
Blue Ocean
Blue Ocean Pipeline Editor
Blue Ocean Core JS
Web for Blue Ocean
Pipeline SCM API for Blue Ocean
Dashboard for Blue Ocean
Build With Parameters
List Git Branches Parameter
Pipeline
Pipeline: Declarative
Kubernetes
Kubernetes CLI
Kubernetes Credentials
Image Tag Parameter
Docker
Docker Slaves
Docker Pipeline
Role-based Authorization Strategy

最后安装完记得重启
image.png-91.6kB

等待安装后自动重启后，就可以在 Installed 看到已经安装的插件：
image.png-95.1kB

至此 Jenkins 和 Jenkins 插件的安装就完成了。

2.4 Jenkins Pipeline 初体验

首先创建一个 Job：
image.png-119.2kB

image.png-123kB

image.png-91.2kB

image.png-73kB

image.png-117.8kB

查看流程图：

image.png-73kB

image.png-68.8kB

3、声明式 Pipeline 语法

3.1 Sections

声明式流水线中的 Sections 不是一个关键字或指令，而是包含一个或多个 Agent、Stages、Post、Directives 和 Steps 的代码区域块。

3.1.1 Stages

Stages 包含一个或多个 stage 指令，同时可以在 stage 中的 steps 块中定义真正执行的指令。

比如创建一个流水线，stages 包含一个名为 Example 的 stage，该 stage 执行 echo 'Hello World'命令输出 Hello World 字符串：

pipeline {agent anystages {stage('Example') {steps {echo 'Hello World'}}}
}

3.1.2 Steps

Steps 部分在给定的 stage 指令中执行的一个或多个步骤，比如在 steps 定义执行一条 shell 命令：

pipeline {agent anystages {stage('Example') {steps {echo 'Hello World'}}}
}

或者是使用 sh 字段执行多条指令：

pipeline {agent anystages {stage('Example') {steps {sh """echo 'steps01'echo 'steps02'echo 'steps03'"""}}}
}

image.png-99.8kB

3.1.3 Agent

Agent 表示整个流水线或特定阶段中的步骤和命令执行的位置，该部分可以在 pipeline 块的顶层被定义，也可以在 stage 中再次定义，也可以同时在两处定义。

1、any：在任何可用的代理上执行流水线，配置语法：

pipeline {agent any
}

2、none：表示该 Pipeline 脚本没有全局的 agent 配置。当顶层的 agent 配置为 none 时，可以为每个 stage 配置局部的 agent。配置语法：

pipeline {agent nonestages {stage('Stage For Build') {agent any}}
}

3、label：选择某个具体的节点执行 Pipeline 命令，例如：agent { label 'my-defined-label' }。配置语法：

pipeline {agent anystages {stage('Hello') {steps {echo 'Hello World'}}stage('Example') {agent { label 'my-slave-label' }steps {sh """echo 'steps01'echo 'steps02'echo 'steps03'"""}}}
}

如果 agent 不存在，任务会一直处于等待 agent 状态：
image.png-59kB

4、docker：agent 支持直接使用镜像作为 agent，这也是比较推荐的方式，可以避免处理
编译环境或者 slave 的版本问题。比如 Java 编译，可以直接使用 maven 镜像启动 slave，之后进行打包，同时可以指定 args：

pipeline {agent anystages {stage('Example') {agent { docker {image 'crpi-q1nb2n896zwtcdts.cn-beijing.personal.cr.aliyuncs.com/ywb01/maven:3.5.3'args '-v /tmp:/tmp'}}steps {sh 'mvn -version'}}}
}

此时运行 pipeline，如果不存在该镜像运行的容器，会使用该镜像启动容器：
image.png-69.5kB

image.png-89.4kB

5、kubernetes：Jenkins 也支持使用 Kubernetes 创建 Slave，也就是常说的动态 Slave。配置示例如下：

agent {kubernetes {label podlabelyaml """
kind: Pod
metadata:name: jenkins-agent
spec:containers:- name: kanikoimage: crpi-q1nb2n896zwtcdts.cn-beijing.personal.cr.aliyuncs.com/ywb01/executor:debugimagePullPolicy: Alwayscommand:- /busybox/cattty: truevolumeMounts:- name: aws-secretmountPath: /root/.aws/- name: docker-registry-configmountPath: /kaniko/.dockerrestartPolicy: Nevervolumes:- name: aws-secretsecret:secretName: aws-secret- name: docker-registry-configconfigMap:name: docker-registry-config
"""}
}

3.1.4 Agent 配置示例

示例 1：假设有一个 Java 项目，需要用 mvn 命令进行编译，此时可以使用 maven 的镜像作为 agent。配置如下：

pipeline {agent { docker {image 'crpi-q1nb2n896zwtcdts.cn-beijing.personal.cr.aliyuncs.com/ywb01/maven:3.5.3'}}stages {stage('Example Build') {steps {sh 'mvn -version'}}}
}

image.png-123.2kB

示例 2：本示例在流水线顶层将 agent 定义为 none，那么此时可以在 stage 部分配置局部的 agent。在 stage('Example Build')部分使用 registry.cn-beijing.aliyuncs.com/dotbalo/maven:3.5.3 执行该阶段步骤，在 stage('Example Test')部分使用 openjdk:8-jre 执行该阶段步骤。此时 Pipeline 如下：

pipeline {agent nonestages {stage('Example Build') {agent { docker {image 'crpi-q1nb2n896zwtcdts.cn-beijing.personal.cr.aliyuncs.com/ywb01/maven:3.5.3'}}steps {echo 'Hello, Maven'sh 'mvn -version'}}stage('Example Test') {agent { docker {image 'crpi-q1nb2n896zwtcdts.cn-beijing.personal.cr.aliyuncs.com/ywb01/jre:8u211-data'}}steps {echo 'Hello, JDK'sh 'java -version'}}}
}

image.png-110.6kB

image.png-81.1kB

示例 3：上述的示例也可以用基于 Kubernetes 的 agent 实现。比如定义具有三个容器的 Pod，分别为 jnlp（负责和 Jenkins Master 通信）、build（负责执行构建命令）、kubectl（负责执行 Kubernetes
相关命令），在 steps 中可以通过 containers 字段，选择在某个容器执行命令：

pipeline {agent {kubernetes {cloud 'kubernetes-default'slaveConnectTimeout 1200yaml '''
apiVersion: v1
kind: Pod
spec:containers:- args: [\'$(JENKINS_SECRET)\', \'$(JENKINS_NAME)\']image: 'crpi-q1nb2n896zwtcdts.cn-beijing.personal.cr.aliyuncs.com/ywb01/jnlp-agent-docker:latest'name: jnlpimagePullPolicy: IfNotPresent- command:- "cat"image: "crpi-q1nb2n896zwtcdts.cn-beijing.personal.cr.aliyuncs.com/ywb01/maven:3.5.3"imagePullPolicy: "IfNotPresent"name: "build"tty: true- command:- "cat"image: "crpi-q1nb2n896zwtcdts.cn-beijing.personal.cr.aliyuncs.com/ywb01/kubectl:latest"imagePullPolicy: "IfNotPresent"name: "kubectl"tty: true'''}
}stages {stage('Building') {steps {container(name: 'build') {sh """mvm clean install"""}}
}stage('Deploy') {steps {container(name: 'kubectl') {sh """kubectl get node"""}}}}
}

3.1.5 Post

Post 一般用于流水线结束后的进一步处理，比如错误通知等。Post 可以针对流水线不同的结果做出不同的处理，就像开发程序的错误处理，比如 Python 语言的 try catch。Post 可以定义在 Pipeline 或 stage 中，目前支持以下条件：

  • always：无论 Pipeline 或 stage 的完成状态如何，都允许运行该 post 中定义的指令；
  • changed：只有当前 Pipeline 或 stage 的完成状态与它之前的运行不同时，才允许在该post 部分运行该步骤；
  • fixed：当本次 Pipeline 或 stage 成功，且上一次构建是失败或不稳定时，允许运行该 post 中定义的指令；
  • regression：当本次 Pipeline 或 stage 的状态为失败、不稳定或终止，且上一次构建的状态为成功时，允许运行该 post 中定义的指令；
  • failure：只有当前 Pipeline 或 stage 的完成状态为失败（failure），才允许在 post 部分运行该步骤，通常这时在 Web 界面中显示为红色；
  • success：当前状态为成功（success），执行 post 步骤，通常在 Web 界面中显示为蓝色或绿色；
  • unstable：当前状态为不稳定（unstable），执行 post 步骤，通常由于测试失败或代码违规等造成，在 Web 界面中显示为黄色；
  • aborted：当前状态为终止（aborted），执行该 post 步骤，通常由于流水线被手动终止触发，这时在 Web 界面中显示为灰色；
  • unsuccessful：当前状态不是 success 时，执行该 post 步骤；
  • cleanup：无论 pipeline 或 stage 的完成状态如何，都允许运行该 post 中定义的指令。和 always 的区别在于，cleanup 会在其它执行之后执行。

3.1.6 Post 配置示例

示例一：一般情况下 post 部分放在流水线的底部，比如本实例，无论 stage 的完成状态如何，都会输出一条I will always say Hello again!信息：

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

image.png-93.6kB

示例二：只有 stage 的完成状态是成功的时候，才会输出一条我只有在成功的时候才会执行!信息

pipeline {agent anystages {stage('Example') {steps {sh '''echo 'Hello World'xxxx'''}}}post {always {echo 'I will always say Hello again!'}success {echo '我只有在成功的时候才会执行!'}}
}

没有执行
image.png-75.6kB

删除错误命令
image.png-80.3kB

成功执行
image.png-76.3kB

示例三：也可以将 post 写在 stage，并且在失败时执行，此时只有流水线失败时才会执行：

pipeline {agent anystages {stage('Test') {steps {sh 'EXECUTE_TEST_COMMAND'}post {failure {echo "Pipeline Testing failure..."}}}}
}

失败的状态才会执行这个命令
image.png-80.8kB

改成正确的命令就不会执行了
image.png-86.2kB

image.png-51.1kB

3.2 Directives

Directives可用于一些执行stage时的条件判断或预处理一些数据，和Sections一致，Directives也不是一个关键字或指令，而是包含了 environment、options、parameters、triggers、stage、tools、input、when 等配置。

3.2.1 Environment

Environment 主要用于在流水线中配置的一些环境变量，根据配置的位置决定环境变量的作用域。可以定义在 pipeline 中作为全局变量，也可以配置在 stage 中作为该 stage 的环境变量。

假如需要定义个变量名为 CC 的全局变量和一个局部变量，可以通过以下方式定义：

pipeline {agent anyenvironment {CC = 'global'            # Pipeline 中定义，属于全局变量}stages {stage('local') {environment {CC2 = 'local'    # 定义在 stage 中，属于局部变量}steps {sh '''echo CC: $CC echo CC2: $CC2 '''}}stage('global') {steps {sh '''echo CC: $CC echo CC2: $CC2 '''}}        }
}

image.png-71.8kB

3.2.2 Options

Jenkins 流水线支持很多内置指令，比如 retry 可以对失败的步骤进行重复执行 n 次，可以根据不同的指令实现不同的效果。比较常用的指令如下：

  • buildDiscarder ： 保 留 多 少 个 流 水 线 的 构 建 记 录 。 比 如：options { buildDiscarder(logRotator(numToKeepStr: '1')) }；
  • disableConcurrentBuilds：禁止流水线并行执行，防止并行流水线同时访问共享资源导致流水线失败。比如：options { disableConcurrentBuilds() }；
  • disableResume ： 如 果 控 制 器 重 启 ， 禁 止 流 水 线 自 动 恢 复 。 比 如 ： options { disableResume() }；
  • retry：流水线失败后重试次数。比如：options { retry(30) }；
  • timeout：设置流水线的超时时间，超过流水线时间，job 会自动终止。比如：options { timeout(time: 1, unit: 'HOURS') }；

配置示例如下，只需要添加 options 字段即可：

pipeline {agent anyoptions {timeout(time: 1, unit: 'HOURS')     # 全局超时}stages {stage('Example') {steps {echo 'Hello World'}}}
}

Option 除了写在 Pipeline 顶层，还可以写在 stage 中，但是写在 stage 中的 option 仅支持 retry、timeout、timestamps，或者是和 stage 相关的声明式选项，比如 skipDefaultCheckout。处于 stage 级别的 options 写法如下：

pipeline {agent anyoptions {timeout(time: 1, unit: 'HOURS')}stages {stage('Example') {options {timeout(time: 10, unit: 'SECONDS')  # 局部超时}steps {sh 'sleep 60'       # 模拟一个长时间任务}}}
}

image.png-107.1kB

超时重试

pipeline {agent anyoptions {timeout(time: 1, unit: 'HOURS')}stages {stage('Example') {options {timeout(time: 10, unit: 'SECONDS')retry(3)       # 错误重试三次}steps {sh 'xxx'        # 模拟错误命令}}}
}

image.png-87kB

3.2.3 Parameters

Parameters 提供了一个用户在触发流水线时应该提供的参数列表，这些用户指定参数的值可以通过 params 对象提供给流水线的 step。

目前支持的参数类型如下：

  • string：字符串类型的参数，例如：parameters { string(name: 'DEPLOY_ENV', defaultValue:'staging', description: '') }，表示定义一个名为 DEPLOY_ENV 的字符型变量，默认值为staging；
  • text：文本型参数，一般用于定义多行文本内容的变量。例如 parameters { text(name: 'DEPLOY_TEXT', defaultValue: 'One\nTwo\nThree\n', description: '') }，表示定义一个名为 DEPLOY_TEXT 的变量，默认值是'One\nTwo\nThree\n'；
  • booleanParam：布尔型参数，例如: parameters { booleanParam(name: 'DEBUG_BUILD', defaultValue: true, description: '') }；
  • choice：选择型参数，一般用于给定几个可选的值，然后选择其中一个进行赋值，例如：parameters { choice(name: 'CHOICES', choices: ['one', 'two', 'three'], description: '') }，表示定义一个名为 CHOICES 的变量，可选的值为 one、two、three；
  • password：密码型变量，一般用于定义敏感型变量，在 Jenkins 控制台会显示为*。例如：parameters { password(name: 'PASSWORD', defaultValue: 'SECRET', description: 'A secret password') }，表示定义一个名为 PASSWORD 的变量，其默认值为 SECRET。

Parameters 用法示例如下：

pipeline {agent anyparameters {string(name: 'PERSON', defaultValue: 'Mr Jenkins', description: 'Who should I say hello to?')choice(name: 'CHOICE', choices: ['One', 'Two', 'Three'], description: 'Pick something')}stages {stage('Example') {steps {sh """echo ${params.PERSON}echo ${params.CHOICE}"""}}}
}

image.png-44.9kB

image.png-59.7kB

除了上述内置的参数外，还可以通过插件扩展参数的能力，比如使用 Git 插件定义参数：
1、选择流水线
image.png-70.9kB

2、选择parameters
image.png-152.8kB

3、生成语法
image.png-112.7kB

# 该字段会在 Jenkins 页面生成一个选择分支的选项，用于赋值到 BRANCH 参数
parameters {gitParameter branch: '', branchFilter: '.*', defaultValue: 'master', description: '构建的分支', name: 'BRANCH', quickFilterEnabled: false, selectedValue: 'NONE', sortMode: 'NONE', tagFilter: '*', type: 'GitParameterDefinition'
}

3.2.4 Triggers

在 Pipeline 中可以用 triggers 实现自动触发流水线执行任务，可以通过 Webhook、Cron、pollSCM 和 upstream 等方式触发流水线。

假如某个流水线构建的时间比较长，或者某个流水线需要定期在某个时间段执行构建，可以使用 cron 配置触发器，比如周一到周五每隔四个小时执行一次：

pipeline {agent anytriggers {cron('H */4 * * 1-5')}stages {stage('Example') {steps {echo 'Hello World'}}}
}

使用 cron 字段可以定期执行流水线，如果代码更新后触发流水线，无更新则不触发流水线，可以使用 pollSCM 字段：

pipeline {agent anytriggers {pollSCM('H */4 * * 1-5')}stages {stage('Example') {steps {echo 'Hello World'}}}
}

Upstream 可以根据上游 job 的执行结果决定是否触发该流水线。比如当 job1 或 job2 执行成功时触发该流水线：

pipeline {agent anytriggers {upstream(upstreamProjects: 'job1,job2', threshold: hudson.model.Result.SUCCESS)}stages {stage('Example') {steps {echo 'Hello World'}}}
}

目前支持的状态有 SUCCESS、UNSTABLE、FAILURE、NOT_BUILT、ABORTED 等

3.2.5 Input

Input 字段可以实现在流水线中进行交互式操作，比如选择要部署的环境、是否继续执行某个阶段等。

配置 Input 支持以下选项：

  • message：必选，需要用户进行 input 的提示信息，比如：“是否发布到生产环境？”；
  • id：可选，input 的标识符，默认为 stage 的名称；
  • ok：可选，确认按钮的显示信息，比如：“确定”、“允许”；
  • submitter：可选，允许提交 input 操作的用户或组的名称，如果为空，任何登录用户均可提交 input；
  • parameters：提供一个参数列表供 input 使用。

假如需要配置一个提示消息为“还继续么”、确认按钮为“继续”、提供一个 PERSON 的变量的参数，并且所有登录用户均可提交的 input 流水线：

pipeline {agent anystages {stage('Example') {input {message "还继续么?"ok "继续"submitter ""parameters {string(name: 'PERSON', defaultValue: 'false', description: '确认部署')}}steps {echo "${PERSON}"}}}
}

432af703-40f4-4398-bb4a-c09c4b9d730a.png-60.5kB

image.png-66.5kB

3.2.6 When

When 指令允许流水线根据给定的条件决定是否应该执行该 stage，when 指令必须包含至少
一个条件。如果 when 包含多个条件，所有的子条件必须都返回 True，stage 才能执行。

目前比较常用的内置条件如下：

  • branch：当正在构建的分支与给定的分支匹配时，执行这个 stage，例如：when { branch 'master' }。注意，branch 只适用于多分支流水线；
  • changelog ：匹配 提交的 changeLog 决定是否 构 建， 例如 ：when { changelog'.*^\\[DEPENDENCY\\] .+$' }；
  • environment：当指定的环境变量和给定的变量匹配时，执行这个 stage，例如：when { environment name: 'DEPLOY_TO', value: 'production' }；
  • expression：当指定的 Groovy 表达式评估为 True，执行这个 stage，例如：when { expression { return params.DEBUG_BUILD } }；
  • tag：如果 TAG_NAME 的值和给定的条件匹配，执行这个 stage，例如：when { tag "release-*" }；
  • not：当嵌套条件出现错误时，执行这个 stage，必须包含一个条件，例如：when { not { branch 'master' } }；
  • allOf：当所有的嵌套条件都正确时，执行这个 stage，必须包含至少一个条件，例如：when { allOf { branch 'master'; environment name: 'DEPLOY_TO', value: 'production' } }；
  • anyOf：当至少有一个嵌套条件为 True 时，执行这个 stage，例如：when { anyOf { branch 'master'; branch 'staging' } }。

示例一：当分支为 production 时，执行 Example Deploy 步骤：

pipeline {agent anystages {stage('Example Build') {steps {echo 'Hello World'}}stage('Example Deploy') {when {branch 'production'     # 条件判断，当分支必须是production的时候，才会执行steps里面的字段}steps {echo 'Deploying'}}}
}

我们这里没有设置分支字段，所以它就会跳过这个步骤
image.png-132.3kB

示例二：也可以同时配置多个条件，比如分支是 production，而且 DEPLOY_TO 变量的值为 production 时，才执行 Example Deploy：

pipeline {agent anystages {stage('Example Build') {steps {echo 'Hello World'}}stage('Example Deploy') {when {      # 两个条件必须全部满足branch 'production'environment name: 'DEPLOY_TO', value: 'production'}steps {echo 'Deploying'}}}
}

示例三：也可以使用 anyOf 进行匹配其中一个条件即可，比如分支为 production，DEPLOY_TO 为 production 或 staging 时执行 Deploy：

pipeline {agent anyenvironment {DEPLOY_TO = 'production'}stages {stage('Example Build') {steps {echo 'Hello World'}}stage('Example Deploy') {when {anyOf {     # 满足其中一个条件即可environment name: 'DEPLOY_TO', value: 'production'environment name: 'DEPLOY_TO', value: 'staging'}}steps {echo 'Deploying'}}}
}

image.png-88.4kB

示例四：也可以使用 expression 进行正则匹配，比如当 BRANCH_NAME 为 production 或 staging，并且 DEPLOY_TO 为 production 或 staging 时才会执行 Example Deploy：

pipeline {agent anystages {stage('Example Build') {steps {echo 'Hello World'}}stage('Example Deploy') {when {          # expression与anyOf属于同级子条件，必须全部满足expression { BRANCH_NAME ==~ /(production|staging)/ }anyOf {     # 而anyOf内只需满足其中一个条件即可environment name: 'DEPLOY_TO', value: 'production'environment name: 'DEPLOY_TO', value: 'staging'}}steps {echo 'Deploying'}}}
}

默认情况下，如果定义了某个 stage 的 agent，在进入该 stage 的 agent 后，该 stage 的 when 条件才会被评估，但是可以通过一些选项更改此选项。比如在进入 stage 的 agent 前评估 when，可以使用 beforeAgent，当 when 为 true 时才进行该 stage。

目前支持的前置条件如下：

  • beforeAgent：如果 beforeAgent 为 true，则会先评估 when 条件。在 when 条件为 true 时，才会进入该 stage；
  • beforeInput：如果 beforeInput 为 true，则会先评估 when 条件。在 when 条件为 true 时，才会进入到 input 阶段；
  • beforeOptions：如果 beforeInput 为 true，则会先评估 when 条件。在 when 条件为 true 时，才会进入到 options 阶段；

配置一个 beforeAgent 示例如下：

pipeline {agent nonestages {stage('Example Build') {steps {echo 'Hello World'}}stage('Example Deploy') {agent {label "some-label"}when {beforeAgent truebranch 'production'}steps {echo 'Deploying'}}}
}

配置一个 beforeInput 示例如下：

pipeline {agent nonestages {stage('Example Build') {steps {echo 'Hello World'}}stage('Example Deploy') {when {beforeInput truebranch 'production'}input {message "Deploy to production?"id "simple-input"}steps {echo 'Deploying'}}}
}

配置一个 beforeOptions 示例如下：

pipeline {agent nonestages {stage('Example Build') {steps {echo 'Hello World'}}stage('Example Deploy') {when {beforeOptions truebranch 'production'}options {retry(3)}steps {echo "Deploying to ${deployEnv}"}}}
}

3.3 Parallel

在声明式流水线中可以使用 Parallel 字段，即可很方便的实现并发构建，比如对下面几个操作进行并行处理：

pipeline {agent anystages {stage('Non-Parallel Stage') {steps {echo 'This stage will be executed first.'}}stage('Parallel Stage') {failFast trueparallel {stage('build') {steps {echo "开始构建"}}stage('sonarqube') {steps {echo "代码扫描"}}stage('Stage C') {steps {echo "其他长时间任务"}}}}}
}

设置 failFast 为 true 表示并行流水线中任意一个 stage 出现错误，其它 stage 也会立即终止。也可以通过 options 配置在全局：

pipeline {agent anyoptions {parallelsAlwaysFailFast()}stages {stage('Non-Parallel Stage') {steps {echo 'This stage will be executed first.'}}stage('Parallel Stage') {parallel {stage('build') {steps {echo "开始构建"}}stage('sonarqube') {steps {echo "代码扫描"}}stage('Stage C') {steps {echo "其他长时间任务"}}}}}
}

image.png-95.8kB

4、Pipeline 常用变量处理

4.1 内置环境变量

Jenkins 有许多内置变量可以直接在 Jenkinsfile 中使用，可以通过 JENKINS_URL/pipelinesyntax/globals#env 获取完整列表。目前比较常用的环境变量如下：

  • BUILD_ID：构建 ID，对于 1.597 及以上版本和 BUILD_NUMBER 一致，而对于更早版本的构建则是一个 YYYY-MM-DD_hh-mm-ss 格式的时间戳；
  • BUILD_NUMBER：当前构建的 ID，和 BUILD_ID 一致；
  • BUILD_TAG：用来标识构建的版本号，格式为：jenkins-${JOB_NAME}-${BUILD_NUMBER}，可以对产物进行命名，比如生产的 jar 包名字、镜像的 TAG 等；
  • BUILD_URL：本次构建的完整URL，比如：http://buildserver/jenkins/job/MyJobName/17/；
  • JOB_NAME：本次构建的项目名称；
  • NODE_NAME：当前构建节点的名称；
  • JENKINS_URL：Jenkins 完整的 URL，需要在 System Configuration 设置；
  • WORKSPACE：执行构建的工作目录。

上述变量会保存在一个 Map 中，可以使用 env.BUILD_ID 或 env.JENKINS_URL 引用某个内置变量：

pipeline {agent anystages {stage('Example') {steps {echo "Running ${env.BUILD_ID} on ${env.JENKINS_URL}"}}}
}

image.png-101kB

4.2 凭证管理

4.2.1 用户名密码

本示例用来演示 credentials 账号密码的使用，比如使用一个公用账户访问 Bitbucket、GitLab、Harbor 等,此时可以使用 Jenkins 用户名密码类型的凭证进行管理。

比如添加一个用于访问 Harbor 的凭证：
a6db8f8b-a9ff-45ed-b649-f83e26dc641d.png-123.4kB

image.png-45.3kB

image.png-127.5kB

接下来可以使用访问获取凭证的值，HARBOR_ACCOUNT 为接收的变量名，可以自定义：

environment {HARBOR_ACCOUNT = credentials('HARBOR_USER_PASSWORD')
}

上述的配置会自动生成 3 个环境变量：

  • HARBOR_ACCOUNT ： 包 含 一 个 以 冒 号 分 隔 的 用 户 名 和 密 码 ， 格 式 为 username:password；
  • HARBOR_ACCOUNT_USR：仅包含用户名的附加变量；
  • HARBOR_ACCOUNT_PSW：仅包含密码的附加变量。

此时可以用如下方式获取变量：

pipeline {agent anystages {stage('Example stage 1') {environment {HARBOR_ACCOUNT = credentials(' HARBOR_USER_PASSWORD ')}steps {echo """HARBOR_ACCOUNT: $HARBOR_ACCOUNTHARBOR_ACCOUNT_USR: $HARBOR_ACCOUNT_USRHARBOR_ACCOUNT_PSW: $HARBOR_ACCOUNT_PSW"""}}}
}

image.png-107.6kB

4.2.2 加密文件

如果需要加密某个文件，也可以使用 credential，比如链接到 Kubernetes 集群的 kubeconfig文件等。

首先创建文本形式的凭证
image.png-84.6kB

image.png-96.6kB

接下来可以在 Pipeline 中引用该文件：

pipeline {agent anystages {stage('Secret File') {environment {MY_KUBECONFIG = credentials('STUDY_CLUSTER_CONFIG')}steps {echo "MY_KUBECONFIG: $MY_KUBECONFIG"}}}
}

image.png-81.6kB

更多其它类型的凭证可以参考：https://www.jenkins.io/doc/book/pipeline/jenkinsfile#handling-credentials。

此博客来源于：https://edu.51cto.com/lecturer/11062970.html