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

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

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

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

Jenkins को Kubernetes क्लस्टर पर डिप्लॉय करना
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 बकेट बनाना

हमें टेस्ट वर्क अपलोड करने के लिए, 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

फ़ाइल को अनज़िप करें और उसमें शामिल हेल्म फ़ाइल को अपनी मौजूदा वर्किंग डायरेक्ट्री में कॉपी करें:

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 पॉड को RUNNING स्टेटस के साथ दिखाया जाना चाहिए:

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 प्रोजेक्ट की rbac डायरेक्ट्री में बदलें. हमने इसे पहले क्लोन किया था:

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 robot deployer का इस्तेमाल करके, GKE प्लगिन के लिए क्लस्टर अनुमतियां सेट अप करने के लिए Helm का इस्तेमाल कर सकते हैं. अपनी वर्किंग डायरेक्ट्री को GKE प्रोजेक्ट की हेल्म डायरेक्ट्री में बदलें:

cd ~/google-kubernetes-engine-plugin/docs/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 पेज पर वापस जाएं. इसके बाद, बाईं ओर मौजूद पैनल में, क्रेडेंशियल और फिर सिस्टम पर क्लिक करें.

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

Kind ड्रॉपडाउन में, Google Service Account from private key चुनें. नाम के तौर पर ‘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 में, ‘New Item' पर क्लिक करें:

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

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

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

बिल्ड पूरे होने के बाद, आपको Kubernetes Workloads पेज पर 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 क्लस्टर को काम सौंपती है