หน้านี้ได้รับการแปลโดย Cloud Translation API

ไปป์ไลน์หลายสาขาของ Jenkins ใน GKE

1. ภาพรวม

Jenkins เป็นโซลูชันการผสานรวมอย่างต่อเนื่องที่ได้รับความนิยมมากที่สุดอย่างหนึ่ง ซึ่งใช้เพื่อทำให้ส่วนสำคัญของกระบวนการพัฒนาซอฟต์แวร์ซึ่งไม่ใช่งานของมนุษย์เป็นแบบอัตโนมัติ การใช้ Jenkins ใน Kubenetes บน Google Cloud และปลั๊กอิน GKE ช่วยให้เราปรับขนาดผู้ดำเนินการสร้างได้อย่างรวดเร็วและอัตโนมัติเมื่อจำเป็น เมื่อใช้ร่วมกับ Cloud Storage เราสามารถสร้างและทดสอบแอปพลิเคชันได้โดยแทบไม่ต้องออกแรง

สิ่งที่ต้องทำ

ทำให้ Jenkins ใช้งานได้ในคลัสเตอร์ Kubernetes
ติดตั้งใช้งานและกำหนดค่าปลั๊กอิน GKE ของ Jenkins เพื่อให้ Jenkins สร้างและทำลายพ็อดเป็นโหนดผู้ดำเนินการได้
สร้างและทดสอบแอปพลิเคชัน SpringBoot ตัวอย่าง
สร้างและเผยแพร่คอนเทนเนอร์ไปยัง Google Container Registry
ทำให้แอปพลิเคชันตัวอย่างใช้งานได้ในสภาพแวดล้อม GKE ที่ใช้ทดสอบและเวอร์ชันที่ใช้งานจริง

สิ่งที่ต้องมี

โปรเจ็กต์ Google Cloud ที่มีการตั้งค่าการเรียกเก็บเงิน หากยังไม่มีบัญชีดังกล่าว คุณจะต้องสร้างบัญชี

2. การเริ่มตั้งค่า

โค้ดแล็บนี้สามารถทำงานบน Google Cloud Platform ได้โดยไม่ต้องติดตั้งหรือกำหนดค่าในเครื่อง

Cloud Shell

ตลอดทั้งโค้ดแล็บนี้ เราจะจัดสรรและจัดการทรัพยากรและบริการต่างๆ ในระบบคลาวด์โดยใช้บรรทัดคำสั่งผ่าน Cloud Shell

เปิดใช้ API

API ที่เราจะต้องเปิดใช้ในโปรเจ็กต์มีดังนี้

Compute Engine API - สร้างและเรียกใช้เครื่องเสมือน
Kubernetes Engine API - สร้างและจัดการแอปพลิเคชันที่ใช้คอนเทนเนอร์
Cloud Build API - แพลตฟอร์มการผสานรวมอย่างต่อเนื่องและการส่งมอบอย่างต่อเนื่องของ Google Cloud
Service Management API - ช่วยให้ผู้ให้บริการเผยแพร่บริการใน Google Cloud Platform ได้
Cloud Resource Manager API - สร้าง อ่าน และอัปเดตข้อมูลเมตาสำหรับคอนเทนเนอร์ทรัพยากร Google Cloud

เปิดใช้ API ที่จำเป็นด้วยคำสั่ง gcloud ต่อไปนี้

gcloud services enable compute.googleapis.com \
container.googleapis.com \
cloudbuild.googleapis.com \
servicemanagement.googleapis.com \
cloudresourcemanager.googleapis.com \
--project ${GOOGLE_CLOUD_PROJECT}

สร้างที่เก็บข้อมูล GCS

เราจะต้องมีที่เก็บข้อมูล GCS เพื่ออัปโหลดงานทดสอบ มาสร้างที่เก็บข้อมูลโดยใช้รหัสโปรเจ็กต์ในชื่อเพื่อให้แน่ใจว่าไม่ซ้ำกัน

gsutil mb gs://${GOOGLE_CLOUD_PROJECT}-jenkins-test-bucket/

3. การสร้างคลัสเตอร์ Kubernetes

สร้างคลัสเตอร์

ถัดไป เราจะสร้างคลัสเตอร์ GKE ที่จะโฮสต์ระบบ Jenkins รวมถึงพ็อดที่จะส่งเป็นโหนดที่ทำงาน ขอบเขตเพิ่มเติมที่ระบุโดย Flag --scopes จะช่วยให้ Jenkins เข้าถึง Cloud Source Repositories และ Container Registry ได้ ใน Cloud Console ให้เรียกใช้คำสั่งต่อไปนี้

