Google Kubernetes Engine पर, Kubernetes में स्प्रिंग बूट Java ऐप्लिकेशन डिप्लॉय करें

1. शुरू करने से पहले

Kubernetes एक ओपन सोर्स प्रोजेक्ट है. इसे लैपटॉप से लेकर हाई-अवेलेबिलिटी मल्टी-नोड क्लस्टर, पब्लिक क्लाउड से लेकर ऑन-प्रिमाइसेस डिप्लॉयमेंट, और वर्चुअल मशीन (वीएम) इंस्टेंस से लेकर बेयर मेटल तक, कई अलग-अलग एनवायरमेंट में चलाया जा सकता है.

इस कोडलैब में, GKE पर Kubernetes में एक सामान्य Spring Boot Java वेब ऐप्लिकेशन डिप्लॉय किया जाएगा. इसका मकसद यह है कि आप अपने वेब ऐप्लिकेशन को Kubernetes पर रेप्लिका ऐप्लिकेशन के तौर पर चला सकें. आपको अपनी मशीन पर डेवलप किए गए कोड को Docker कंटेनर इमेज में बदलना होगा. इसके बाद, GKE पर इमेज को चलाना होगा.

आपको GKE का इस्तेमाल करना होगा. यह Google Cloud पर पूरी तरह से मैनेज की जाने वाली Kubernetes सेवा है. इससे आपको Kubernetes का इस्तेमाल करने पर ज़्यादा ध्यान देने में मदद मिलेगी. इसके बजाय, आपको बुनियादी इंफ़्रास्ट्रक्चर सेट अप करने पर ध्यान नहीं देना होगा.

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

इस कोडलैब में, Spring Boot की मदद से ऐप्लिकेशन बनाने के बारे में गाइड में दिए गए सैंपल कोड का इस्तेमाल किया जाएगा.

ज़रूरी शर्तें

• Java प्रोग्रामिंग लैंग्वेज और टूल की जानकारी
• Vim, Emacs, और nano जैसे स्टैंडर्ड Linux टेक्स्ट एडिटर की जानकारी

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

• एक सामान्य Java ऐप्लिकेशन को Docker कंटेनर के तौर पर पैकेज करें.
• GKE पर अपना Kubernetes क्लस्टर बनाएं.
• अपने Java ऐप्लिकेशन को GKE पर Kubernetes में डिप्लॉय करें.
• अपनी सेवा को स्केल अप करें और अपग्रेड रोल आउट करें.
• ऐक्सेस डैशबोर्ड, वेब पर आधारित Kubernetes का यूज़र इंटरफ़ेस.

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

• Google Cloud प्रोजेक्ट
• कोई ब्राउज़र, जैसे कि Google Chrome

2. सेटअप और ज़रूरी शर्तें

अपने हिसाब से एनवायरमेंट सेट अप करना

1. Google Cloud Console में साइन इन करें और नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें. अगर आपके पास पहले से कोई Gmail या Google Workspace खाता नहीं है, तो आपको एक खाता बनाना होगा.

• प्रोजेक्ट का नाम, इस प्रोजेक्ट में हिस्सा लेने वाले लोगों के लिए डिसप्ले नेम होता है. यह एक वर्ण स्ट्रिंग है, जिसका इस्तेमाल Google API नहीं करते हैं. इसे कभी भी अपडेट किया जा सकता है.
• प्रोजेक्ट आईडी, सभी Google Cloud प्रोजेक्ट के लिए यूनीक होता है. साथ ही, इसे बदला नहीं जा सकता. Cloud Console, अपने-आप एक यूनीक स्ट्रिंग जनरेट करता है. आम तौर पर, आपको इससे कोई फ़र्क़ नहीं पड़ता कि यह क्या है. ज़्यादातर कोडलैब में, आपको अपने प्रोजेक्ट आईडी (आम तौर पर PROJECT_ID के तौर पर पहचाना जाता है) का रेफ़रंस देना होगा. अगर आपको जनरेट किया गया आईडी पसंद नहीं है, तो आपके पास कोई दूसरा रैंडम आईडी जनरेट करने का विकल्प होता है. इसके अलावा, आपके पास अपना नाम आज़माने का विकल्प भी है. इससे आपको पता चलेगा कि वह नाम उपलब्ध है या नहीं. इस चरण के बाद, इसे बदला नहीं जा सकता. यह प्रोजेक्ट की अवधि तक बना रहता है.
• आपकी जानकारी के लिए बता दें कि एक तीसरी वैल्यू भी होती है, जिसे प्रोजेक्ट नंबर कहते हैं. इसका इस्तेमाल कुछ एपीआई करते हैं. इन तीनों वैल्यू के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.

