當前位置：首頁 > 编程资源 > 编程问答 >内容正文

编程问答

Jenkins 与 Kubernetes 的 CI 与 CD Git + Maven + Docker+Kubectl

發布時間：2025/3/11 编程问答 38 豆豆

生活随笔收集整理的這篇文章主要介紹了 Jenkins 与 Kubernetes 的 CI 与 CD Git + Maven + Docker+Kubectl 小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

目錄[-]

. 一、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.199
Kubernetes 版本：1.15.3

參考地址：

Jenkins 官方網址
Jenkins Github 網址
Jenkins Kubernetes 插件 Github 網址
示例的配置與部署文件的 Github 地址：https://github.com/my-dlq/blog-example/tree/master/jenkins/jenkins-ci&cd

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/jenkins

2、創建 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- nfsvers=4.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 public

3、創建 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 public

4、創建 Service & Deployment

在 Kubernetes 中部署服務需要部署文件，這里部署 Jenkins 需要創建 Service 與 Deployment 對象，其中兩個對象需要做一些配置，如下：

Service：Service 暴露兩個接口?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: "2000m"requests:memory: 2Gicpu: "2000m"env:- name: LIMITS_MEMORYvalueFrom:resourceFieldRef:resource: limits.memorydivisor: 1Mi- name: "JAVA_OPTS" #設置變量，指定時區和 jenkins slave 執行者設置value: " -Xmx$(LIMITS_MEMORY)m -XshowSettings:vm -Dhudson.slaves.NodeProvisioner.initialDelay=0-Dhudson.slaves.NodeProvisioner.MARGIN=50-Dhudson.slaves.NodeProvisioner.MARGIN0=0.85-Duser.timezone=Asia/Shanghai" - name: "JENKINS_OPTS"value: "--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.initialDelay=0 -Dhudson.slaves.NodeProvisioner.MARGIN=50 -Dhudson.slaves.NodeProvisioner.MARGIN0=0.85

有了上面的部署文件后，再將 Jenkins 部署到 Kuberntes 中：

-n：指定應用啟動的 namespace

$ kubectl create -f jenkins-deployment.yaml -n mydlqcloud

5、獲取 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 密碼）：略
ID：global-git-credential
描述：全局 Git 憑據

2、添加 Kubernetes Token 憑據

配置的參數值：

類型：Secret text
范圍：全局
Secret（K8S Token 串）：略
ID：global-kubernetes-credential
描述：全局的 K8S Token

3、添加 Docker 倉庫認證憑據

配置的參數值：

類型：Username with password
范圍：全局
用戶名（Docker 倉庫用戶名）：略
密碼（Docker 倉庫密碼）：略
ID：docker-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 鏡像，并指定 RunAsUser=0 來使容器以 Root 身份執行任務，并設置 privileged=true 來讓 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-alpine

3、Kubernetes 插件 Container 配置

將配置 Jenkins Slave 在 Kubernetes 中的 Pod 中所包含容器信息，這里鏡像都可以從官方 Docker Hub 下載，由于網速原因，本人已經將其下載到 Aliyun 鏡像倉庫。

(1)、配置 Maven 鏡像

名稱：maven
Docker 鏡像：registry.cn-shanghai.aliyuncs.com/mydlq/maven:3.6.0-jdk8-alpine
其它參數：默認值即可

Maven 鏡像可以從官方 Docker Hub 下載，地址：https://hub.docker.com/_/maven

(2)、配置 Docker In Docker 鏡像

名稱：docker
Docker 鏡像：registry.cn-shanghai.aliyuncs.com/mydlq/docker:18.06.3-dind
其它參數：默認值即可

Docker-IN-Docker 鏡像可以從官方 Docker Hub 下載，地址：https://hub.docker.com/_/docker

(3)、配置 Kubectl 鏡像

名稱：kubectl
Docker 鏡像：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- nfsvers=4.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-settings
Name：?MavenGlobalSettings
Comment：?全局 Maven Settings.xml 文件
Content：?內容如下↓：

為了加快 jar 包的下載速度，這里將倉庫地址指向 aliyun Maven 倉庫地址。

<?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><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>

2、新增 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" ]

3、新增 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_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_uuid"value: "#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.git"branch: "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.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" }

創建 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.com"if ("${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://xxxxxxxxxxxx"

Git 分支變量

變量名稱：GIT_BRANCH
類型：Git Parameter
描述：選擇 Git 分支
默認值：master

Git 憑據變量

變量名稱：GIT_CREADENTIAL
類型：Credentials
描述：Git 憑據
默認值：global-git-credential

4、配置 Maven 變量

Maven 構建命令變量

變量名稱：MAVEN_BUILD_OPTION
類型：Choices
描述：要執行的執行 Maven 命令選擇
可選值：[‘package’, ‘install’, ‘deploy’]
默認值：install

5、配置 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”

6、配置 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”

7、配置 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 腳本

接下將使用 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-agent"podTemplate(label: label,cloud: 'kubernetes' ){node (label) {print "在 Slave Pod 中執行任務" }} }

2、腳本中 Git 拉取項目階段

接下來接著往整體的腳本中添加 Git 模塊，其中需要引用上面配置的變量，將變量填入腳本中的方法，如下：

變量介紹：

GIT_BRANCH：?Git 項目分支變量。
GIT_PROJECT_URL：?Git 項目 URL 變量。
GIT_CREADENTIAL：?Git 憑據 ID 變量。

3、腳本中 Maven 編譯項目階段

變量介紹：

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?兩個全局參數。

變量介紹：

pom.artifactId：?從 pom.xml 文件中讀取的 artifactId 參數值。
pom.version：?從 pom.xml 文件中讀取的 version 參數值。

5、腳本中 Docker 鏡像構建與推送模塊

變量介紹：

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 模塊

變量介紹：

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-agent"podTemplate(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.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}"// 判斷 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.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}"// 判斷是否返回 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.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.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.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}"// 判斷是否返回 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—

總結

以上是生活随笔為你收集整理的Jenkins 与 Kubernetes 的 CI 与 CD Git + Maven + Docker+Kubectl的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇： android listview 数据数
下一篇：整数转字符串