gcloud container clusters create jenkins-cd \
--machine-type n1-standard-2 --num-nodes 1 \
--zone us-east1-d \
--scopes "https://www.googleapis.com/auth/source.read_write,cloud-platform" \
--cluster-version latest

และมาทำให้คลัสเตอร์ 2 คลัสเตอร์พร้อมใช้งานเพื่อโฮสต์บิลด์เวอร์ชัน Staging และเวอร์ชันที่ใช้งานจริงของแอปพลิเคชันตัวอย่างกัน

gcloud container clusters create staging \
--machine-type n1-standard-2 --num-nodes 1 \
--zone us-east1-d \
--cluster-version latest

gcloud container clusters create prod \
--machine-type n1-standard-2 --num-nodes 2 \
--zone us-east1-d \
--cluster-version latest

ยืนยัน

เมื่อสร้างคลัสเตอร์แล้ว เราจะยืนยันว่าคลัสเตอร์ทํางานกับ gcloud container clusters list

เอาต์พุตควรมี RUNNING ในคอลัมน์ STATUS

NAME        LOCATION    MASTER_VERSION  MASTER_IP     MACHINE_TYPE   NODE_VERSION  NUM_NODES  STATUS
jenkins-cd  us-east1-d  1.15.9-gke.9    34.74.77.124  n1-standard-2  1.15.9-gke.9  2          RUNNING
prod        us-east1-d  1.15.9-gke.9    35.229.98.12  n1-standard-2  1.15.9-gke.9  2          RUNNING
staging     us-east1-d  1.15.9-gke.9    34.73.92.228  n1-standard-2  1.15.9-gke.9  2          RUNNING

4. ติดตั้งใช้งาน Jenkins ด้วย Helm

ติดตั้ง Helm

เราจะใช้ Helm ซึ่งเป็นเครื่องมือจัดการแพ็กเกจแอปพลิเคชันสำหรับ Kubernetes เพื่อติดตั้ง Jenkins ในคลัสเตอร์ ในการเริ่มต้นใช้งาน ให้ดาวน์โหลดโปรเจ็กต์ที่มีไฟล์ Manifest ของ Kubernetes ที่เราจะใช้เพื่อทำให้ Jenkins ใช้งานได้

git clone https://github.com/GoogleCloudPlatform/continuous-deployment-on-kubernetes.git ~/continuous-deployment-on-kubernetes

เปลี่ยนไดเรกทอรีที่ใช้งานอยู่ในปัจจุบันเป็นไดเรกทอรีโปรเจ็กต์ โดยทำดังนี้

cd ~/continuous-deployment-on-kubernetes/

สร้างการเชื่อมโยงบทบาทคลัสเตอร์เพื่อมอบสิทธิ์บทบาทผู้ดูแลระบบคลัสเตอร์ให้ตนเอง โดยทำดังนี้

kubectl create clusterrolebinding cluster-admin-binding --clusterrole=cluster-admin --user=$(gcloud config get-value account)

เชื่อมต่อกับคลัสเตอร์ Jenkins โดยรับข้อมูลเข้าสู่ระบบ

gcloud container clusters get-credentials jenkins-cd --zone us-east1-d --project ${GOOGLE_CLOUD_PROJECT}

และดาวน์โหลดไบนารี Helm ลงใน Cloud Console

wget https://storage.googleapis.com/kubernetes-helm/helm-v2.14.1-linux-amd64.tar.gz

แตกไฟล์และคัดลอกไฟล์ Helm ที่ให้มาไปยังไดเรกทอรีการทำงานปัจจุบัน

tar zxfv helm-v2.14.1-linux-amd64.tar.gz && \
cp linux-amd64/helm .

Tiller เป็นฝั่งเซิร์ฟเวอร์ของ Helm ที่ทำงานในคลัสเตอร์ Kubernetes มาสร้างบัญชีบริการชื่อ tiller กัน

kubectl create serviceaccount tiller \
--namespace kube-system

และเชื่อมโยงกับบทบาทคลัสเตอร์ cluster-admin เพื่อให้ทำการเปลี่ยนแปลงได้

kubectl create clusterrolebinding tiller-admin-binding \
--clusterrole=cluster-admin \
--serviceaccount=kube-system:tiller