चेतावनी: प्रोजेक्ट आईडी, दुनिया भर में यूनीक होता है. इसे चुनने के बाद, कोई और व्यक्ति इसका इस्तेमाल नहीं कर सकता. उस आईडी का इस्तेमाल सिर्फ़ आपके पास हो. प्रोजेक्ट मिटाने के बाद भी, आईडी का दोबारा इस्तेमाल नहीं किया जा सकता

ध्यान दें: अगर Gmail खाते का इस्तेमाल किया जाता है, तो डिफ़ॉल्ट जगह को कोई संगठन नहीं पर सेट किया जा सकता है. अगर Google Workspace खाते का इस्तेमाल किया जा रहा है, तो अपने संगठन के हिसाब से कोई जगह चुनें.

2. इसके बाद, आपको Cloud Console में बिलिंग की सुविधा चालू करनी होगी, ताकि Cloud संसाधनों/एपीआई का इस्तेमाल किया जा सके. इस कोडलैब को पूरा करने में ज़्यादा खर्च नहीं आएगा. इस ट्यूटोरियल के बाद बिलिंग से बचने के लिए, संसाधनों को शट डाउन करें. इसके लिए, बनाए गए संसाधनों को मिटाएं या प्रोजेक्ट को मिटाएं. Google Cloud के नए उपयोगकर्ताओं को, 300 डॉलर का क्रेडिट मुफ़्त में आज़माने का प्रोग्राम मिलता है.

Cloud Shell चालू करें

1. Cloud Console में, Cloud Shell चालू करें पर क्लिक करें.

अगर Cloud Shell को पहली बार शुरू किया जा रहा है, तो आपको एक इंटरमीडिएट स्क्रीन दिखेगी. इसमें Cloud Shell के बारे में बताया गया होगा. अगर आपको इंटरमीडिएट स्क्रीन दिखती है, तो जारी रखें पर क्लिक करें.

Cloud Shell से कनेक्ट होने में कुछ ही सेकंड लगेंगे.

इस वर्चुअल मशीन में, डेवलपमेंट के लिए ज़रूरी सभी टूल पहले से मौजूद होते हैं. यह 5 जीबी की होम डायरेक्ट्री उपलब्ध कराता है. साथ ही, Google Cloud में काम करता है. इससे नेटवर्क की परफ़ॉर्मेंस और पुष्टि करने की प्रोसेस बेहतर होती है. इस कोडलैब में ज़्यादातर काम ब्राउज़र से किया जा सकता है.

Cloud Shell से कनेक्ट होने के बाद, आपको दिखेगा कि आपने पुष्टि कर ली है और प्रोजेक्ट को आपके प्रोजेक्ट आईडी पर सेट कर दिया गया है.

2. पुष्टि करें कि आपने Cloud Shell में पुष्टि कर ली है. इसके लिए, यह कमांड चलाएं:

gcloud auth list

कमांड का आउटपुट

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

ध्यान दें: gcloud कमांड-लाइन टूल, Google Cloud में सबसे ज़्यादा इस्तेमाल किया जाने वाला और एक जैसा कमांड-लाइन टूल है. यह Cloud Shell में पहले से इंस्टॉल होता है. आपको टैब पूरा करने की सुविधा दिखेगी. ज़्यादा जानकारी के लिए, gcloud कमांड-लाइन टूल की खास जानकारी देखें.

3. यह पुष्टि करने के लिए कि gcloud कमांड को आपके प्रोजेक्ट के बारे में पता है, Cloud Shell में यह कमांड चलाएं:

gcloud config list project

