GKE पर Jenkins की मल्टी-ब्रांच पाइपलाइन

1. खास जानकारी

Jenkins, लगातार इंटिग्रेशन के सबसे लोकप्रिय समाधानों में से एक है. इसका इस्तेमाल, सॉफ़्टवेयर डेवलपमेंट की प्रोसेस के उन ज़रूरी हिस्सों को ऑटोमेट करने के लिए किया जाता है जिनमें मानवीय संसाधनों की ज़रूरत नहीं होती. Google Cloud पर Kubenetes में Jenkins को डिप्लॉय करके और GKE प्लग इन का इस्तेमाल करके, हम ज़रूरत पड़ने पर, बिल्ड एक्सीक्यूटर को तेज़ी से और अपने-आप स्केल कर सकते हैं. Cloud Storage के साथ मिलकर, हम कम से कम मेहनत के साथ ऐप्लिकेशन बना सकते हैं और उसकी जांच कर सकते हैं.

आपको क्या करना होगा

  • Kubernetes क्लस्टर में Jenkins डिप्लॉय करना
  • Jenkins GKE प्लग इन को डिप्लॉय और कॉन्फ़िगर करना, ताकि Jenkins, एक्सेक्यूटर नोड के तौर पर पॉड बना सके और उन्हें नष्ट कर सके
  • SpringBoot ऐप्लिकेशन का सैंपल बनाना और उसका टेस्ट करना
  • Google Container Registry में कंटेनर बनाना और पब्लिश करना
  • सैंपल ऐप्लिकेशन को स्टेजिंग और प्रोडक्शन GKE एनवायरमेंट में डिप्लॉय करना

आपको इन चीज़ों की ज़रूरत होगी

  • बिलिंग सेट अप किया गया Google Cloud प्रोजेक्ट. अगर आपके पास Google खाता नहीं है, तो आपको खाता बनाना होगा.

2. सेट अप करना

यह कोडलैब, Google Cloud Platform पर पूरी तरह से काम कर सकता है. इसके लिए, किसी स्थानीय इंस्टॉलेशन या कॉन्फ़िगरेशन की ज़रूरत नहीं है.

Cloud Shell

इस कोडलैब में, हम Cloud Shell की कमांड लाइन का इस्तेमाल करके, अलग-अलग क्लाउड संसाधनों और सेवाओं को उपलब्ध कराएंगे और उन्हें मैनेज करेंगे.

एपीआई चालू करना

यहां वे एपीआई दिए गए हैं जिन्हें हमें अपने प्रोजेक्ट में चालू करना होगा:

  • Compute Engine API - वर्चुअल मशीनें बनाता और चलाता है
  • Kubernetes Engine API - कंटेनर पर आधारित ऐप्लिकेशन बनाता और मैनेज करता है
  • Cloud Build API - Google Cloud का लगातार इंटिग्रेशन और डिलीवरी प्लैटफ़ॉर्म
  • Service Management API - इसकी मदद से, सेवा देने वाली कंपनियां Google Cloud Platform पर सेवाएं पब्लिश कर सकती हैं
  • Cloud Resource Manager API - Google Cloud के रिसॉर्स कंटेनर के लिए मेटाडेटा बनाता है, उसे पढ़ता है, और अपडेट करता है

ज़रूरी एपीआई चालू करने के लिए, gcloud कमांड का इस्तेमाल करें:

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

जीसीएस बकेट बनाना

टेस्ट के लिए अपलोड किए जाने वाले डेटा के लिए, हमें GCS बकेट की ज़रूरत होगी. आइए, नाम में अपने प्रोजेक्ट आईडी का इस्तेमाल करके एक बकेट बनाएं, ताकि यह पक्का किया जा सके कि वह यूनीक है:

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

3. Kubernetes क्लस्टर बनाना

क्लस्टर बनाना

इसके बाद, हम एक GKE क्लस्टर बनाएंगे, जो हमारे Jenkins सिस्टम को होस्ट करेगा. इसमें वे पॉड भी शामिल होंगे जिन्हें वर्कर्स नोड के तौर पर डिस्पैच किया जाएगा. --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

अपने सैंपल ऐप्लिकेशन के स्टैजिंग और प्रोडक्शन बिल्ड को होस्ट करने के लिए, दो क्लस्टर भी डिप्लॉय करते हैं:

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

28b45298e1e82748.png पुष्टि करें

क्लस्टर बन जाने के बाद, हम यह पुष्टि कर सकते हैं कि वे gcloud container clusters list

आउटपुट में STATUS कॉलम में RUNNING होना चाहिए:

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. Helm की मदद से Jenkins को डिप्लॉय करना

Helm इंस्टॉल करना

हम अपने क्लस्टर पर Jenkins इंस्टॉल करने के लिए, Kubernetes के लिए ऐप्लिकेशन पैकेज मैनेजर Helm का इस्तेमाल करेंगे. शुरू करने के लिए, वह प्रोजेक्ट डाउनलोड करें जिसमें 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}

