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

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

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

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

ध्यान दें: Cloud Console के यूआरएल को याद रखकर, इसे आसानी से ऐक्सेस किया जा सकता है. इसका यूआरएल console.cloud.google.com है.

प्रोजेक्ट आईडी याद रखें. यह सभी Google Cloud प्रोजेक्ट के लिए एक यूनीक नाम होता है. ऊपर दिया गया नाम पहले ही इस्तेमाल किया जा चुका है. इसलिए, यह आपके लिए काम नहीं करेगा. माफ़ करें! इस कोड लैब में इसे बाद में PROJECT_ID के तौर पर दिखाया जाएगा.

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

2. इसके बाद, Google Cloud के संसाधनों का इस्तेमाल करने के लिए, आपको Cloud Console में बिलिंग चालू करनी होगी.

इस कोडलैब को पूरा करने में आपको कुछ डॉलर से ज़्यादा खर्च नहीं करने पड़ेंगे. हालांकि, अगर ज़्यादा संसाधनों का इस्तेमाल किया जाता है या उन्हें चालू रखा जाता है, तो यह खर्च बढ़ सकता है.

Google Cloud के नए उपयोगकर्ता, 300 डॉलर के क्रेडिट के साथ मुफ़्त में आज़माने की सुविधा पा सकते हैं.

Cloud Shell चालू करें

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

अगर आपने Cloud Shell का इस्तेमाल पहले कभी नहीं किया है, तो आपको एक इंटरमीडिएट स्क्रीन दिखेगी. यह स्क्रीन, फ़ोल्ड के नीचे दिखेगी. इसमें Cloud Shell के बारे में जानकारी दी गई होगी. अगर ऐसा है, तो जारी रखें पर क्लिक करें. इसके बाद, आपको यह स्क्रीन कभी नहीं दिखेगी. एक बार दिखने वाली स्क्रीन ऐसी दिखती है:

Cloud Shell को चालू करने और उससे कनेक्ट होने में सिर्फ़ कुछ सेकंड लगेंगे.

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

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 कमांड-लाइन टूल की खास जानकारी देखें.

gcloud config list project

कमांड आउटपुट

[core]
project = <PROJECT_ID>

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

gcloud config set project <PROJECT_ID>

कमांड आउटपुट

Updated property [core/project].

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

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

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

$ ./mvnw -DskipTests spring-boot:run

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

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

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

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

$ ./mvnw -DskipTests package

2. कंटेनर रजिस्ट्री चालू करें, ताकि बनाई जाने वाली कंटेनर इमेज को सेव किया जा सके.

$ gcloud services enable containerregistry.googleapis.com

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

$ ./mvnw -DskipTests com.google.cloud.tools:jib-maven-plugin:build \
  -Dimage=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1

4. अगर सब कुछ ठीक रहा, तो आपको कंटेनर इमेज, कंसोल में दिखनी चाहिए. इसके लिए, Container Registry > Images पर जाएं. अब आपके पास पूरे प्रोजेक्ट के लिए Docker इमेज उपलब्ध है. इसे Kubernetes ऐक्सेस कर सकता है और व्यवस्थित कर सकता है. यह आपको कुछ मिनटों में दिखेगा.

ध्यान दें: आपने रजिस्ट्री (gcr.io) के लिए सामान्य डोमेन का इस्तेमाल किया है. हालांकि, आपके पास यह तय करने का विकल्प भी है कि कौनसे ज़ोन और बकेट का इस्तेमाल करना है. ज़्यादा जानकारी के लिए, Container Registry का दस्तावेज़ देखें.

5. इसके बाद, जब यह प्रोसेस पूरी हो जाए, तो इमेज को स्थानीय तौर पर टेस्ट किया जा सकता है. इसमें कुछ समय लगेगा, क्योंकि सभी चीज़ें डाउनलोड और एक्सट्रैक्ट की जाएंगी. इसके लिए, यह कमांड इस्तेमाल करें. इससे आपकी बनाई गई नई कंटेनर इमेज से, पोर्ट 8080 पर Docker कंटेनर, डेमॉन के तौर पर चलेगा:

$ docker run -ti --rm -p 8080:8080 \
  gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v1

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

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

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

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

$ gcloud services enable compute.googleapis.com container.googleapis.com
Operation "operations/..." finished successfully

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 से आपको कमांड का मौजूदा वर्शन दिखेगा.

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

$ kubectl create deployment hello-java \
  --image=gcr.io/$GOOGLE_CLOUD_PROJECT/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 के कंट्रोल में चल रहा होगा. हालांकि, आपको इसे बाहरी दुनिया के लिए उपलब्ध कराना होगा.

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

1. Cloud Shell में, --type=LoadBalancer फ़्लैग के साथ kubectl expose कमांड का इस्तेमाल करके, पॉड को सार्वजनिक इंटरनेट पर दिखाया जा सकता है. बाहरी तौर पर ऐक्सेस किए जा सकने वाले आईपी पते को बनाने के लिए, इस फ़्लैग की ज़रूरत होती है.

$ 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. ध्यान दें कि आपकी सेवा के लिए दो आईपी पते दिए गए हैं. दोनों 8080 पोर्ट पर काम कर रहे हैं. पहला, इंटरनल आईपी पता है. यह सिर्फ़ आपके वर्चुअल प्राइवेट क्लाउड में दिखता है. दूसरा, लोड बैलेंस किया गया एक्सटर्नल आईपी पता होता है. इस उदाहरण में, एक्सटर्नल आईपी पता aaa.bbb.ccc.ddd है. अब आपको http://<EXTERNAL_IP>:8080 पर जाकर, सेवा को ऐक्सेस करने का विकल्प मिलेगा.

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 रीकंसिलिएशन लूप, यह पक्का करते हैं कि आपके अनुरोध के मुताबिक काम हो रहा है या नहीं. अगर ज़रूरी हो, तो वे कार्रवाई भी करते हैं.

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

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

package hello;

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=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v2

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

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

4. चल रहे कंटेनर के लिए इमेज लेबल बदलने के लिए, आपको मौजूदा hello-java डिप्लॉयमेंट में बदलाव करना होगा. साथ ही, इमेज को gcr.io/PROJECT_ID/hello-java:v1 से gcr.io/PROJECT_ID/hello-java:v2 में बदलना होगा.

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

$ kubectl set image deployment/hello-java \
  hello-java=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-java:v2

deployment "hello-java" image updated

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

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

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

$ kubectl rollout undo deployment/hello-java

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

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

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