1. खास जानकारी
Jenkins, लगातार इंटिग्रेशन के लिए उपलब्ध सबसे लोकप्रिय समाधानों में से एक है. इसका इस्तेमाल, सॉफ़्टवेयर डेवलपमेंट प्रोसेस के ज़रूरी और गैर-मानवीय हिस्सों को ऑटोमेट करने के लिए किया जाता है. Google Cloud पर Kubenetes में Jenkins को डिप्लॉय करने और GKE प्लगिन का इस्तेमाल करने से, ज़रूरत पड़ने पर बिल्ड एक्ज़ीक्यूटर को तेज़ी से और अपने-आप स्केल किया जा सकता है. Cloud Storage के साथ मिलकर, हम कम मेहनत में कोई ऐप्लिकेशन बना और टेस्ट कर सकते हैं.
आपको क्या करना होगा
- Jenkins को Kubernetes क्लस्टर पर डिप्लॉय करना
- Jenkins GKE प्लगिन को डिप्लॉय और कॉन्फ़िगर करना, ताकि Jenkins, एक्ज़ीक्यूटर नोड के तौर पर पॉड बना और मिटा सके
- SpringBoot ऐप्लिकेशन का सैंपल बनाना और उसे टेस्ट करना
- Google Container Registry पर कोई कंटेनर बनाना और पब्लिश करना
- सैंपल ऐप्लिकेशन को स्टेजिंग और प्रोडक्शन GKE एनवायरमेंट पर डिप्लॉय करना
आपको किन चीज़ों की ज़रूरत होगी
- बिलिंग की सुविधा वाला Google Cloud प्रोजेक्ट. अगर आपके पास कोई प्रोजेक्ट नहीं है, तो आपको एक प्रोजेक्ट बनाना होगा.
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}
साथ ही, 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 version कमांड से पुष्टि करें कि Helm काम कर रहा है या नहीं. इससे क्लाइंट और सर्वर के वर्शन नंबर दिखने चाहिए:
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 क्लस्टर पर पब्लिश कर सकते हैं. आपके प्रोजेक्ट पर, IAM अनुमतियों के साथ कुछ कॉन्फ़िगरेशन करना होगा. हम 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 प्रोजेक्ट की helm डायरेक्ट्री में बदलें:
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 पेज पर वापस जाएं. इसके बाद, बाईं ओर मौजूद पैनल में, क्रेडेंशियल पर क्लिक करें. फिर सिस्टम पर क्लिक करें.
पेज के सिस्टम सेक्शन में, ग्लोबल क्रेडेंशियल पर क्लिक करें. इसके बाद, बाईं ओर मौजूद, क्रेडेंशियल जोड़ें पर क्लिक करें:
Kind ड्रॉपडाउन में, 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' डालें. इसके बाद, प्रोजेक्ट टाइप के तौर पर ‘मल्टीब्रांच पाइपलाइन' को चुनें और ठीक है पर क्लिक करें:
हमें पाइपलाइन कॉन्फ़िगरेशन पेज पर रीडायरेक्ट किया जाएगा. ब्रांच के सोर्स में, प्रोजेक्ट रिपॉज़िटरी के तौर पर https://github.com/GoogleCloudPlatform/jenkins-integration-samples.git डालें. बिल्ड कॉन्फ़िगरेशन में, स्क्रिप्ट पाथ के तौर पर ‘gke/Jenkinsfile' डालें.
ये सेटिंग लागू करने के लिए, सेव करें पर क्लिक करें. सेव करने के बाद, Jenkins रिपॉज़िटरी को स्कैन करेगा. साथ ही, हर ब्रांच के लिए एक बिल्ड बनाएगा. जैसे-जैसे यह प्रोसेस आगे बढ़ेगी, आपको Kubernetes Workloads पेज पर पॉड बनते, चलते, और मिटते दिखेंगे.
बिल्ड पूरे होने के बाद, आपको Kubernetes Workloads पेज पर jenkins-integration-samples-gke नाम के दो आइटम दिखेंगे. इनमें से हर आइटम, prod या टेस्टिंग क्लस्टर से जुड़ा होगा. स्टेटस में, ठीक है दिखेगा:
हम इस 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. साफ़-सफ़ाई सेवा
हमने Kubernetes पर Jenkins और मल्टीब्रांच पाइपलाइन के सैंपल को डिप्लॉय करने का तरीका जाना. अब समय है कि हम अपने प्रोजेक्ट से, बनाए गए सभी संसाधनों को मिटा दें.
प्रोजेक्ट मिटाना
अगर आपको ठीक लगे, तो पूरा प्रोजेक्ट मिटाया जा सकता है. जीसीपी कंसोल में, 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 क्लस्टर डिप्लॉय किया और Helm का इस्तेमाल करके Jenkins इंस्टॉल किया
- हमने GKE प्लगिन इंस्टॉल और कॉन्फ़िगर किया, ताकि Jenkins, Kubernetes क्लस्टर पर बिल्ड आर्टफ़ैक्ट डिप्लॉय कर सके
- हमने Jenkins को कॉन्फ़िगर किया, ताकि वह मल्टीब्रांच पाइपलाइन सेट अप कर सके. यह पाइपलाइन, GKE क्लस्टर पर काम भेजती है