ตอนนี้เราเริ่มต้นใช้งาน Helm และอัปเดตที่เก็บข้อมูลได้แล้ว โดยทำดังนี้

./helm init --service-account=tiller && \
./helm repo update

ยืนยัน

ตรวจสอบว่า Helm พร้อมใช้งานด้วย ./helm version ซึ่งจะแสดงหมายเลขเวอร์ชันของไคลเอ็นต์และเซิร์ฟเวอร์

Client: &version.Version{SemVer:"v2.14.1", GitCommit:"5270352a09c7e8b6e8c9593002a73535276507c0", GitTreeState:"clean"}
Server: &version.Version{SemVer:"v2.14.1", GitCommit:"5270352a09c7e8b6e8c9593002a73535276507c0", GitTreeState:"clean"}

ติดตั้ง Jenkins

เมื่อติดตั้ง Helm ในคลัสเตอร์แล้ว เราพร้อมสำหรับการติดตั้ง Jenkins โดยทำดังนี้

./helm install stable/jenkins -n cd \
-f jenkins/values.yaml \
--version 1.2.2 --wait

ยืนยัน

มาดูสถานะพ็อดกัน

kubectl get pods

เอาต์พุตควรแสดงพ็อด Jenkins ที่มีสถานะ "ทำงาน"

NAME                          READY     STATUS    RESTARTS   AGE
cd-jenkins-7c786475dd-vbhg4   1/1       Running   0          1m

ยืนยันว่าได้สร้างบริการ Jenkins อย่างถูกต้องแล้ว โดยทำดังนี้

kubectl get svc

เอาต์พุตควรมีลักษณะดังนี้

NAME               TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)     AGE
cd-jenkins         ClusterIP   10.35.241.170   <none>        8080/TCP    2m27s
cd-jenkins-agent   ClusterIP   10.35.250.57    <none>        50000/TCP   2m27s
kubernetes         ClusterIP   10.35.240.1     <none>        443/TCP     75m

การติดตั้ง Jenkins จะใช้ปลั๊กอิน Kubernetes เพื่อสร้างตัวแทนผู้สร้าง รายการดังกล่าวจะเปิดโดยอัตโนมัติโดย Jenkins master ตามความจำเป็น เมื่อทํางานเสร็จแล้ว ระบบจะสิ้นสุดการทํางานของคอนเทนเนอร์โดยอัตโนมัติและเพิ่มทรัพยากรของคอนเทนเนอร์กลับไปยังพูลทรัพยากรของคลัสเตอร์

เชื่อมต่อกับ Jenkins

Jenkins ทำงานอยู่ในคลัสเตอร์ของเรา แต่หากต้องการเข้าถึง UI ให้ตั้งค่าการส่งต่อพอร์ตจาก Cloud Shell โดยทำดังนี้

export POD_NAME=$(kubectl get pods --namespace default -l "app.kubernetes.io/component=jenkins-master" -l "app.kubernetes.io/instance=cd" -o jsonpath="{.items[0].metadata.name}") &&
kubectl port-forward $POD_NAME 8080:8080 >> /dev/null &

ระบบจะสร้างรหัสผ่านผู้ดูแลระบบระหว่างการติดตั้ง มาเรียกข้อมูลกัน

printf $(kubectl get secret cd-jenkins -o jsonpath="{.data.jenkins-admin-password}" | base64 --decode);echo

ที่ด้านบนของ Cloud Shell ให้คลิกไอคอนแสดงตัวอย่างเว็บ แล้วเลือก "แสดงตัวอย่างบนพอร์ต 8080"

เราควรเห็นหน้าจอเข้าสู่ระบบของ Jenkins ซึ่งเราสามารถป้อน admin สำหรับชื่อผู้ใช้และรหัสผ่านที่แสดงในขั้นตอนก่อนหน้า

เมื่อคลิกลงชื่อเข้าใช้ ระบบควรนําเราไปยังหน้าหลักของ Jenkins

5. ติดตั้งและกำหนดค่าปลั๊กอิน GKE

ปลั๊กอิน Google Kubernetes Engine ช่วยให้เราเผยแพร่การทำให้ใช้งานได้ซึ่งสร้างขึ้นภายใน Jenkins ไปยังคลัสเตอร์ Kubernetes ที่ทำงานภายใน GKE ได้ คุณต้องทำการกําหนดค่าบางอย่างด้วยสิทธิ์ IAM ในโปรเจ็กต์ เราจะทำให้การกำหนดค่านั้นใช้งานได้โดยใช้ Terraform

