基于 Jenkins 和 K8s 的 CICD 学习随笔（Kubectl）
一、CICD 流程图参考
二、必要的插件说明
- Git： Jenkins 安装中默认安装 Git 插件，所以不需要单独安装。利用 git 工具可以将 github、gitlab 等等的地址下载源码。
- Docker： Jenkins 安装中默认安装 Docker 插件，所以不需要单独安装。利用 Docker 插件可以设置 Docker 环境，运行 Docker 命令，配置远程 Docker 仓库凭据等。
- Kubernetes： Kubernetes 插件的目的是能够使用 Kubernetes 集群动态配置 Jenkins 代理（使用Kubernetes调度机制来优化负载），运行单个构建，等构建完成后删除该代理。这里我们需要用到这个插件来启动 Jenkins Slave 代理镜像，让代理执行 Jenkins 要执行的 Job。
- Kubernetes Cli： Kubernetes Cli 插件作用是在执行 Jenkins Job 时候提供 kubectl 与 Kubernetes 集群交互环境。可以在 Pipeline 或自由式项目中允许执行 kubectl 相关命令。它的主要作用是提供 kubectl 运行环境，当然也可以提供 helm 运行环境。
- Config File Provider： Config File Provider 插件作用就是提供在 Jenkins 中存储 properties、xml、json、settings.xml 等信息，可以在执行 Pipeline 过程中可以写入存储的配置。例如，存入一个 Maven 全局 Settings.xml 文件，在执行 Pipeline Job 时候引入该 Settings.xml ，这样 Maven 编译用的就是该全局的 Settings.xml。
- Pipeline Utility Steps： 这是一个操作文件的插件，例如读写 json、yaml、pom.xml、Properties 等等。在这里主要用这个插件读取 pom.xml 文件的参数设置，获取变量，方便构建 Docker 镜像。
- Git Parameter： 能够与 Git 插件结合使用，动态获取 Git 项目中分支信息，在 Jenkins Job 构建前提供分支选项，来让项目执行人员选择拉取对应分支的代码。
三、必要的凭据说明
选择 <凭据->系统->全局凭据->添加凭据> 来新增 Git、Docker Hub、Kubernetes 等认证凭据。
- Git 认证凭据
配置的参数值：
类型：Username with password
范围：全局
用户名（Git 用户名）： 略
密码（Git 密码）：略
ID：global-git-credential
描述：全局 Git 凭据
- Kubernetes Token 凭据
配置的参数值：
类型：Secret text
范围：全局
Secret（K8S Token 串）：略
ID：global-kubernetes-credential
描述：全局的 K8S Token
- Docker 仓库认证凭据
配置的参数值：
类型：Username with password
范围：全局
用户名（Docker 仓库用户名）：略
密码（Docker 仓库密码）：略
ID：docker-hub-credential
描述：Docker 仓库认证凭据
四、Jenkins 配置 Kubernetes 插件
Kubernetes Plugin 基本配置
- 配置连接 Kubernetes 参数
注意： 如果你的 Jenkins 也是安装在 Kubernetes 环境中，那么可以直接使用 Kubernetes 集群内的 Kubernetes API 地址，如果 Jnekins 是在安装在正常物理机或者虚拟机环境中，那么使用集群外的 Kubernetes API 地址。
- 配置 Jenkins 地址
注意： 这里的 Jenkins 地址是供 Slave 节点连接 Jenkins Master 节点用的，所以这里需要配置 Jenkins Master 的 URL 地址。这里和上面一样，也是考虑 Jenkins 是部署在 Kubernetes 集群内还是集群外。如果 Jnekins 中配置了 /jenkins 前缀，则 URL 后面加上 /jenkins，否则不加，这个地址根据自己的 Jnekins 实际情况来判断。
Kubernetes 插件 Pod 模板配置
- 配置 Pod 名称和标签列表
配置 Pod 模板的名称和标签列表名，Pod 模板名可用于子模板继承，标签列表可用于 Jenkins Job 中指定，使用此 Pod 模板来执行任务。
- 配置 Pod 的原始 yaml
在 Pod 的原始 yaml 配置中，加入一段配置，用于改变 Kubernetes Plugin 自带的 JNLP 镜像，并指定 RunAsUser=0 来使容器以 Root 身份执行任务，并设置 privileged=true 来让 Slave Pod 在 Kubernetes 中拥有特权。
yaml 内容如下：
apiVersion: v1
kind: Pod
metadata:
labels:
app: jenkins-slave
spec:
securityContext:
runAsUser: 0
privileged: true
containers:
- name: jnlp
tty: true
workingDir: /home/jenkins/agent
image: jenkins/agent:4.10-1-alpine
Jenkins Slave JNLP 镜像官方地址： https://hub.docker.com/r/jenkins/agent/
Kubernetes 插件 Container 配置
- 配置 Maven 镜像
Maven 镜像可以从官方 Docker Hub 下载，地址：https://hub.docker.com/_/maven
- 配置 Docker In Docker 镜像
这里推荐使用 dind 版本的镜像，Docker-IN-Docker 镜像可以从官方 Docker Hub 下载，地址：https://hub.docker.com/_/docker
- 配置 Kubectl 镜像
Kubectl 镜像可以从官方 Docker Hub 下载，地址：https://hub.docker.com/r/bitnami/kubectl
Container 存储挂载配置
由于上面配置的 Maven、Docker 等都需要挂载存储，Maven 中是将中央仓库下载的 Jar 存储到共享目录，而 Docker 则是需要将宿主机的 Docker 配置挂载到 Docker In Docker 容器内部，所以我们要对挂载进行配置。
- 创建 Maven 存储使用的 PVC
例如：
kind: PersistentVolumeClaim
apiVersion: v1
metadata:
name: maven
namespace: cicd
spec:
storageClassName: cephfs
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 100Gi
- 配置 Maven 挂载
- 配置 Docker 挂载
Kubernetes 中 Pod 的容器是启动在各个节点上，每个节点就是一台宿主机，里面进行了很多 Docker 配置，所以我们这里将宿主机的 Docker 配置挂载进入 Docker 镜像。选择添加卷，选择 Host Path Volume 按如下添加配置：
路径 /usr/bin/docker：
主机路径（宿主机目录）：/usr/bin/docker
挂载路径（容器内的目录）：/usr/bin/docker
路径 /var/run/docker.sock：
主机路径（宿主机目录）：/var/run/docker.sock
挂载路径（容器内的目录）：/var/run/docker.sock
路径 /etc/docker：
主机路径（宿主机目录）：/etc/docker
挂载路径（容器内的目录）：/etc/docker
五、Jenkins 创建相关文件
之前安装了 Config File Provider 插件，该插件功能就是可以在 Jenkins 上存储一些配置文件，例如，我们经常使用到的 yaml、properties、Dockerfile、Maven 的 Settings.xml 等文件，都可以存储到 Jenkins 该插件中。
打开 系统管理->Managed files ，在其中新增几个文件：
- Maven 配置文件： Maven 的 Settings.xml 配置文件。
- Dockerfile 文件： Dockerfile 脚本。
- Kubernetes 部署文件： 将应用部署到 kubernetes 的 Deployment 文件。
新增 Maven 配置文件
选择 Add a new Config—>Global Maven settings.xml 来新增一个 Maven 全局 Settings.xml 文件：
ID： global-maven-settings
Name： MavenGlobalSettings
Comment： 全局 Maven Settings.xml 文件
Content： 内容如下
示例文件内容：
<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
<pluginGroups>
</pluginGroups>
<proxies>
</proxies>
<servers>
</servers>
<mirrors>
<!--Aliyun Maven-->
<mirror>
<id>alimaven</id>
<name>aliyun maven</name>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
<mirrorOf>central</mirrorOf>
</mirror>
</mirrors>
<profiles>
</profiles>
</settings>
为了加快 jar 包的下载速度，这里将仓库地址指向 aliyun Maven 仓库地址。
新增 Dockerfile 文件
选择 Add a new Config—>Custom file 来新增一个 Dockerfile 文件：
ID： global-dockerfile-file
Name： Dockerfile
Comment： 全局 Dockerfile 文件
Content： 内容如下
示例文件内容：
FROM openjdk:8u222-jre-slim
VOLUME /tmp
ADD target/*.jar app.jar
RUN sh -c 'touch /app.jar'
ENV JVM_OPTS="-Xss256k -Duser.timezone=Asia/Shanghai -Djava.security.egd=file:/dev/./urandom"
ENV JAVA_OPTS=""
ENV APP_OPTS=""
ENTRYPOINT [ "sh", "-c", "java $JVM_OPTS $JAVA_OPTS -jar /app.jar $APP_OPTS" ]
新增 Kubernetes 部署文件
选择 Add a new Config—>Custom file 来新增一个 Kubernetes 部署文件：
ID： global-kubernetes-deployment
Name： deployment.yaml
Comment： 全局 Kubernetes 部署文件
Content： 内容如下
示例文件内容：
apiVersion: v1
kind: Service
metadata:
name: #APP_NAME
labels:
app: #APP_NAME
spec:
type: NodePort
ports:
- name: server #服务端口
port: 8080
targetPort: 8080
- name: management #监控及监控检查的端口
port: 8081
targetPort: 8081
selector:
app: #APP_NAME
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: #APP_NAME
labels:
app: #APP_NAME
spec:
replicas: #APP_REPLICAS
selector:
matchLabels:
app: #APP_NAME
strategy:
type: Recreate #设置更新策略为删除策略
template:
metadata:
labels:
app: #APP_NAME
spec:
containers:
- name: #APP_NAME
image: #APP_IMAGE_NAME
imagePullPolicy: Always
ports:
- containerPort: 8080 #服务端口
name: server
- containerPort: 8081 #监控及监控检查的端口
name: management
env:
- name: "update_uuid"
value: "#APP_UUID" #生成的随机值，放置执行kubectl apply时能够执行
resources:
limits:
cpu: 2000m
memory: 1024Mi
requests:
cpu: 1000m
memory: 512Mi
为了模板能够动态替换某些值，上面模板中设置了几个可替换的参数，用 #变量名称 来标记，后面我们在执行 Pipeline 时候将里面的 #xxx变量 标记替换掉。
六、流水线脚本编写和插件使用说明
脚本中设置全局超时时间
设置任务超时时间，如果在规定时间内任务没有完成，则进行失败操作，格式如下：
timeout(time: 60, unit: 'SECONDS') {
// 脚本
}
脚本中使用 Git 插件
Git 插件方法使用格式，及其部分参数：
- changelog： 是否检测变化日志
- url： Git 项目地址
- branch： Git 分支
- credentialsId： Jenkins 保存的 Git 凭据 ID 值
git changelog: true,
url: "http://gitlab.xxxx/xxx.git"
branch: "master",
credentialsId: "xxxx-xxxx-xxxx-xxxx",
脚本中使用 Kubernetes 插件
Kubernetes 插件中存在 PodTemplate 方法，在执行脚本时候，会自动在 Kubernetes 中创建 Pod Template 配置的 Slave Pod，在其中执行 podTemplate 代码块中的脚本。
def label = "jnlp-agent"
podTemplate(label: label,cloud: 'kubernetes' ){
node (label) {
print "在 Slave Pod 中执行任务"
}
}
podTemplate 方法参数简介：
- cloud： 之前 Kuberntes 插件配置的 Cloud 名称
- label： 之前 Kuberntes 插件配置的 Cloud 中 Pod Template 里面的 Label 标签名称。
脚本中使用 Docker 镜像
在之前配置了 Kubernetes 插件的 Pod Template 配置中，配置了几个容器，每个容器中都有特定的功能的环境，例如：
- Maven 容器中能够执行 mvn 命令。
- Kubectl 容器能够执行 kubectl 命令。
- Docker In Docker 容器中能够执行 Docker 命令。
既然每个容器都能提供特定的环境，那么再执行执行 Pipleline 脚本时候，就可以在不同的镜像中使用不同的环境的命令：
Maven 镜像
container('maven') {
sh "mvn install
}
Docker In Docker 镜像
container('docker') {
sh "docker build -t xxxxx:1.0.0 .
}
Kubectl 镜像
container('kubectl') {
sh "kubectl apply -f xxxx.yaml"
}
脚本中引入 Jenkins 中预先存储的文件
在之前的 系统设置->File Manager 中，存储了很多文件，例如：
- Docker 的镜像构建脚本文件 Dockerfile。
- Maven 的全局设置文件 Settings.xml
- Kubernetes 的部署文件 deployment.yaml
在使用 Pipleline 脚本时候，我们需要将这些文件文本提取出来，创建在执行任务的流程中，创建这些文件可以使用 Config File Provider 插件提供的 configFileProvider 方法，如下所示：
创建 settings.xml 文件
configFileProvider([configFile(fileId: "global-maven-settings", targetLocation: "settings.xml")]){
sh "cat settings.xml"
}
创建 Dockerfile 文件
configFileProvider([configFile(fileId: "global-dockerfile-file", targetLocation: "Dockerfile")]){
sh "cat Dockerfile"
}
创建 deployment.yaml 文件
configFileProvider([configFile(fileId: "global-kubernetes-deployment", targetLocation: "deployment.yaml")]){
sh "cat deployment.yaml"
}
脚本创建文件
在使用 Groovy 写 Pipleline 脚本时候，经常要将变量的文本生成文件，方便在执行流水线过程中操作文本文件使用，如何将文本转换为文件，可以使用 Pipeline Utility Steps 插件的 writeFile 方法，如下：
writeFile encoding: 'UTF-8', file: './test.txt', text: "写入文件的文本内容"
脚本中使用 Http Rrequest 插件
脚本中可以使用 HttpRequest 来对某一地址进行请求，这里简单使用 Get 请求地址，复杂的可以查看 Jenkins 插件的官网查看使用示例。
下面是使用 Http Request 的 Get 请求示例：
result = httpRequest "http:www.baidu.com"
if ("${result.status}" == "200") {
print "Http 请求成功"
}
脚本中使用 Kubernetes Cli 插件
在之前说过，在 kubectl 镜像中能够使用 kubectl 命令，不过由于执行 Kubectl 命令一般需要在镜像的 $HOME/.kube/ 目录中存在连接 Kubernetes API 的 config 文件，使其 kubectl 命令有明确请求 kubernetes API 的地址和用户权限，不过将 config 文件挂入镜像内部是一件比较繁琐的事情。
好在 Jenkins 提供的 Kubectl Cli 插件，只要在其中配置连接 Kubernetes 的 Token 凭据，就能够在 Kubectl Cli 提供的 withKubeConfig 方法，拥有类似存在 config 一样的功能，在 kubectl 镜像中的 withKubeConfig 方法块内执行 kubectl 就可以操作配置的 Kubectl Cli 的凭据的 K8S 集群。
container('kubectl') {
withKubeConfig([credentialsId: "Kubernetes Token 凭据 ID",serverUrl: "https://kubernetes.default.svc.cluster.local"]) {
sh "kubectl get nodes"
}
}
脚本中操作字符串替换值
在使用 Groovy 语法写 Pipleline 脚本时候，我们经常要替换先前设置好的一些文本的值，这里我们简单示例一下，如何替换字符串。
// 测试的字符串
sourceStr = "这是要替换的值：#value1，这是要替换的值：#value2"
// 替换 #value1 与 #value2 两个值
afterStr = deploy.replaceAll("#value1","AAA").replaceAll("#value2","BBB")
// 输出替换后的字符串
print "${afterStr}"
脚本中读取 pom.xml 参数
在执行 Java 项目的流水线时，我们经常要动态获取项目中的属性，很多属性都配置在项目的 pom.xml 中，还好 Pipeline Utility Steps 插件提供能够读取 pom.xml 的方法，示例如下：
stage('读取pom.xml参数阶段'){
// 读取 Pom.xml 参数
pom = readMavenPom file: './pom.xml'
// 输出读取的参数
print "${pom.artifactId}"
print = "${pom.version}"
}
脚本中使用 Docker 插件构建与推送镜像
在流水线脚本中，我们一般不直接使用 Docker 命令，而是使用 Docker 插件提供的 docker.withRegistry("") 方法来构建与推送镜像，并且还能在方法中配置登录凭据信息，来让仓库验证权限，这点是非常方便的。使用示例如下：
docker.withRegistry("http://xxxx Docker 仓库地址", "Docker 仓库凭据 ID") {
// 构建 Docker 镜像
def customImage = docker.build("${dockerImageName}")
// 推送 Docker 镜像
customImage.push()
}
七、在 Jenkins 创建模板任务
创建一个 Pipeline Job 来充当各个 Jenkins Job 的模板，方便后续创建 Job 时，直接复制模板项目，然后修改配置就能使用。所以这里我们创建一个模板 Pipeline Job，在 Job 配置中需要添加一些参数和环境变量，方便我们动态替换一些值。
创建 Pipeline 任务
配置项目构建基本参数
配置同一时间一个 Job 只能构建一个，不允许多个并发构建。另外需要设置项目构建后，包的保留时间，以防止包过多且大占用大量空间（一个包很可能占 10MB~200MB 大小）导致存储空间不足。
配置 Git 变量
在 Job 配置的 参数化构建过程 中，添加下面参数：
Git 项目地址变量
变量名称：GIT_PROJECT_URL
类型：String
描述：项目 Git 地址
默认值："https://xxxxxxxxxxxx"
Git 分支变量
变量名称：GIT_BRANCH
类型：Git Parameter
描述：选择 Git 分支
默认值：master
Git 凭据变量
变量名称：GIT_CREADENTIAL
类型：Credentials
描述：Git 凭据
默认值：global-git-credential
配置 Maven 变量
Maven 构建命令变量
变量名称：MAVEN_BUILD_OPTION
类型：Choices
描述：要执行的 Maven 命令选择
可选值：['package', 'install', 'deploy']
默认值：install
配置 Docker 变量
Docker 项目地址变量
变量名称：DOCKER_HUB_URL
类型：String
描述：Docker 仓库地址
默认值（默认 Docker 仓库地址）："10.71.164.28:5000"
Docker 仓库项目组变量
变量名称：DOCKER_HUB_GROUP
类型：String
描述：Docker 仓库项目组名
默认值：""
Docker 仓库认证凭据变量
变量名称：DOCKER_HUB_CREADENTIAL
类型：Credentials
描述：Docker 仓库认证凭据
默认值：docker-hub-credential
Docker Dockerfile 文件 ID 变量
变量名称：DOCKER_DOCKERFILE_ID
类型：String
描述：存于 Jenkins "Managed files" 的 Dockerfile 文件的 ID
默认值："global-dockerfile-file"
配置 Kubernetes 变量
Kubernetes 认证凭据变量
变量名称：KUBERNETES_CREADENTIAL
类型：Credentials
描述：Kubernetes 认证 Token
默认值：global-kubernetes-credential
Kubernetes Namespace 变量
变量名称：KUBERNETES_NAMESPACE
类型：String
描述：Kubernetes 命名空间 Namespace
默认值：""
Kubernetes 应用实例副本数
变量名称：KUBERNETES_APP_REPLICAS
类型：String
描述：应用实例副本数
默认值：1
Kubernetes 应用部署 yaml 文件ID
变量名称：KUBERNETES_DEPLOYMENT_ID
类型：String
描述：存于 Jenkins "Managed files" 的 K8S 部署文件的 ID
默认值："global-kubernetes-deployment"
配置 HTTP 变量
HTTP 健康检查端口
变量名称：HTTP_REQUEST_PORT
类型：String
描述：Http Request 端口（健康检测端口）
默认值：8081
HTTP 健康检查地址
变量名称：HTTP_REQUEST_URL
类型：String
描述：Http Request 项目中的相对路径（健康检测路径）
默认值：/actuator/health
HTTP 健康检查次数
变量名称：HTTP_REQUEST_NUMBER
类型：Choices
描述：Http Request 请求次数
可选值：['10', '5', '10', '15', '20', '25', '30']
默认值：10
HTTP 健康检查时间间隔
变量名称：HTTP_REQUEST_INTERVAL
类型：Choices
描述：Http Request 时间间隔
可选值：['10', '5', '15', '20', '25', '30']
默认值：10
八、Pipeline 脚本模板
脚本中包含多个阶段，分别为 Git 拉取镜像，Maven 编译 Java 项目，Docker 构建与推送镜像，Kubectl 部署应用到 Kubernetes 中，最后使用 Http 请求进行健康检查。
def label = "jnlp-agent"
timeout(time: 900, unit: 'SECONDS') {
podTemplate(label: label,cloud: 'kubernetes' ){
node (label) {
stage('Git阶段'){
// 执行 Git 命令进行 Clone 项目
git changelog: true,
branch: "${params.GIT_BRANCH}",
credentialsId: "${params.GIT_CREADENTIAL}",
url: "${GIT_PROJECT_URL}"
}
stage('Maven阶段'){
container('maven') {
// 创建 Maven 需要的 Settings.xml 文件
configFileProvider([configFile(fileId: "global-maven-settings", targetLocation: "settings.xml")]){
// 执行 Maven 命令构建项目，并且设置 Maven 配置为刚刚创建的 Settings.xml 文件
sh "mvn -T 1C clean ${MAVEN_BUILD_OPTION} -Dmaven.test.skip=true --settings settings.xml"
}
}
}
stage('读取pom.xml参数阶段'){
// 读取 Pom.xml 参数
pom = readMavenPom file: './pom.xml'
// 设置 appName 和 appVersion 两个全局参数
appName = "${pom.artifactId}"
appVersion = "${pom.version}"
}
stage('Docker阶段'){
container('docker') {
// 创建 Dockerfile 文件，但只能在方法块内使用
configFileProvider([configFile(fileId: "${params.DOCKER_DOCKERFILE_ID}", targetLocation: "Dockerfile")]){
// 设置 Docker 镜像名称
dockerImageName = "${params.DOCKER_HUB_URL}/${params.DOCKER_HUB_GROUP}/${appName}:${appVersion}"
if ("${params.DOCKER_HUB_GROUP}" == '') {
dockerImageName = "${params.DOCKER_HUB_URL}/${appName}:${appVersion}"
}
// 提供 Docker 环境，使用 Docker 工具来进行 Docker 镜像构建与推送
docker.withRegistry("http://${params.DOCKER_HUB_URL}", "${params.DOCKER_HUB_CREADENTIAL}") {
def customImage = docker.build("${dockerImageName}")
customImage.push()
}
}
}
}
stage('Kubernetes 阶段'){
// kubectl 镜像
container('kubectl') {
// 使用 Kubectl Cli 插件的方法，提供 Kubernetes 环境，在其方法块内部能够执行 kubectl 命令
withKubeConfig([credentialsId: "${params.KUBERNETES_CREADENTIAL}",serverUrl: "https://kubernetes.default.svc.cluster.local"]) {
// 使用 configFile 插件，创建 Kubernetes 部署文件 deployment.yaml
configFileProvider([configFile(fileId: "${params.KUBERNETES_DEPLOYMENT_ID}", targetLocation: "deployment.yaml")]){
// 读取 Kubernetes 部署文件
deploy = readFile encoding: "UTF-8", file: "deployment.yaml"
// 替换部署文件中的变量，并将替换后的文本赋予 deployfile 变量
deployfile = deploy.replaceAll("#APP_NAME","${appName}")
.replaceAll("#APP_REPLICAS","${params.KUBERNETES_APP_REPLICAS}")
.replaceAll("#APP_IMAGE_NAME","${dockerImageName}")
.replaceAll("#APP_UUID",(new Random().nextInt(100000)).toString())
// 生成新的 Kubernetes 部署文件，内容为 deployfile 变量中的文本，文件名称为 "deploy.yaml"
writeFile encoding: 'UTF-8', file: './deploy.yaml', text: "${deployfile}"
// 输出新创建的部署 yaml 文件内容
sh "cat deploy.yaml"
// 执行 Kuberctl 命令进行部署操作
sh "kubectl apply -n ${params.KUBERNETES_NAMESPACE} -f deploy.yaml"
}
}
}
}
stage('应用启动检查'){
// 设置检测延迟时间 10s,10s 后再开始检测
sleep 10
// 健康检查地址
httpRequestUrl = "http://${appName}.${params.KUBERNETES_NAMESPACE}:${params.HTTP_REQUEST_PORT}${params.HTTP_REQUEST_URL}"
// 循环使用 httpRequest 请求，检测服务是否启动
for(n = 1; n <= "${params.HTTP_REQUEST_NUMBER}".toInteger(); n++){
try{
// 输出请求信息和请求次数
print "访问服务：${appName} \n" +
"访问地址：${httpRequestUrl} \n" +
"访问次数：${n}"
// 如果非第一次检测，就睡眠一段时间，等待再次执行 httpRequest 请求
if(n > 1){
sleep "${params.HTTP_REQUEST_INTERVAL}".toInteger()
}
// 使用 HttpRequest 插件的 httpRequest 方法检测对应地址
result = httpRequest "${httpRequestUrl}"
// 判断是否返回 200
if ("${result.status}" == "200") {
print "Http 请求成功，流水线结束"
break
}
}catch(Exception e){
print "监控检测失败，将在 ${params.HTTP_REQUEST_INTERVAL} 秒后将再次检测。"
// 判断检测次数是否为最后一次检测，如果是最后一次检测，并且还失败了，就对整个 Jenkins 任务标记为失败
if (n == "${params.HTTP_REQUEST_NUMBER}".toInteger()) {
currentBuild.result = "FAILURE"
}
}
}
}
}
}
}
变量说明：
GIT_BRANCH： Git 项目分支变量。
GIT_PROJECT_URL： Git 项目 URL 变量。
GIT_CREADENTIAL： Git 凭据 ID 变量。
MAVEN_BUILD_OPTION： Maven 执行的构建命令，package、install 或 deploy。
global-maven-settings： 全局 Maven 的 Settings.xml 文件的 ID 值，这里是使用 configFileProvider 插件来创建该文件。
pom.artifactId： 从 pom.xml 文件中读取的 artifactId 参数值。
pom.version： 从 pom.xml 文件中读取的 version 参数值。
DOCKER_DOCKERFILE_ID： Dockerfile 文件的 ID。
DOCKER_HUB_URL： Docker 仓库 URL 地址。
DOCKER_HUB_GROUP： Docker 仓库项目组名。
DOCKER_HUB_CREADENTIAL： Docker 仓库认证凭据。
appName： 从 pom.xml 中读取的应用名称。
appVersion： 从 pom.xml 中读取的应用版本号。
KUBERNETES_DEPLOYMENT_ID： Kubernetes 部署文件的 ID。
KUBERNETES_CREADENTIAL： Kubernetes API 认证凭据。
KUBERNETES_NAMESPACE： Kubernetes 部署应用的 Namespace。
KUBERNETES_APP_REPLICAS： Kubernetes 部署应用的副本数。
dockerImageName： Docker 镜像名称。
HTTP_REQUEST_PORT： HTTP 健康检查端口。
HTTP_REQUEST_URL： HTTP 健康检查 URL 地址。
HTTP_REQUEST_NUMBER： HTTP 健康检查次数。
HTTP_REQUEST_INTERVAL： HTTP 健康检查间隔。
将该流水线代码，配置到之前的模板 Job 的流水线脚本中，方便后续项目以此项目为模板。