कमांड का आउटपुट

[core]
project = <PROJECT_ID>

अगर ऐसा नहीं है, तो इस कमांड का इस्तेमाल करके इसे सेट किया जा सकता है:

gcloud config set project <PROJECT_ID>

कमांड का आउटपुट

Updated property [core/project].

ध्यान दें: अगर आपको यह ट्यूटोरियल Cloud Shell के बाहर पूरा करना है, तो ऐप्लिकेशन के डिफ़ॉल्ट क्रेडेंशियल सेट अप करें लेख पढ़ें.

3. सोर्स कोड पाना

Cloud Shell लॉन्च होने के बाद, कमांड लाइन का इस्तेमाल करके, होम डायरेक्ट्री में उदाहरण के तौर पर दिए गए सोर्स कोड को क्लोन किया जा सकता है.

$ git clone https://github.com/spring-guides/gs-spring-boot.git
$ cd gs-spring-boot/complete

4. ऐप्लिकेशन को स्थानीय तौर पर चलाना

1. पक्का करें कि JAVA_HOME को सही वर्शन पर सेट किया गया हो:

$ export JAVA_HOME=/usr/lib/jvm/java-1.17.0-openjdk-amd64

2. Spring Boot प्लगिन की मदद से, Spring Boot ऐप्लिकेशन को सामान्य तरीके से शुरू किया जा सकता है.

$ ./mvnw -DskipTests spring-boot:run

3. ऐप्लिकेशन शुरू होने के बाद, Cloud Shell टूलबार में मौजूद वेब प्रीव्यू पर क्लिक करें. इसके बाद, पोर्ट 8080 पर प्रीव्यू करें को चुनें.

आपके ब्राउज़र में एक टैब खुलता है और यह उस सर्वर से कनेक्ट होता है जिसे आपने अभी शुरू किया है.

5. Java ऐप्लिकेशन को Docker कंटेनर के तौर पर पैकेज करना

इसके बाद, आपको अपने ऐप्लिकेशन को Kubernetes पर चलाने के लिए तैयार करना होगा. पहला चरण, कंटेनर और उसके कॉन्टेंट को तय करना है.

1. ऐप्लिकेशन के लिए, डिप्लॉय किया जा सकने वाला JAR बनाएं.

$ ./mvnw -DskipTests package

2. बनाई जाने वाली कंटेनर इमेज को सेव करने के लिए, Artifact Registry API चालू करें.

$ gcloud services enable artifactregistry.googleapis.com

3. अगर कोई Docker रिपॉज़िटरी मौजूद नहीं है, तो बनाएं. किसी भी इमेज को रिपॉज़िटरी में पुश करने से पहले, आपको एक रिपॉज़िटरी बनानी होगी:

$ gcloud artifacts repositories create codelabrepo     --repository-format=docker --location=us-central1 

4. आपकी इमेज इस फ़ॉर्मैट में होगी:

{LOCATION}-docker.pkg.dev/{PROJECT-ID}/{REPOSITORY}/{IMAGE-NAME}

उदाहरण के लिए, अगर आपने codelabrepo नाम की जगह us-central1पर रिपॉज़िटरी बनाई है और आपको अपनी इमेज का नाम hello-java:v1 रखना है, तो इमेज का नाम यह होगा:

us-central1-docker.pkg.dev/{PROJECT-ID}/codelabrepo/hello-java:v1

5. कंटेनर इमेज बनाने और उसे Artifact Registry में पुश करने के लिए, Jib का इस्तेमाल करें.

$ export GOOGLE_CLOUD_PROJECT=`gcloud config list --format="value(core.project)"`

$ ./mvnw -DskipTests com.google.cloud.tools:jib-maven-plugin:build -Dimage=us-central1-docker.pkg.dev/${GOOGLE_CLOUD_PROJECT}/codelabrepo/hello-java:v1

