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
पुष्टि करें
क्लस्टर बन जाने के बाद, हम यह पुष्टि कर सकते हैं कि वे 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
पुष्टि करना
पुष्टि करें कि 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 मास्टर उन्हें अपने-आप लॉन्च कर देगा. काम पूरा होने के बाद, ये प्रोसेस अपने-आप बंद हो जाती हैं और उनके संसाधन, क्लस्टर के संसाधन पूल में वापस जुड़ जाते हैं.
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 में सबसे ऊपर, वेब की झलक दिखाने वाले आइकॉन 
पर क्लिक करें. इसके बाद, ‘पोर्ट 8080 पर झलक देखें' चुनें
हमें Jenkins की लॉगिन स्क्रीन दिखेगी. यहां उपयोगकर्ता नाम के लिए admin और पिछले चरण में मिला पासवर्ड डाला जा सकता है:
साइन इन करें पर क्लिक करने पर, हमें Jenkins के मुख्य पेज पर ले जाया जाना चाहिए.
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 फ़ाइल को अपनी लोकल डिस्क पर डाउनलोड करें:
फ़ाइल का पाथ /tmp/kaniko-secret.json डालें और डाउनलोड करें पर क्लिक करें.
Jenkins पेज पर वापस जाकर, बाईं ओर मौजूद पैनल में, क्रेडेंशियल पर क्लिक करें. इसके बाद,सिस्टम पर क्लिक करें.
सिस्टम पेज के सेक्शन में, ग्लोबल क्रेडेंशियल पर क्लिक करें. इसके बाद, बाईं ओर मौजूद क्रेडेंशियल जोड़ें पर क्लिक करें:
टाइप ड्रॉपडाउन में, निजी पासकोड से Google सेवा खाता चुनें. नाम के तौर पर ‘kaniko-role' डालें. इसके बाद, पिछले चरणों में बनाई गई JSON कुंजी अपलोड करें और 'ठीक है' पर क्लिक करें.
एनवायरमेंट वैरिएबल
मल्टी-ब्रैंच पाइपलाइन बनाने से पहले, हमें कुछ एनवायरमेंट वैरिएबल तय करने होंगे. कैंपेन के तीनों सब-टाइप के नाम ये रहे:
- 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 पर जाएं:
इसके बाद, सिस्टम कॉन्फ़िगर करें:
यहां ग्लोबल प्रॉपर्टी नाम का एक सेक्शन होगा. एनवायरमेंट वैरिएबल के बॉक्स को चुनने पर, हमें जोड़ें बटन दिखेगा. इस बटन पर क्लिक करके, ऊपर दिए गए वैरिएबल को कीवर्ड वैल्यू पेयर के तौर पर जोड़ा जा सकता है:
बदलाव लागू करने के लिए, पेज पर सबसे नीचे मौजूद सेव करें बटन पर क्लिक करें.
7. पाइपलाइन सेट अप करना
Jenkins में, ‘नया आइटम' पर क्लिक करें:
नाम के लिए ‘jenkins-integration-sample' डालें और प्रोजेक्ट टाइप के तौर पर ‘मल्टीब्रैंच पाइपलाइन' चुनें. इसके बाद, 'ठीक है' पर क्लिक करें:
इसके बाद, आपको पाइपलाइन कॉन्फ़िगरेशन पेज पर रीडायरेक्ट कर दिया जाएगा. शाखा के सोर्स में जाकर, प्रोजेक्ट डेटा स्टोर करने की जगह के तौर पर https://github.com/GoogleCloudPlatform/jenkins-integration-samples.git डालें. बिल्ड कॉन्फ़िगरेशन में, स्क्रिप्ट पाथ के तौर पर ‘gke/Jenkinsfile' डालें.
इन सेटिंग को लागू करने के लिए, सेव करें पर क्लिक करें. सेव करने के बाद, Jenkins, हर शाखा के लिए रिपॉज़िटरी को स्कैन करेगा और उसके बाद बिल्ड करेगा. इस प्रोसेस के दौरान, आपको Kubernetes के वर्कलोड पेज पर, पॉड बनते, चलते, और बंद होते दिखेंगे.
बिल्ड पूरा होने के बाद, आपको Kubernetes के वर्कलोड पेज पर, jenkins-integration-samples-gke नाम के दो आइटम दिखेंगे. इनमें से हर आइटम, प्रोडक्शन या टेस्टिंग क्लस्टर से जुड़ा होगा. स्टेटस 'ठीक है' के तौर पर दिखेगा:
यहां दिए गए 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 पर झलक देखें' चुनें
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 क्लस्टर पर काम भेजती है