ก่อนอื่น ให้ดาวน์โหลดโปรเจ็กต์ปลั๊กอิน GKE โดยทำดังนี้

git clone https://github.com/jenkinsci/google-kubernetes-engine-plugin.git ~/google-kubernetes-engine-plugin

การกำหนดค่าสิทธิ์ IAM อัตโนมัติ

เปลี่ยนไดเรกทอรีทํางานปัจจุบันเป็นไดเรกทอรี rbac ของโปรเจ็กต์ GKE ที่เราโคลนไว้ก่อนหน้านี้

cd ~/google-kubernetes-engine-plugin/docs/rbac/

gcp-sa-setup.tf คือไฟล์การกําหนดค่า Terraform ที่จะสร้างบทบาท GCP IAM ที่กําหนดเองซึ่งมีสิทธิ์ที่จํากัด พร้อมกับบัญชีบริการ GCP เพื่อมอบบทบาทนั้น ไฟล์ต้องมีค่าสำหรับตัวแปรชื่อโปรเจ็กต์ ภูมิภาค และบัญชีบริการ เราระบุค่าเหล่านั้นโดยการประกาศตัวแปรสภาพแวดล้อมต่อไปนี้ก่อน

export TF_VAR_project=${GOOGLE_CLOUD_PROJECT}
export TF_VAR_region=us-east1-d
export TF_VAR_sa_name=kaniko-role

เริ่มต้น Terraform, สร้างแผน และใช้แผน

terraform init
terraform plan -out /tmp/tf.plan
terraform apply /tmp/tf.plan && rm /tmp/tf.plan

บัญชีบริการจะต้องมีสิทธิ์ของผู้ดูแลระบบพื้นที่เก็บข้อมูลจึงจะบันทึกลงในที่เก็บข้อมูล Cloud Storage ได้

gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} \
--member serviceAccount:kaniko-role@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com \
--role 'roles/storage.admin'

นอกจากนี้ ผู้ใช้ดังกล่าวจะต้องมีสิทธิ์เข้าถึงคอนเทนเนอร์สำหรับระยะการทําให้ใช้งานได้ของไปป์ไลน์ด้วย

gcloud projects add-iam-policy-binding ${GOOGLE_CLOUD_PROJECT} --member \
serviceAccount:kaniko-role@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com --role 'roles/container.developer'

ตอนนี้เราใช้ Helm เพื่อตั้งค่าสิทธิ์ของคลัสเตอร์สำหรับปลั๊กอิน GKE โดยใช้ตัวติดตั้งใช้งานของ gke robot ได้แล้ว เปลี่ยนไดเรกทอรีที่ใช้งานอยู่เป็นไดเรกทอรี Helm ของโปรเจ็กต์ GKE โดยทำดังนี้

cd ~/google-kubernetes-engine-plugin/docs/helm/

และติดตั้งโดยใช้ชาร์ต Helm ที่ให้มา

export TARGET_NAMESPACE=kube-system && \
envsubst < gke-robot-deployer/values.yaml | helm install ./gke-robot-deployer --name gke-robot-deployer -f -

6. กำหนดค่า Jenkins

คีย์บัญชีบริการ

เราจะต้องสร้างไฟล์คีย์ส่วนตัวและเพิ่มเป็นข้อมูลลับ Kubernetes เพื่อให้บัญชีบริการทํางานได้อย่างถูกต้อง ก่อนอื่น ให้สร้างไฟล์ด้วยคำสั่ง gcloud ต่อไปนี้

gcloud iam service-accounts keys create /tmp/kaniko-secret.json --iam-account kaniko-role@${GOOGLE_CLOUD_PROJECT}.iam.gserviceaccount.com

เราจะสร้างคีย์ลับในที่เก็บข้อมูลลับของ Kubernetes ด้วยไฟล์ดังกล่าว

kubectl create secret generic jenkins-int-samples-kaniko-secret --from-file=/tmp/kaniko-secret.json

ดาวน์โหลดไฟล์ JSON ลงในดิสก์ในเครื่องโดยไปที่รายการ "ดาวน์โหลดไฟล์" จากเมนู 3 จุดของ Cloud Shell

ป้อนเส้นทางไฟล์ /tmp/kaniko-secret.json แล้วคลิกดาวน์โหลด

กลับไปที่หน้า Jenkins ในแผงด้านซ้าย ให้คลิกข้อมูลเข้าสู่ระบบ แล้วคลิกระบบ