इसके बाद, अपने Cloud Console में Helm बाइनरी डाउनलोड करें:

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

28b45298e1e82748.png पुष्टि करना

पुष्टि करें कि 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

28b45298e1e82748.png पुष्टि करें

आइए, पॉड की जांच करते हैं:

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 मास्टर उन्हें अपने-आप लॉन्च कर देगा. काम पूरा होने के बाद, ये प्रोसेस अपने-आप बंद हो जाती हैं और उनके संसाधन, क्लस्टर के संसाधन पूल में वापस जुड़ जाते हैं.

Jenkins से कनेक्ट करना

Jenkins हमारे क्लस्टर पर चल रहा है, लेकिन यूज़र इंटरफ़ेस (यूआई) को ऐक्सेस करने के लिए, 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 में सबसे ऊपर, वेब की झलक दिखाने वाले आइकॉन 7ddf5a65fd556dd6.pngपर क्लिक करें. इसके बाद, ‘पोर्ट 8080 पर झलक देखें' चुनें

1d614c831a621cff.png

हमें Jenkins की लॉगिन स्क्रीन दिखेगी. यहां उपयोगकर्ता नाम के लिए admin और पिछले चरण में मिला पासवर्ड डाला जा सकता है:

9cba23e856cbc84f.png

साइन इन करें पर क्लिक करने पर, हमें Jenkins के मुख्य पेज पर ले जाया जाना चाहिए.

9261f3e914829137.png

5. GKE प्लगिन को इंस्टॉल और कॉन्फ़िगर करना

Google Kubernetes Engine प्लग इन की मदद से, Jenkins में बनाए गए डिप्लॉयमेंट को GKE में चल रहे हमारे Kubernetes क्लस्टर में पब्लिश किया जा सकता है. आपके प्रोजेक्ट पर आईएएम अनुमतियों के साथ कुछ कॉन्फ़िगरेशन करना ज़रूरी है. हम Terraform का इस्तेमाल करके उस कॉन्फ़िगरेशन को डिप्लॉय करेंगे.

सबसे पहले, GKE प्लगिन प्रोजेक्ट डाउनलोड करें:

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

IAM की अनुमतियों का अपने-आप कॉन्फ़िगर होना

अपनी मौजूदा वर्किंग डायरेक्ट्री को, उस 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'

अब हम gke रोबोट डिप्लॉयर का इस्तेमाल करके, GKE प्लग इन के लिए क्लस्टर की अनुमतियां सेट अप करने के लिए, 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 

Cloud Shell के तीन बिंदु वाले मेन्यू से, 'फ़ाइल डाउनलोड करें' आइटम को ऐक्सेस करके, json फ़ाइल को अपनी लोकल डिस्क पर डाउनलोड करें:

c40378e72013b843.png

फ़ाइल का पाथ /tmp/kaniko-secret.json डालें और डाउनलोड करें पर क्लिक करें.

Jenkins पेज पर वापस जाकर, बाईं ओर मौजूद पैनल में, क्रेडेंशियल पर क्लिक करें. इसके बाद,सिस्टम पर क्लिक करें.

6c140f7e6bb82f8.png

3b874912cdc8019b.png

सिस्टम पेज के सेक्शन में, ग्लोबल क्रेडेंशियल पर क्लिक करें. इसके बाद, बाईं ओर मौजूद क्रेडेंशियल जोड़ें पर क्लिक करें:

4350c0e68561119b.png

3d3526551cdae8b.png

टाइप ड्रॉपडाउन में, निजी पासकोड से Google सेवा खाता चुनें. नाम के तौर पर ‘kaniko-role' डालें. इसके बाद, पिछले चरणों में बनाई गई JSON कुंजी अपलोड करें और 'ठीक है' पर क्लिक करें.

b0502213408e730e.png

एनवायरमेंट वैरिएबल

मल्टी-ब्रैंच पाइपलाइन बनाने से पहले, हमें कुछ एनवायरमेंट वैरिएबल तय करने होंगे. कैंपेन के तीनों सब-टाइप के नाम ये रहे:

  • JENK_INT_IT_ZONE - Kubernetes क्लस्टर का ज़ोन. हमारे मामले में us-east1-d
  • JENK_INT_IT_PROJECT_ID - इससे, Jenkins के इस इंस्टेंस को होस्ट करने वाले GCP प्रोजेक्ट आईडी का पता चलता है
  • 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 से मेल खानी चाहिए

इन्हें जोड़ने के लिए, Manage Jenkins पर जाएं:

d54f279190a07878.png

इसके बाद, सिस्टम कॉन्फ़िगर करें:

ce79d218b2799640.png

यहां ग्लोबल प्रॉपर्टी नाम का एक सेक्शन होगा. एनवायरमेंट वैरिएबल के बॉक्स को चुनने पर, हमें जोड़ें बटन दिखेगा. इस बटन पर क्लिक करके, ऊपर दिए गए वैरिएबल को कीवर्ड वैल्यू पेयर के तौर पर जोड़ा जा सकता है:

81aa222a2b17b2cc.png

बदलाव लागू करने के लिए, पेज पर सबसे नीचे मौजूद सेव करें बटन पर क्लिक करें.

7. पाइपलाइन सेट अप करना

Jenkins में, ‘नया आइटम' पर क्लिक करें:

8d1270ce4d7b6a8a.png

नाम के लिए ‘jenkins-integration-sample' डालें और प्रोजेक्ट टाइप के तौर पर ‘मल्टीब्रैंच पाइपलाइन' चुनें. इसके बाद, 'ठीक है' पर क्लिक करें:

eb071ecfbb4d775b.png

इसके बाद, आपको पाइपलाइन कॉन्फ़िगरेशन पेज पर रीडायरेक्ट कर दिया जाएगा. शाखा के सोर्स में जाकर, प्रोजेक्ट डेटा स्टोर करने की जगह के तौर पर https://github.com/GoogleCloudPlatform/jenkins-integration-samples.git डालें. बिल्ड कॉन्फ़िगरेशन में, स्क्रिप्ट पाथ के तौर पर ‘gke/Jenkinsfile' डालें.

5135bd6b0374508c.png

इन सेटिंग को लागू करने के लिए, सेव करें पर क्लिक करें. सेव करने के बाद, Jenkins, हर शाखा के लिए रिपॉज़िटरी को स्कैन करेगा और उसके बाद बिल्ड करेगा. इस प्रोसेस के दौरान, आपको Kubernetes के वर्कलोड पेज पर, पॉड बनते, चलते, और बंद होते दिखेंगे.

बिल्ड पूरा होने के बाद, आपको Kubernetes के वर्कलोड पेज पर, jenkins-integration-samples-gke नाम के दो आइटम दिखेंगे. इनमें से हर आइटम, प्रोडक्शन या टेस्टिंग क्लस्टर से जुड़ा होगा. स्टेटस 'ठीक है' के तौर पर दिखेगा:

bdec6b1753d1ba07.png

यहां दिए गए gcloud कमांड का इस्तेमाल करके, हम देखेंगे कि हमने अपनी पाइपलाइन से जुड़ी Google Container Registry में एक कंटेनर इमेज अपलोड की है:

gcloud container images list

अपने ब्राउज़र में वर्कलोड देखने के लिए, प्रोडक्शन क्लस्टर के क्रेडेंशियल पाएं:

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 पर झलक देखें' चुनें

1b19b5b56f1bae7.png

e80e995e71763bb2.png

8. साफ़-सफ़ाई सेवा

हमने Kubernetes पर Jenkins और मल्टी-ब्रैंच वाली सैंपल पाइपलाइन को डिप्लॉय करने का तरीका बताया है. अब अपने प्रोजेक्ट से, बनाए गए सभी संसाधनों को हटाने का समय आ गया है.

प्रोजेक्ट मिटाना

अगर आप चाहें, तो पूरा प्रोजेक्ट मिटाया जा सकता है. GCP Console में, Cloud Resource Manager पेज पर जाएं:

प्रोजेक्ट की सूची में, वह प्रोजेक्ट चुनें जिस पर हम काम कर रहे हैं. इसके बाद, मिटाएं पर क्लिक करें. आपको प्रोजेक्ट आईडी टाइप करने के लिए कहा जाएगा. इसे डालें और बंद करें पर क्लिक करें.

इसके अलावा, gcloud की मदद से सीधे Cloud Shell से भी पूरे प्रोजेक्ट को मिटाया जा सकता है:

gcloud projects delete $GOOGLE_CLOUD_PROJECT

अगर आपको बिलिंग के लिए उपलब्ध अलग-अलग कॉम्पोनेंट को एक-एक करके मिटाना है, तो अगले सेक्शन पर जाएं.

Kubernetes क्लस्टर

gcloud की मदद से, पूरा Kubernetes क्लस्टर मिटाएं:

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. बधाई हो!

वाह! आपने कर दिखाया. आपने GKE पर Jenkins को डिप्लॉय करने और Kubernetes क्लस्टर में जॉब डिस्पैच करने का तरीका जाना है.

हमने क्या-क्या कवर किया है

  • हमने Kubernetes क्लस्टर को डिप्लॉय किया और Jenkins को इंस्टॉल करने के लिए Helm का इस्तेमाल किया
  • हमने GKE प्लग इन इंस्टॉल और कॉन्फ़िगर किया है, ताकि Jenkins, Kubernetes क्लस्टर में बिल्ड आर्टफ़ैक्ट डिप्लॉय कर सके
  • हमने Jenkins को कॉन्फ़िगर किया, ताकि एक से ज़्यादा शाखाओं वाली पाइपलाइन सेट अप की जा सके. यह पाइपलाइन, GKE क्लस्टर पर काम भेजती है