6. आपको Cloud Console में Artifacts Registry Images पेज पर जाकर, कंसोल में कंटेनर इमेज दिखनी चाहिए. अब आपके पास पूरे प्रोजेक्ट के लिए Docker इमेज उपलब्ध है. इसे Kubernetes ऐक्सेस कर सकता है और व्यवस्थित कर सकता है. यह आपको कुछ मिनटों में दिखेगा.
7. (ज़रूरी नहीं) प्रोसेस पूरी होने के बाद (सभी चीज़ों को डाउनलोड और एक्सट्रैक्ट करने में कुछ समय लगेगा), इस इमेज को इस कमांड की मदद से टेस्ट करें. इससे, आपकी नई बनाई गई कंटेनर इमेज से पोर्ट 8080 पर, Docker कंटेनर को डेमॉन के तौर पर चलाया जा सकेगा. अगर आपको अनुमतियों से जुड़ी समस्याएं आ रही हैं, तो सबसे पहले gcloud auth configure-docker us-central1-docker.pkg.dev चलाएं:

$ docker run -ti --rm -p 8080:8080 \
  us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v1

8. Cloud Shell की वेब प्रीव्यू सुविधा का फिर से फ़ायदा लें.

9. आपको नए टैब में डिफ़ॉल्ट पेज दिखेगा. पुष्टि करें कि ऐप्लिकेशन, Docker कंटेनर में स्थानीय तौर पर चल रहा है. इसके बाद, Control+C दबाकर, चल रहे कंटेनर को बंद किया जा सकता है.

6. अपना क्लस्टर बनाना

अब आपके पास GKE क्लस्टर बनाने का विकल्प है. क्लस्टर में, Google की ओर से मैनेज किया जाने वाला Kubernetes API सर्वर और वर्कर नोड का एक सेट होता है. वर्कर नोड, Compute Engine VM होते हैं.

1. सबसे पहले, पक्का करें कि एपीआई से जुड़ी सुविधाएं चालू हों.

$ gcloud services enable compute.googleapis.com container.googleapis.com

2. दो n1-standard-1 नोड वाला क्लस्टर बनाएं. इसमें कुछ मिनट लगेंगे.

$ gcloud container clusters create hello-java-cluster \
  --num-nodes 2 \
  --machine-type n1-standard-1 \
  --zone us-central1-c

आखिर में, आपको बनाया गया क्लस्टर दिखेगा.