ในส่วนระบบ ให้คลิกข้อมูลเข้าสู่ระบบส่วนกลาง แล้วคลิกเพิ่มข้อมูลเข้าสู่ระบบทางด้านซ้าย

ในเมนูแบบเลื่อนลง "ประเภท" ให้เลือกบัญชีบริการ Google จากคีย์ส่วนตัว ป้อน "kaniko-role" เป็นชื่อ จากนั้นอัปโหลดคีย์ JSON ที่สร้างขึ้นในขั้นตอนก่อนหน้า แล้วคลิก "ตกลง"

ตัวแปรสภาพแวดล้อม

เรามีตัวแปรสภาพแวดล้อมบางอย่างที่ต้องกำหนด Jenkins ก่อนสร้างไปป์ไลน์แบบหลายสาขา ดังนี้

JENK_INT_IT_ZONE - โซนของคลัสเตอร์ Kubernetes ในกรณีของเรา us-east1-d
JENK_INT_IT_PROJECT_ID - หมายถึงรหัสโปรเจ็กต์ GCP ที่โฮสต์อินสแตนซ์ Jenkins นี้
JENK_INT_IT_STAGING - ชื่อคลัสเตอร์ "ระยะเตรียมความพร้อม" ของเรา staging สำหรับวัตถุประสงค์ในการสาธิต
JENK_INT_IT_PROD - ชื่อคลัสเตอร์ "prod" ของเรา รหัสนี้จะใช้เป็นprodสำหรับการสาธิต
JENK_INT_IT_BUCKET - ที่เก็บข้อมูล Google Cloud Storage ที่สร้างขึ้นในขั้นตอนก่อนหน้า
JENK_INT_IT_CRED_ID - หมายถึงข้อมูลเข้าสู่ระบบที่สร้างโดยใช้ JSON ในขั้นตอนก่อนหน้า ค่าควรตรงกับชื่อที่เราตั้งให้ kaniko-role

หากต้องการเพิ่มรายการเหล่านี้ ให้ไปที่จัดการ Jenkins

จากนั้นกําหนดค่าระบบ:

จะมีส่วนชื่อพร็อพเพอร์ตี้ส่วนกลาง และเมื่อเลือกช่องตัวแปรสภาพแวดล้อม เราจะเห็นปุ่มเพิ่มซึ่งคลิกเพื่อเพิ่มตัวแปรด้านบนเป็นคู่คีย์-ค่า

คลิกปุ่มบันทึกที่ด้านล่างของหน้าเพื่อใช้การเปลี่ยนแปลง

7. ตั้งค่าไปป์ไลน์

ใน Jenkins ให้คลิก "รายการใหม่"

ป้อน "jenkins-integration-sample" เป็นชื่อ แล้วเลือก "Multibranch Pipeline" เป็นประเภทโปรเจ็กต์ แล้วคลิก "ตกลง"

ระบบจะเปลี่ยนเส้นทางคุณไปยังหน้าการกําหนดค่าไปป์ไลน์ ในส่วนแหล่งที่มาของสาขา ให้ป้อน https://github.com/GoogleCloudPlatform/jenkins-integration-samples.git เป็นที่เก็บโปรเจ็กต์ ในส่วนการกำหนดค่าบิลด์ ให้ป้อน "gke/Jenkinsfile" เป็นเส้นทางสคริปต์

คลิกบันทึกเพื่อใช้การตั้งค่าเหล่านี้ เมื่อบันทึกแล้ว Jenkins จะเริ่มต้นการสแกนพื้นที่เก็บข้อมูลและบิลด์ที่ตามมาสำหรับแต่ละสาขา ในระหว่างที่ดำเนินการ คุณจะเห็นว่ามีการสร้าง เรียกใช้ และทำลายพ็อดขณะที่บิลด์ดำเนินการในหน้าภาระงาน Kubernetes

เมื่อการบิลด์เสร็จสิ้นแล้ว คุณจะเห็น 2 รายการในหน้าเวิร์กโหลด Kubernetes ชื่อ jenkins-integration-samples-gke ซึ่งแต่ละรายการจะสอดคล้องกับคลัสเตอร์เวอร์ชันที่ใช้งานจริงหรือคลัสเตอร์ทดสอบ สถานะจะแสดงเป็น "OK"

เมื่อใช้คําสั่ง gcloud ต่อไปนี้ เราจะเห็นว่าได้อัปโหลดอิมเมจคอนเทนเนอร์ไปยัง Google Container Registry ที่สอดคล้องกับไปป์ไลน์แล้ว

