Jenkins 与 Kubernetes 的 CI 与 CD Git + Maven + Docker+Kubectl
生活随笔
收集整理的這篇文章主要介紹了
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/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- 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
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
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 啟動時候添加這些參數:
有了上面的部署文件后，再將 Jenkins 部署到 Kuberntes 中：
- -n：指定應用啟動的 namespace
5、獲取 Jenkins 生成的 Token
在安裝 Jenkins 時候，它默認生成一段隨機字符串在控制臺日志中，用于安裝時驗證。這里需要獲取它輸出在控制臺中的日志信息，來獲取 Token 字符串。
查看 Jenkins Pod 啟動日志
- -n：指定應用啟動的 namespace
在日志中可以看到，默認給的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-alpine3、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
(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><!--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>2、新增 Dockerfile 文件
選擇?Add a new Config—>Custom file?來新增一個?Dockerfile?文件：
- ID：?global-dockerfile-file
- Name：?Dockerfile
- Comment：?全局 Dockerfile 文件
- Content：?內容如下↓：
3、新增 Kubernetes 部署文件
選擇?Add a new Config—>Custom file?來新增一個?Kubernetes 部署文件：
- ID：?global-kubernetes-deployment
- Name：?deployment.yaml
- Comment：?全局 Kubernetes 部署文件
- Content：?內容如下↓：
為了模板能夠動態替換某些值，上面模板中設置了幾個可替換的參數，用?#變量名稱?來標記，后面我們在執行 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 值
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 鏡像
- Docker In Docker 鏡像
- Kubectl 鏡像
5、腳本中引入 Jenkins 中預先存儲的文件
在之前的?系統設置->File Manager?中，存儲了很多文件，例如：
- Docker 的鏡像構建腳本文件 Dockerfile。
- Maven 的全局設置文件 Settings.xml
- Kubernetes 的部署文件 deployment.yaml
在使用 Pipleline 腳本時候，我們需要將這些文件文本提取出來，創建在執行任務的流程中，創建這些文件可以使用 Config File Provider 插件提供的 configFileProvider 方法，如下所示：
- 創建 settings.xml 文件
- 創建 Dockerfile 文件
- 創建 Dockerfile 文件
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 模塊，其中需要引用上面配置的變量，將變量填入腳本中的方法，如下：
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}"}}} }變量介紹：
- GIT_BRANCH：?Git 項目分支變量。
- GIT_PROJECT_URL：?Git 項目 URL 變量。
- GIT_CREADENTIAL：?Git 憑據 ID 變量。
3、腳本中 Maven 編譯項目階段
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 命令構建項目，并且設置 Maven 配置為剛剛創建的 Settings.xml 文件sh "mvn -T 1C clean ${MAVEN_BUILD_OPTION} -Dmaven.test.skip=true --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-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}"}}} }變量介紹：
- pom.artifactId：?從 pom.xml 文件中讀取的 artifactId 參數值。
- pom.version：?從 pom.xml 文件中讀取的 version 參數值。
5、腳本中 Docker 鏡像構建與推送模塊
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()}}}}}} }變量介紹：
- 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-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"}}}}}} }變量介紹：
- 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 数据数
- 下一篇： 整数转字符串