Creating cluster hello-java-cluster...done.
Created [https://container.googleapis.com/v1/projects/...].
kubeconfig entry generated for hello-dotnet-cluster.
NAME                  ZONE            MASTER_VERSION  
hello-java-cluster  us-central1-c  ...

ध्यान दें: इसके अलावा, Cloud Console में भी क्लस्टर बनाया जा सकता है. इस पेज पर जाने के लिए, नेविगेशन मेन्यू > Kubernetes Engine > क्लस्टर > क्लस्टर बनाएं पर क्लिक करें. किसी दूसरे ज़ोन में क्लस्टर बनाया जा सकता है. हालांकि, हमारा सुझाव है कि आप उसी क्षेत्र में रहें जहां Container Registry इस्तेमाल करता है.

अब आपके पास GKE की मदद से काम करने वाला, पूरी तरह से फ़ंक्शनल Kubernetes क्लस्टर होना चाहिए.

अब समय आ गया है कि कंटेनर में बदले गए ऐप्लिकेशन को Kubernetes क्लस्टर पर डिप्लॉय किया जाए! अब से, आपको kubectl कमांड लाइन का इस्तेमाल करना होगा. यह आपके Cloud Shell एनवायरमेंट में पहले से ही सेट अप है. बाकी कोडलैब के लिए, Kubernetes क्लाइंट और सर्वर का वर्शन 1.2 या इसके बाद का होना चाहिए. kubectl version से आपको कमांड का मौजूदा वर्शन दिखेगा.

7. अपने ऐप्लिकेशन को Kubernetes पर डिप्लॉय करना

1. Kubernetes डिप्लॉयमेंट, आपकी बनाई गई कंटेनर इमेज का इस्तेमाल करके, आपके ऐप्लिकेशन के कई इंस्टेंस बना सकता है, उन्हें मैनेज कर सकता है, और उन्हें स्केल कर सकता है. kubectl run कमांड का इस्तेमाल करके, अपने ऐप्लिकेशन का एक इंस्टेंस Kubernetes पर डिप्लॉय करें.

$ kubectl create deployment hello-java --image=us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v1

2. आपने जो डिप्लॉयमेंट बनाया है उसे देखने के लिए, यह कमांड चलाएं:

$ kubectl get deployments

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-java   1         1         1            1           37s

3. डिप्लॉयमेंट से बनाए गए ऐप्लिकेशन इंस्टेंस देखने के लिए, यह कमांड चलाएं:

$ kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-java-714049816-ztzrb   1/1       Running   0          57s

इस समय, आपका कंटेनर Kubernetes के कंट्रोल में चल रहा होगा. हालांकि, आपको इसे बाहरी दुनिया के लिए उपलब्ध कराना होगा.

8. बाहरी ट्रैफ़िक की अनुमति दें

डिफ़ॉल्ट रूप से, पॉड को सिर्फ़ क्लस्टर के अंदरूनी आईपी से ऐक्सेस किया जा सकता है. hello-java कंटेनर को Kubernetes वर्चुअल नेटवर्क के बाहर से ऐक्सेस करने के लिए, आपको पॉड को Kubernetes सेवा के तौर पर दिखाना होगा.

1. Cloud Shell में, Kubernetes LoadBalancer सेवा बनाकर पॉड को सार्वजनिक इंटरनेट पर उपलब्ध कराया जा सकता है.

$ kubectl create service loadbalancer hello-java --tcp=8080:8080

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

Kubernetes मास्टर, लोड बैलेंसर और Compute Engine से जुड़े फ़ॉरवर्डिंग के नियम, टारगेट पूल, और फ़ायरवॉल के नियम बनाता है. इससे, Google Cloud के बाहर से भी सेवा को पूरी तरह से ऐक्सेस किया जा सकता है.

2. सेवा का सार्वजनिक तौर पर ऐक्सेस किया जा सकने वाला आईपी पता ढूंढने के लिए, kubectl से क्लस्टर की सभी सेवाओं की सूची बनाने का अनुरोध करें.

$ kubectl get services

NAME         CLUSTER-IP     EXTERNAL-IP      PORT(S)    AGE
hello-java   10.3.253.62    aaa.bbb.ccc.ddd  8080/TCP    1m
kubernetes   10.3.240.1     <none>           443/TCP    5m

ध्यान दें: EXTERNAL-IP को उपलब्ध होने और दिखने में कई मिनट लग सकते हैं. अगर EXTERNAL-IP मौजूद नहीं है, तो कुछ मिनट इंतज़ार करें और फिर से कोशिश करें.

3. अब आपको इस सेवा को ऐक्सेस करने में कोई परेशानी नहीं आएगी. इसके लिए, अपने ब्राउज़र को http://<EXTERNAL_IP>:8080 पर ले जाएं.

9. अपनी सेवा को बड़े पैमाने पर उपलब्ध कराना

Kubernetes की एक अहम सुविधा यह है कि इसकी मदद से, ऐप्लिकेशन को आसानी से स्केल किया जा सकता है. मान लें कि आपको अचानक अपने ऐप्लिकेशन के लिए ज़्यादा क्षमता की ज़रूरत है. ऐसे में, रेप्लिकेशन कंट्रोलर को अपने ऐप्लिकेशन इंस्टेंस के लिए, रेप्लिका की नई संख्या को मैनेज करने के लिए कहा जा सकता है.

$ kubectl scale deployment hello-java --replicas=3

deployment "hello-java" scaled

$ kubectl get deployment
NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-java   3         3         3            3           22m

डिक्लेरेटिव अप्रोच पर ध्यान दें. नए इंस्टेंस शुरू करने या बंद करने के बजाय, यह तय किया जाता है कि हर समय कितने इंस्टेंस चालू रहने चाहिए. Kubernetes रीकंसिलिएशन लूप, यह पक्का करते हैं कि आपकी ज़रूरत के हिसाब से काम हो रहा है या नहीं. अगर ज़रूरत होती है, तो वे कार्रवाई भी करते हैं.

10. अपनी सेवा को अपग्रेड करना

किसी समय, प्रोडक्शन में डिप्लॉय किए गए ऐप्लिकेशन में गड़बड़ियां ठीक करने या अतिरिक्त सुविधाएं जोड़ने की ज़रूरत होगी. Kubernetes की मदद से, उपयोगकर्ताओं पर असर डाले बिना प्रोडक्शन में नया वर्शन डिप्लॉय किया जा सकता है.

1. Cloud Shell मेन्यू में, एडिटर खोलें पर क्लिक करके कोड एडिटर खोलें.
2. src/main/java/com/example/springboot/HelloController.java पर जाएं और जवाब की वैल्यू अपडेट करें.

package com.example.springboot;

import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;

@RestController
public class HelloController {

    @RequestMapping("/")
    public String index() {
        return "Greetings from Google Kubernetes Engine!";
    }
}

3. कंटेनर इमेज का नया वर्शन बनाने और उसे पुश करने के लिए, Jib का इस्तेमाल करें. अपडेट की गई इमेज को बनाने और पुश करने में कम समय लगेगा, क्योंकि आपने कैश मेमोरी का पूरा फ़ायदा उठाया है.

$ ./mvnw -DskipTests package com.google.cloud.tools:jib-maven-plugin:build -Dimage=us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v2

अब Kubernetes, रेप्लिकेशन कंट्रोलर को ऐप्लिकेशन के नए वर्शन में आसानी से अपडेट कर सकता है!

4. चालू कंटेनर के लिए इमेज लेबल बदलने के लिए, आपको मौजूदा hello-java डिप्लॉयमेंट में बदलाव करना होगा और इमेज को us-central1-docker.pkg.dev/PROJECT_ID/codelabrepo/hello-java:v1 से बदलना होगा

us-central1-docker.pkg.dev/PROJECT_ID/codelabrepo/hello-java:v2 तक

5. kubectl set image कमांड का इस्तेमाल करके, Kubernetes से कहा जा सकता है कि वह आपके ऐप्लिकेशन के नए वर्शन को पूरे क्लस्टर में एक-एक करके डिप्लॉय करे. इसके लिए, रोलिंग अपडेट का इस्तेमाल किया जाता है.

$ kubectl set image deployment/hello-java hello-java=us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v2

deployment "hello-java" image updated

ध्यान दें: ऐसा होने पर, हो सकता है कि सेवाओं के उपयोगकर्ताओं को कुछ समय के लिए रुकावटों का सामना करना पड़े. हालांकि, ऐसा इसलिए होता है, क्योंकि हेल्थ चेक कॉन्फ़िगर नहीं किया गया था. यह थोड़ा ज़्यादा ऐडवांस कॉन्फ़िगरेशन है, जो कोडलैब के दायरे से बाहर है.

6. http://EXTERNAL_IP:8080 को फिर से देखें, ताकि यह पता चल सके कि यह नया जवाब दे रहा है या नहीं.

11. रोल बैक करें

ओह! क्या आपने ऐप्लिकेशन के नए वर्शन में कोई गलती की है? ऐसा हो सकता है कि नए वर्शन में कोई गड़बड़ी हो और आपको उसे तुरंत पहले जैसा करना पड़े. Kubernetes की मदद से, इसे आसानी से पिछली स्थिति पर वापस लाया जा सकता है. ऐप्लिकेशन को रोल बैक करने के लिए, यह कमांड चलाएं:

$ kubectl rollout undo deployment/hello-java

http://EXTERNAL_IP:8080 को फिर से देखने पर, आपको पुराना जवाब दिखेगा.

12. बधाई हो

आपने GKE पर Kubernetes के लिए, Java पर आधारित नया वेब ऐप्लिकेशन बनाने और उसे डिप्लॉय करने का तरीका सीखा.

खाली करने के लिए जगह

$ gcloud container clusters delete hello-java-cluster --zone us-central1-c

$ gcloud container images delete us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v1 us-central1-docker.pkg.dev/$GOOGLE_CLOUD_PROJECT/codelabrepo/hello-java:v2

ज़्यादा जानें

• Google Cloud पर Java
• Java कोड के सैंपल
• GKE पर Kubernetes—बुनियादी से लेकर ऐडवांस तक