呼和浩特网站建设信息,兰州做公司网站,佛山软件开发培训,免费制作模卡app的软件目录[-]
. 一、Kubernetes 部署 Jenkins. 1、NFS 存储卷创建 Jenkins 目录. 2、创建 Jenkins 用于存储的 PV、PVC. 3、创建 ServiceAccount ClusterRoleBinding. 4、创建 Service Deployment. 5、获取 Jenkins 生成的 Token. 6、启动 Jenkins 进行初始化. 二、Jen…目录[-]
. 一、Kubernetes 部署 Jenkins. 1、NFS 存储卷创建 Jenkins 目录. 2、创建 Jenkins 用于存储的 PV、PVC. 3、创建 ServiceAccount ClusterRoleBinding. 4、创建 Service Deployment. 5、获取 Jenkins 生成的 Token. 6、启动 Jenkins 进行初始化. 二、Jenkins 安装相关插件. 三、配置相关凭据. 1、添加 Git 认证凭据. 2、添加 Kubernetes Token 凭据. 3、添加 Docker 仓库认证凭据. 四、Jenkins 配置 Kubernetes 插件. 1、Kubernetes Plugin 基本配置. 2、Kubernetes 插件 Pod 模板配置. 3、Kubernetes 插件 Container 配置. 4、Container 存储挂载配置. 五、创建相关文件. 1、新增 Maven 配置文件. 2、新增 Dockerfile 文件. 3、新增 Kubernetes 部署文件. 六、如何写流水线脚本和使用插件. 1、脚本中设置全局超时时间. 2、脚本中使用 Git 插件. 3、脚本中使用 Kubernetes 插件. 4、脚本中使用 Docker 镜像. 5、脚本中引入 Jenkins 中预先存储的文件. 6、脚本创建文件. 7、脚本中使用 Http Rrequest 插件. 8、脚本中使用 Kubernetes Cli 插件. 9、脚本中操作字符串替换值. 10、脚本中读取 pom.xml 参数. 11、脚本中使用 Docker 插件构建与推送镜像. 七、在 Jenkins 创建模板任务. 1、创建 Pipeline 任务. 2、配置项目构建基本参数. 3、配置 Git 变量. 4、配置 Maven 变量. 5、配置 Docker 变量. 6、配置 Kubernetes 变量. 7、配置 HTTP 变量. 八、创建 Pipeline 脚本. 1、脚本中使用 Kubernetes 插件及设置超时时间. 2、脚本中 Git 拉取项目阶段. 3、脚本中 Maven 编译项目阶段. 4、脚本中读取 pom.xml 参数阶段. 5、脚本中 Docker 镜像构建与推送模块. 6、Kubernetes 模块. 7、HTTP 健康检查模块. 8、完整脚本. 九、创建任务从模板任务复制配置. 1、创建新的 Job 并复制模板项目配置. 2、修改新建 Job 的部分配置项. 十、执行 pipeline 任务进行测试系统环境
Jenkins 版本2.199Kubernetes 版本1.15.3
参考地址
Jenkins 官方网址Jenkins Github 网址Jenkins Kubernetes 插件 Github 网址示例的配置与部署文件的 Github 地址https://github.com/my-dlq/blog-example/tree/master/jenkins/jenkins-cicd
CI/CD 流程图: 整个流程
(1)、介绍了如何在 Kubernetes 部署 Jenkins。(2)、介绍 Jenkins 中需要安装什么相关插件。(3)、配置凭据例如 Docker 仓库凭据、K8S 连接凭据、Git 认证凭据。(4)、在 Jenkins 中存储执行流水线过程中的脚本例如 Docker 的 Dockerfile、Maven 的 Settings.xml。(5)、简介描述了如何写 “脚本式” 的流水线脚本以及脚本中如何使用各种常用插件。(6)、创建一个用于当做模板的 Job对其进行一些参数化构建变量配置方便后续全部的 Job 通过复制该模板 Job 来新建。(7)、写流水线脚本将分为 Git、Maven、Docker、Kubectl、Http 等几个阶段。写完脚本后放置到上面创建模板 Job 的脚本框框中。(8)、通过复制模板 Job 来新创建用于测试的项目 Job并且修改其中从模板 Job 复制过来的变量的参数将其改成适用于该测试项目的参数值。(9)、执行上面创建的测试项目的 Job观察它是否能够正常执行完整个脚本并且结果为成功。
一、Kubernetes 部署 Jenkins
下面是以 NFS 为存储卷的示例将在 NFS 存储卷上创建 Jenkins 目录然后创建 NFS 类型的 PV、PVC。
1、NFS 存储卷创建 Jenkins 目录
进入 NFS Server 服务器然后再其存储目录下创建 Jenkins 目录并且确保目录对其它用户有读写权限。
$ mkdir /nfs/data/jenkins2、创建 Jenkins 用于存储的 PV、PVC
创建 Kubernetes 的 PV、PVC 资源其中 PV 用于与 NFS 关联需要设置 NFS Server 服务器地址和挂载的路径修改占用空间大小。而 PVC 则是与应用关联方便应用与 NFS 绑定挂载下面是 PV、PVC 的资源对象 yaml 文件。
jenkins-storage.yaml
apiVersion: v1
kind: PersistentVolume
metadata:name: jenkinslabels:app: jenkins
spec:capacity: storage: 50GiaccessModes: - ReadWriteOncepersistentVolumeReclaimPolicy: Retain mountOptions: #NFS挂载选项- hard- nfsvers4.1 nfs: #NFS设置path: /nfs/data/jenkins server: 192.168.2.11
---
kind: PersistentVolumeClaim
apiVersion: v1
metadata:name: jenkins
spec:accessModes:- ReadWriteOnceresources:requests:storage: 50Gi #存储空间大小selector:matchLabels:app: jenkins将 PV 与 PVC 部署到 Kubernetes 中
-n指定 namespace
$ kubectl apply -f jenkins-storage.yaml -n public3、创建 ServiceAccount ClusterRoleBinding
Kubernetes 集群一般情况下都默认开启了 RBAC 权限所以需要创建一个角色和服务账户设置角色拥有一定权限然后将角色与 ServiceAccount 绑定最后将 ServiceAccount 与 Jenkins 绑定这样来赋予 Jenkins 一定的权限使其能够执行一些需要权限才能进行的操作。这里为了方便将 cluster-admin 绑定到 ServiceAccount 来保证 Jenkins 拥有足够的权限。
注意 请修改下面的 Namespace 参数改成部署的 Jenkins 所在的 Namespace。
jenkins-rbac.yaml
apiVersion: v1
kind: ServiceAccount
metadata:name: jenkins-admin #ServiceAccount名namespace: mydlqcloud #指定namespace一定要修改成你自己的namespacelabels:name: jenkins
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:name: jenkins-adminlabels:name: jenkins
subjects:- kind: ServiceAccountname: jenkins-adminnamespace: mydlqcloud
roleRef:kind: ClusterRolename: cluster-adminapiGroup: rbac.authorization.k8s.io将 Jenkins 的 RBAC 部署到 Kubernetes 中
-n指定 namespace
$ kubectl apply -f jenkins-rbac.yaml -n public4、创建 Service Deployment
在 Kubernetes 中部署服务需要部署文件这里部署 Jenkins 需要创建 Service 与 Deployment 对象其中两个对象需要做一些配置如下
ServiceService 暴露两个接口 8080 与 50000其中 8080 是 Jenkins API 和 UI 的端口而 50000 则是供代理使用的端口。Deployment Deployment 中需要设置容器安全策略为 runAsUser: 0 赋予容器以 Root 权限运行并且暴露 8080 与 50000 两个端口与 Service 对应而且还要注意的是还要设置上之前创建的服务账户 “jenkins-admin”。
jenkins-deployment.yaml
apiVersion: v1
kind: Service
metadata:name: jenkinslabels:app: jenkins
spec:type: NodePortports:- name: httpport: 8080 #服务端口targetPort: 8080nodePort: 32001 #NodePort方式暴露 Jenkins 端口- name: jnlpport: 50000 #代理端口targetPort: 50000nodePort: 32002selector:app: jenkins
---
apiVersion: apps/v1
kind: Deployment
metadata:name: jenkinslabels:app: jenkins
spec:selector:matchLabels:app: jenkinsreplicas: 1template:metadata:labels:app: jenkinsspec:serviceAccountName: jenkins-admincontainers:- name: jenkinsimage: jenkins/jenkins:2.199securityContext: runAsUser: 0 #设置以ROOT用户运行容器privileged: true #拥有特权ports:- name: httpcontainerPort: 8080- name: jnlpcontainerPort: 50000resources:limits:memory: 2Gicpu: 2000mrequests:memory: 2Gicpu: 2000menv:- name: LIMITS_MEMORYvalueFrom:resourceFieldRef:resource: limits.memorydivisor: 1Mi- name: JAVA_OPTS #设置变量指定时区和 jenkins slave 执行者设置value: -Xmx$(LIMITS_MEMORY)m -XshowSettings:vm -Dhudson.slaves.NodeProvisioner.initialDelay0-Dhudson.slaves.NodeProvisioner.MARGIN50-Dhudson.slaves.NodeProvisioner.MARGIN00.85-Duser.timezoneAsia/Shanghai - name: JENKINS_OPTSvalue: --prefix/jenkins #设置路径前缀加上 JenkinsvolumeMounts: #设置要挂在的目录- name: datamountPath: /var/jenkins_homevolumes:- name: datapersistentVolumeClaim:claimName: jenkins #设置PVC参数说明
JAVA_OPTS JVM 参数设置JENKINS_OPTS Jenkins 参数设置其它参数 默认情况下Jenkins 生成代理是保守的。例如如果队列中有两个构建它不会立即生成两个执行器。它将生成一个执行器并等待某个时间释放第一个执行器然后再决定生成第二个执行器。Jenkins 确保它生成的每个执行器都得到了最大限度的利用。如果你想覆盖这个行为并生成一个执行器为每个构建队列立即不等待所以在 Jenkins 启动时候添加这些参数:
-Dhudson.slaves.NodeProvisioner.initialDelay0
-Dhudson.slaves.NodeProvisioner.MARGIN50
-Dhudson.slaves.NodeProvisioner.MARGIN00.85有了上面的部署文件后再将 Jenkins 部署到 Kuberntes 中
-n指定应用启动的 namespace
$ kubectl create -f jenkins-deployment.yaml -n mydlqcloud5、获取 Jenkins 生成的 Token
在安装 Jenkins 时候它默认生成一段随机字符串在控制台日志中用于安装时验证。这里需要获取它输出在控制台中的日志信息来获取 Token 字符串。
查看 Jenkins Pod 启动日志
-n指定应用启动的 namespace
$ kubectl log $(kubectl get pods -n mydlqcloud | awk {print $1} | grep jenkins) -n mydlqcloud在日志中可以看到默认给的token为
*************************************************************
Jenkins initial setup is required. An admin user has been created and a password generated.
Please use the following password to proceed to installation:96b19967a2aa4e7ab7d2ea5c6f55db8dThis may also be found at: /var/jenkins_home/secrets/initialAdminPassword
*************************************************************6、启动 Jenkins 进行初始化
输入 Kubernetes 集群地址和 Jenkins Service 设置的 NodePort 端口号访问 Jenkins UI 界面进行初始化按以下步骤执行
进入Jenkins
输入 Kubernetes 集群地址和上面设置的 Nodeport 方式的端口号 32001然后输入上面获取的 Token 字符串。例如本人 Kubernetes 集群 IP 为 192.168.2.11 所以就可以访问地址 http://192.168.2.11:32001/jenkins 进入 Jenkins 初始化界面。 安装插件
安装插件选择 推荐安装 方式进行安装即可后续再安装需要的插件。 设置用户名、密码
在这里输入一个用户名、密码方便后续登录如果不设置可能下次登录需要使用之前日志中默认的 Token 串来登录。 配置 Jenkins 地址
配置 Jenkins URL 地址来告知 Jenkins 自己的 URL在发送邮件、触发钩子等可能用到。 进入 Jenkins 界面
到此 Jenkins 初始化就配置完成成功进入 Jenkins 界面。 二、Jenkins 安装相关插件
Jenkins 中可以打开 系统管理-插件管理-可选插件 来安装下面的一些插件
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 等认证凭据。
1、添加 Git 认证凭据
配置的参数值
类型Username with password范围全局用户名Git 用户名 略密码Git 密码略IDglobal-git-credential描述全局 Git 凭据2、添加 Kubernetes Token 凭据
配置的参数值
类型Secret text范围全局SecretK8S Token 串略IDglobal-kubernetes-credential描述全局的 K8S Token3、添加 Docker 仓库认证凭据
配置的参数值
类型Username with password范围全局用户名Docker 仓库用户名略密码Docker 仓库密码略IDdocker-hub-credential描述Docker 仓库认证凭据四、Jenkins 配置 Kubernetes 插件
进入 系统管理-系统设置-云 中点击 新增一个云 选项来新建一个与 Kubernetes 的连接然后按照下面各个配置项进行配置。
1、Kubernetes Plugin 基本配置
(1)、配置连接 Kubernetes 参数
配置 Kubernetes API 地址然后再选择 Kubernetes Token 凭据。 注意 如果你的 Jenkins 也是安装在 Kubernetes 环境中那么可以直接使用 Kubernetes 集群内的 Kubernetes API 地址如果 Jnekins 是在安装在正常物理机或者虚拟机环境中那么使用集群外的 Kubernetes API 地址两个地址如下
集群内地址https://kubernetes.default.svc.cluster.local集群外地址https://{Kubernetes 集群 IP}:6443
然后点击连接测试查看是否能成功连通 Kubernetes如果返回结果 Successful 则代表连接成功否则失败。 (2)、配置 Jenkins 地址 注意 这里的 Jenkins 地址是供 Slave 节点连接 Jenkins Master 节点用的所以这里需要配置 Jenkins Master 的 URL 地址。这里和上面一样也是考虑 Jenkins 是部署在 Kubernetes 集群内还是集群外两个地址如下
集群内地址https://{Jenkins Pod 名称}.{Jenkins Pod 所在 Namespace}/{Jenkins 前缀}集群外地址https://{Kubernetes 集群 IP}:{Jenkins NodePort 端口}/{Jenkins 前缀}如果 Jnekins 中配置了 /jenkins 前缀则 URL 后面加上 /jenkins否则不加这个地址根据自己的 Jnekins 实际情况来判断。 2、Kubernetes 插件 Pod 模板配置
(1)、配置 Pod 名称和标签列表
配置 Pod 模板的名称和标签列表名Pod 模板名可用于子模板继承标签列表可用于 Jenkins Job 中指定使用此 Pod 模板来执行任务。 (2)、配置 Pod 的原始 yaml
在 Pod 的原始 yaml 配置中加入一段配置用于改变 Kubernetes Plugin 自带的 JNLP 镜像并指定 RunAsUser0 来使容器以 Root 身份执行任务并设置 privilegedtrue 来让 Slave Pod 在 Kubernetes 中拥有特权。 Jenkins Slave JNLP 镜像官方地址 https://hub.docker.com/r/jenkins/slave 可以从中下载相关 JNLP 代理镜像。 yaml 内容如下
apiVersion: v1
kind: Pod
metadata:labels:app: jenkins-slave
spec:securityContext:runAsUser: 0privileged: truecontainers:- name: jnlptty: trueworkingDir: /home/jenkins/agentimage: registry.cn-shanghai.aliyuncs.com/mydlq/jnlp-slave:3.35-5-alpine3、Kubernetes 插件 Container 配置
将配置 Jenkins Slave 在 Kubernetes 中的 Pod 中所包含容器信息这里镜像都可以从官方 Docker Hub 下载由于网速原因本人已经将其下载到 Aliyun 镜像仓库。
(1)、配置 Maven 镜像
名称mavenDocker 镜像registry.cn-shanghai.aliyuncs.com/mydlq/maven:3.6.0-jdk8-alpine其它参数默认值即可Maven 镜像可以从官方 Docker Hub 下载地址https://hub.docker.com/_/maven (2)、配置 Docker In Docker 镜像
名称dockerDocker 镜像registry.cn-shanghai.aliyuncs.com/mydlq/docker:18.06.3-dind其它参数默认值即可Docker-IN-Docker 镜像可以从官方 Docker Hub 下载地址https://hub.docker.com/_/docker (3)、配置 Kubectl 镜像
名称kubectlDocker 镜像registry.cn-shanghai.aliyuncs.com/mydlq/kubectl:1.15.3其它参数默认值即可Kubectl 镜像可以从官方 Docker Hub 下载地址https://hub.docker.com/r/bitnami/kubectl 4、Container 存储挂载配置
由于上面配置的 Maven、Docker 等都需要挂载存储Maven 中是将中央仓库下载的 Jar 存储到共享目录而 Docker 则是需要将宿主机的 Docker 配置挂载到 Docker In Docker 容器内部所以我们要对挂载进行配置。
(1)、创建 Maven 存储使用的 PV、PVC
提前在 NFS 卷中创建用于存储 Maven 相关 Jar 的目录 创建的目录要确保其它用户有读写权限。 $ mkdir /nfs/data/maven然后Kubernetes 下再创建 Maven 的 PV、PVC 部署文件
maven-storage.yaml
apiVersion: v1
kind: PersistentVolume
metadata:name: mavenlabels:app: maven
spec:capacity: storage: 100GiaccessModes: - ReadWriteOncepersistentVolumeReclaimPolicy: Retain mountOptions: #NFS挂在选项- hard- nfsvers4.1 nfs: #NFS设置path: /nfs/data/maven server: 192.168.2.11
---
kind: PersistentVolumeClaim
apiVersion: v1
metadata:name: maven
spec:accessModes:- ReadWriteOnceresources:requests:storage: 100Gi #存储空间大小selector:matchLabels:app: maven部署 PV、PVC 到 Kubernetes 中
-n指定 namespace
$ kubectl apply -f maven-storage.yaml -n public(2)、配置 Maven 挂载
在卷选项中选择添加卷选择 Persistent Volume Claim 按如下添加配置
申明值PVC 名称maven挂在路径容器内的目录/root/.m2(3)、配置 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五、创建相关文件
之前安装了 Config File Provider 插件该插件功能就是可以在 Jenkins 上存储一些配置文件例如我们经常使用到的 yaml、properties、Dockerfile、Maven 的 Settings.xml 等文件都可以存储到 Jenkins 该插件中。
打开 系统管理-Managed files 在其中新增几个文件
Maven 配置文件 Maven 的 Settings.xml 配置文件。Dockerfile 文件 Dockerfile 脚本。Kubernetes 部署文件 将应用部署到 kubernetes 的 Deployment 文件。
1、新增 Maven 配置文件
选择 Add a new Config—Global Maven settings.xml 来新增一个 Maven 全局 Settings.xml 文件
ID global-maven-settingsName MavenGlobalSettingsComment 全局 Maven Settings.xml 文件Content 内容如下↓为了加快 jar 包的下载速度这里将仓库地址指向 aliyun Maven 仓库地址。 ?xml version1.0 encodingUTF-8?settings xmlnshttp://maven.apache.org/SETTINGS/1.0.0 xmlns:xsihttp://www.w3.org/2001/XMLSchema-instance xsi:schemaLocationhttp://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsdpluginGroups/pluginGroupsproxies/proxiesservers/serversmirrors!--Aliyun Maven--mirroridalimaven/idnamealiyun maven/nameurlhttp://maven.aliyun.com/nexus/content/groups/public//urlmirrorOfcentral/mirrorOf/mirror/mirrorsprofiles/profiles/settings2、新增 Dockerfile 文件
选择 Add a new Config—Custom file 来新增一个 Dockerfile 文件
ID global-dockerfile-fileName DockerfileComment 全局 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.timezoneAsia/Shanghai -Djava.security.egdfile:/dev/./urandom
ENV JAVA_OPTS
ENV APP_OPTS
ENTRYPOINT [ sh, -c, java $JVM_OPTS $JAVA_OPTS -jar /app.jar $APP_OPTS ]3、新增 Kubernetes 部署文件
选择 Add a new Config—Custom file 来新增一个 Kubernetes 部署文件
ID global-kubernetes-deploymentName deployment.yamlComment 全局 Kubernetes 部署文件Content 内容如下↓
apiVersion: v1
kind: Service
metadata:name: #APP_NAMElabels:app: #APP_NAME
spec:type: NodePortports:- name: server #服务端口port: 8080 targetPort: 8080- name: management #监控及监控检查的端口 port: 8081targetPort: 8081selector:app: #APP_NAME
---
apiVersion: apps/v1
kind: Deployment
metadata:name: #APP_NAMElabels:app: #APP_NAME
spec:replicas: #APP_REPLICASselector:matchLabels:app: #APP_NAMEstrategy:type: Recreate #设置更新策略为删除策略template:metadata:labels:app: #APP_NAMEspec:containers:- name: #APP_NAMEimage: #APP_IMAGE_NAMEimagePullPolicy: Alwaysports:- containerPort: 8080 #服务端口name: server- containerPort: 8081 #监控及监控检查的端口 name: managementenv:- name: update_uuidvalue: #APP_UUID #生成的随机值放置执行kubectl apply时能够执行resources: limits:cpu: 2000mmemory: 1024Mirequests:cpu: 1000mmemory: 512Mi为了模板能够动态替换某些值上面模板中设置了几个可替换的参数用 #变量名称 来标记后面我们在执行 Pipeline 时候将里面的 #xxx变量 标记替换掉上面配置的变量有
#APP_NAME 应用名称。#APP_REPLICAS 应用副本数。#APP_IMAGE_NAME 镜像名称。#APP_UUID 生成的随机值因为后续 Kubectl 在执行命令时候如果部署对象中的值没有一点变化的话将不会执行 kubectl apply 命令所以这里设置了一个随机值以确保每次部署文件都不一致。
并且还有一点就是要注意设置更新策略为 Recreate删除再创建 策略否则后面的健康检查阶段将不能正常检查更新后的项目。 Kubernetes 默认为 RollingUpdate 策略该策略为应用启动时先将新实例启动再删除旧的实例就是因为这样在后面健康检查阶段健康检查 URL 地址还是未更新前的旧实例的 URL 地址会导致健康检查不准确所以必须改为 Recreate 策略先删除旧实例再创建新实例。 六、如何写流水线脚本和使用插件
1、脚本中设置全局超时时间
设置任务超时时间如果在规定时间内任务没有完成则进行失败操作格式如下
timeout(time: 60, unit: SECONDS) {// 脚本
}2、脚本中使用 Git 插件
Git 插件方法使用格式及其部分参数
changelog 是否检测变化日志url Git 项目地址branch Git 分支credentialsId Jenkins 存的 Git 凭据 ID 值
git changelog: true,url: http://gitlab.xxxx/xxx.gitbranch: master,credentialsId: xxxx-xxxx-xxxx-xxxx,3、脚本中使用 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 标签名称。
4、脚本中使用 Docker 镜像
在之前配置了 Kubernetes 插件的 Pod Template 配置中配置了几个容器每个容器中都有特定的功能的环境例如
Maven 容器中能够执行 mvn 命令。Kuberctl 容器能够执行 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
}5、脚本中引入 Jenkins 中预先存储的文件
在之前的 系统设置-File Manager 中存储了很多文件例如
Docker 的镜像构建脚本文件 Dockerfile。Maven 的全局设置文件 Settings.xmlKubernetes 的部署文件 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
}创建 Dockerfile 文件
configFileProvider([configFile(fileId: global-kubernetes-deployment, targetLocation: deployment.yaml)]){sh cat deployment.yaml
}6、脚本创建文件
在使用 Groovy 写 Pipleline 脚本时候经常要将变量的文本生成文件方便在执行流水线过程中操作文本文件使用如何将文件转换为文件可以使用 Pipeline Utility Steps 插件的 writeFile 方法如下
writeFile encoding: UTF-8, file: ./test.txt, text: 写入文件的文本内容7、脚本中使用 Http Rrequest 插件
脚本中可以使用 HttpRequest 来对某一地址进行请求这里简单使用 Get 请求地址复杂的可以查看 Jenkins 插件的官网查看使用示例。
下面是使用 Http Request 的 Get 请求示例
result httpRequest http:www.baidu.comif (${result.status} 200) {print Http 请求成功
} 8、脚本中使用 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}
}9、脚本中操作字符串替换值
在使用 Groovy 语法写 Pipleline 脚本时候我们经常要替换先前设置好的一些文本的值这里我们简单示例一下如何替换字符串。
// 测试的字符串
sourceStr 这是要替换的值#value1这是要替换的值#value2
// 替换#value1与#value2连个值
afterStr deploy.replaceAll(#value1,AAA).replaceAll(#value2,BBB)
// 输出替换后的字符串
print ${afterStr}10、脚本中读取 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}
}11、脚本中使用 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 配置中需要添加一些参数和环境变量方便我们动态替换一些值。
1、创建 Pipeline 任务
任务名称 my-template任务类型 流水线项目2、配置项目构建基本参数
配置同一时间一个 Job 只能构建一个不允许多个并发构建。另外需要设置项目构建后包的保留时间以防止包过多且大占用大量空间一个包很肯能占 10MB~200MB 大小导致储不足。 3、配置 Git 变量
在 Job 配置的 参数化构建过程 中添加下面参数
Git 项目地址变量
变量名称GIT_PROJECT_URL类型String描述项目 Git 地址默认值”https://xxxxxxxxxxxxGit 分支变量
变量名称GIT_BRANCH类型Git Parameter描述选择 Git 分支默认值masterGit 凭据变量
变量名称GIT_CREADENTIAL类型Credentials描述Git 凭据默认值global-git-credential4、配置 Maven 变量
Maven 构建命令变量
变量名称MAVEN_BUILD_OPTION类型Choices描述要执行的执行 Maven 命令选择可选值[‘package’, ‘install’, ‘deploy’]默认值install5、配置 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-credentialDocker Dockerfile 文件 ID 变量
变量名称DOCKER_DOCKERFILE_ID类型String描述存于 Jenkins “Managed files” 的 Dockerfile 文件的 ID默认值”global-dockerfile-file”6、配置 Kubernetes 变量
Kubernetes 认证凭据变量
变量名称KUBERNETES_CREADENTIAL类型Credentials描述Kubernetes 认证 Token默认值global-kubernetes-credentialKubernetes Namespace 变量
变量名称KUBERNETES_NAMESPACE类型String描述Kubernetes 命名空间 Namespace默认值””Kubernetes 应用实例副本数
变量名称KUBERNETES_APP_REPLICAS类型String描述应用实例副本数默认值1Kubernetes 应用部署 yaml 文件ID
变量名称KUBERNETES_DEPLOYMENT_ID类型String描述存于 Jenkins “Managed files” 的 K8S 部署文件的 ID默认值”global-kubernetes-deployment”7、配置 HTTP 变量
HTTP 健康检查端口
变量名称HTTP_REQUEST_PORT类型String描述Http Request 端口健康检测端口默认值8081HTTP 健康检查地址
变量名称HTTP_REQUEST_URL类型String描述Http Request 项目中的相对路径健康检测路径默认值/actuator/healthHTTP 健康检查次数
变量名称HTTP_REQUEST_NUMBER类型Choices描述Http Request 请求次数可选值[‘10’, ‘5’, ‘10’, ‘15’, ‘20’, ‘25’, ‘30’]默认值10HTTP 健康检查时间间隔
变量名称HTTP_REQUEST_INTERVAL类型Choices描述Http Request 时间间隔可选值[‘10’, ‘5’, ‘15’, ‘20’, ‘25’, ‘30’]默认值10八、创建 Pipeline 脚本
接下将使用 Groovy 语法创建一个为 SpringBoot 项目准备的 CI/CD 的脚本式的流水线脚本。其中脚本中包含多个阶段分别为 Git 拉取镜像Maven 编译 Java 项目Docker 构建与推送镜像Kubectl 部署应用到 Kubernetes 中最后使用 Http 请求进行健康检查下面是各个阶段脚本及其介绍。
1、脚本中使用 Kubernetes 插件及设置超时时间
使用 Kubernetes 插件执行任务并设置超时时间为 10 分钟脚本如下
// 设置超时时间 600 SECONDS方法块内的方法执行超时任务就标记为失败
timeout(time: 600, unit: SECONDS) {def label jnlp-agentpodTemplate(label: label,cloud: kubernetes ){node (label) {print 在 Slave Pod 中执行任务 }}
}2、脚本中 Git 拉取项目阶段
接下来接着往整体的脚本中添加 Git 模块其中需要引用上面配置的变量将变量填入脚本中的方法如下
timeout(time: 600, unit: SECONDS) {def label jnlp-agentpodTemplate(label: label,cloud: kubernetes ){node (label) {stage(Git阶段){git changelog: true,url: ${params.GIT_PROJECT_URL}branch: ${params.GIT_BRANCH},credentialsId: ${params.GIT_CREADENTIAL}}}}
}变量介绍
GIT_BRANCH Git 项目分支变量。GIT_PROJECT_URL Git 项目 URL 变量。GIT_CREADENTIAL Git 凭据 ID 变量。
3、脚本中 Maven 编译项目阶段
timeout(time: 600, unit: SECONDS) {def label jnlp-agentpodTemplate(label: label,cloud: kubernetes ){node (label) {stage(Git阶段){git changelog: true,url: ${params.GIT_PROJECT_URL}branch: ${params.GIT_BRANCH},credentialsId: ${params.GIT_CREADENTIAL}}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.skiptrue --settings settings.xml}}}}}
}变量介绍
MAVEN_BUILD_OPTION Maven 执行的构建命令package、install 或 deploy。global-maven-settings 全局 Maven 的 Settings.xml 文件的 ID 值这里是使用 configFileProvider 插件来创建该文件。
4、脚本中读取 pom.xml 参数阶段
这里使用 Pipeline Utility Steps 的 readMavenPom 方法读取项目的 pom.xml 文件并设置 appName 与 appVersion 两个全局参数。
timeout(time: 600, unit: SECONDS) {def label jnlp-agentpodTemplate(label: label,cloud: kubernetes ){node (label) {stage(Git阶段){git changelog: true,url: ${params.GIT_PROJECT_URL}branch: ${params.GIT_BRANCH},credentialsId: ${params.GIT_CREADENTIAL}}stage(Maven阶段){container(maven) { // 创建 Maven 需要的 Settings.xml 文件configFileProvider([configFile(fileId: global-maven-settings, targetLocation: settings.xml)]){// 执行 Maven 命令构建项目sh mvn -T 1C clean ${MAVEN_BUILD_OPTION} -Dmaven.test.skiptrue --settings settings.xml}}}stage(读取pom.xml参数阶段){// 读取 Pom.xml 参数pom readMavenPom file: ./pom.xml// 设置 appName 和 appVersion 两个全局参数appName ${pom.artifactId}appVersion ${pom.version}}}}
}变量介绍
pom.artifactId 从 pom.xml 文件中读取的 artifactId 参数值。pom.version 从 pom.xml 文件中读取的 version 参数值。
5、脚本中 Docker 镜像构建与推送模块
timeout(time: 600, unit: SECONDS) {def label jnlp-agentpodTemplate(label: label,cloud: kubernetes ){node (label) {stage(Git阶段){git changelog: true,url: ${params.GIT_PROJECT_URL}branch: ${params.GIT_BRANCH},credentialsId: ${params.GIT_CREADENTIAL}}stage(Maven阶段){container(maven) { // 创建 Maven 需要的 Settings.xml 文件configFileProvider([configFile(fileId: global-maven-settings, targetLocation: settings.xml)]){// 执行 Maven 命令构建项目sh mvn -T 1C clean ${MAVEN_BUILD_OPTION} -Dmaven.test.skiptrue --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}// 判断 DOCKER_HUB_GROUP 是否为空有些仓库是不设置仓库组的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()}}}}}}
}变量介绍
DOCKER_DOCKERFILE_ID Dockerfile 文件的 ID。DOCKER_HUB_URL Docker 仓库 URL 地址。DOCKER_HUB_GROUP Docker 仓库项目组名。DOCKER_HUB_CREADENTIAL Docker 仓库认证凭据。appName 从 pom.xml 中读取的应用名称。appVersion 从 pom.xml 中读取的应用版本号。
6、Kubernetes 模块
timeout(time: 600, unit: SECONDS) {def label jnlp-agentpodTemplate(label: label,cloud: kubernetes ){node (label) {stage(Git阶段){git changelog: true,url: ${params.GIT_PROJECT_URL}branch: ${params.GIT_BRANCH},credentialsId: ${params.GIT_CREADENTIAL}}stage(Maven阶段){container(maven) { // 创建 Maven 需要的 Settings.xml 文件configFileProvider([configFile(fileId: global-maven-settings, targetLocation: settings.xml)]){// 执行 Maven 命令构建项目sh mvn -T 1C clean ${MAVEN_BUILD_OPTION} -Dmaven.test.skiptrue --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}// 判断 DOCKER_HUB_GROUP 是否为空有些仓库是不设置仓库组的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 阶段){container(kubectl) {// 使用 Kubectl Cli 插件的方法提供 Kubernetes 环境在其方法块内部能够执行 kubectl 命令withKubeConfig([credentialsId: ${params.KUBERNETES_CREADENTIAL},serverUrl: https://kubernetes.default.svc.cluster.local]) {// 使用 configFile 插件创建 Kubernetes 部署文件 deployment.yamlconfigFileProvider([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.yamlwriteFile encoding: UTF-8, file: ./deploy.yaml, text: ${deployfile}// 输出新创建的部署 yaml 文件内容sh cat deploy.yaml// 执行 Kuberctl 命令进行部署操作sh kubectl apply -n ${params.KUBERNETES_NAMESPACE} -f deploy.yaml}}}}}}
}变量介绍
KUBERNETES_DEPLOYMENT_ID Kubernetes 部署文件的 ID。KUBERNETES_CREADENTIAL Kubernetes API 认证凭据。KUBERNETES_NAMESPACE Kubernetes 部署应用的 Namespace。KUBERNETES_APP_REPLICAS Kubernetes 部署应用的副本数。appName 从 pom.xml 中读取的应用名称。dockerImageName Docker 镜像名称。
7、HTTP 健康检查模块
timeout(time: 600, unit: SECONDS) {def label jnlp-agentpodTemplate(label: label,cloud: kubernetes ){node (label) {stage(Git阶段){git changelog: true,url: ${params.GIT_PROJECT_URL}branch: ${params.GIT_BRANCH},credentialsId: ${params.GIT_CREADENTIAL}}stage(Maven阶段){container(maven) { // 创建 Maven 需要的 Settings.xml 文件configFileProvider([configFile(fileId: global-maven-settings, targetLocation: settings.xml)]){// 执行 Maven 命令构建项目sh mvn -T 1C clean ${MAVEN_BUILD_OPTION} -Dmaven.test.skiptrue --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}// 判断 DOCKER_HUB_GROUP 是否为空有些仓库是不设置仓库组的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 阶段){container(kubectl) {// 使用 Kubectl Cli 插件的方法提供 Kubernetes 环境在其方法块内部能够执行 kubectl 命令withKubeConfig([credentialsId: ${params.KUBERNETES_CREADENTIAL},serverUrl: https://kubernetes.default.svc.cluster.local]) {// 使用 configFile 插件创建 Kubernetes 部署文件 deployment.yamlconfigFileProvider([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.yamlwriteFile 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}// 判断是否返回 200if (${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}}}}}}
}变量介绍
HTTP_REQUEST_PORT HTTP 健康检查端口。HTTP_REQUEST_URL HTTP 健康检查 URL 地址。HTTP_REQUEST_NUMBER HTTP 健康检查次数。HTTP_REQUEST_INTERVAL HTTP 健康检查间隔。KUBERNETES_NAMESPACE Kubernetes 的 Namespace。appName 从 pom.xml 中读取的应用名称。
8、完整脚本
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.skiptrue --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.yamlconfigFileProvider([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.yamlwriteFile 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}// 判断是否返回 200if (${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}}}}}}
}将该流水线代码配置到之前的模板 Job 的流水线脚本中方便后续项目以此项目为模板。
九、创建任务从模板任务复制配置
这里我们新创建一个测试的示例项目 Job命名为 new-test除了新建命名外其它配置直接复制上面的模板 Job然后修改配置中的默认的 Git 地址、Git 凭据、Kubernetes Namespace 等变量参数值。
1、创建新的 Job 并复制模板项目配置 2、修改新建 Job 的部分配置项
修改 Git 项目地址 修改 Git 凭据 修改 Kubernetes Namespace 一般情况下就需要修改上面这些参数其它默认即可不过特殊项目特殊处理例如健康检查端口非 8081 就需要单独改端口变量配置检查地址非 /actuator/health 就需要检查健康检查地址Docker hub 凭据非默认设置就需要配置新的凭据等等这些都需要根据项目的不同单独修改的。
十、执行 pipeline 任务进行测试
执行上面创建的 Pipeline Job点击 Build with Parameters 查看配置的参数是否有误没有错误就开始执行任务。 查看整个执行的各个节点是否哪部都能够成功构建如果出现错误需要查看控制台输出的日志查找错误点然后对脚本进行修改。 —END—