gcloud container images list

หากต้องการดูภาระงานในเบราว์เซอร์ ให้รับข้อมูลเข้าสู่ระบบสำหรับคลัสเตอร์ prod โดยทำดังนี้

gcloud container clusters get-credentials prod --zone us-east1-d --project ${GOOGLE_CLOUD_PROJECT}

และเรียกใช้คำสั่งต่อไปนี้เพื่อตั้งค่าการส่งต่อพอร์ตจากพอร์ต 8081 ของเชลล์ไปยังพอร์ต 8080 ของเวิร์กโหลด

export POD_NAME=$(kubectl get pods -o jsonpath="{.items[0].metadata.name}") &&
kubectl port-forward $POD_NAME 8081:8080 >> /dev/null &

ที่ด้านบนของ Cloud Shell ให้คลิกไอคอนแสดงตัวอย่างเว็บ แล้วเลือก "แสดงตัวอย่างบนพอร์ต 8081"

8. ล้างข้อมูล

เราได้สำรวจวิธีทำให้ Jenkins และไปป์ไลน์แบบหลายสาขาตัวอย่างใช้งานได้ใน Kubernetes ตอนนี้ถึงเวลาล้างข้อมูลโปรเจ็กต์จากทรัพยากรที่เราสร้างขึ้นแล้ว

ลบโปรเจ็กต์

คุณลบทั้งโปรเจ็กต์ได้หากต้องการ ในคอนโซล GCP ให้ไปที่หน้าเครื่องมือจัดการทรัพยากรในระบบคลาวด์

ในรายการโปรเจ็กต์ ให้เลือกโปรเจ็กต์ที่เรากำลังทำงานอยู่ แล้วคลิกลบ ระบบจะแจ้งให้คุณพิมพ์รหัสโปรเจ็กต์ ป้อนรหัสแล้วคลิกปิดเครื่อง

หรือจะลบทั้งโปรเจ็กต์จาก Cloud Shell โดยตรงด้วย gcloud ก็ได้ โดยทำดังนี้

gcloud projects delete $GOOGLE_CLOUD_PROJECT

หากต้องการลบคอมโพเนนต์ต่างๆ ที่เรียกเก็บเงินได้ทีละรายการ ให้ไปที่ส่วนถัดไป

คลัสเตอร์ Kubernetes

ลบคลัสเตอร์ Kubernetes ทั้งหมดด้วย gcloud

gcloud container clusters delete jenkins-cd --zone=us-east1-d

ที่เก็บข้อมูล

นำไฟล์ที่อัปโหลดทั้งหมดออกและลบที่เก็บข้อมูลด้วย gsutil โดยทำดังนี้

gsutil rm -r gs://${GOOGLE_CLOUD_PROJECT}-jenkins-test-bucket

อิมเมจใน Google Container Registry

เราจะลบอิมเมจ Google Container Registry โดยใช้ข้อมูลสรุปอิมเมจ ก่อนอื่น ให้เรียกข้อมูลสรุปด้วยคำสั่งต่อไปนี้

gcloud container images list-tags gcr.io/${GOOGLE_CLOUD_PROJECT}/jenkins-integration-samples-gke --format="value(digest)"

จากนั้นสําหรับข้อมูลสรุปที่แสดงผลแต่ละรายการ ให้ทำดังนี้

gcloud container images delete gcr.io/${GOOGLE_CLOUD_PROJECT}/jenkins-integration-samples-gke@sha256:<DIGEST>

9. ยินดีด้วย

แจ่มแจ๋ว! สำเร็จแล้ว คุณได้เรียนรู้วิธีทำให้ Jenkins ใช้งานได้ใน GKE และส่งงานไปยังคลัสเตอร์ Kubernetes แล้ว

สิ่งที่เราได้พูดถึง

เราได้ติดตั้งใช้งานคลัสเตอร์ Kubernetes และใช้ Helm เพื่อติดตั้ง Jenkins
เราได้ติดตั้งและกำหนดค่าปลั๊กอิน GKE เพื่อให้ Jenkins ติดตั้งใช้งานอาร์ติแฟกต์การสร้างในคลัสเตอร์ Kubernetes ได้
เราได้กําหนดค่า Jenkins ให้สร้างไปป์ไลน์แบบหลายสาขาซึ่งส่งงานไปยังคลัสเตอร์ GKE