Google Kubernetes Engine पर Kubernetes के लिए Spring बूट Java ऐप्लिकेशन डिप्लॉय करें

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

इस कोडलैब में आप #39;GKE में Kubernetes पर एक आसान स्प्रिंग बूट Java वेब ऐप्लिकेशन डिप्लॉय करेंगे. आपका लक्ष्य अपने वेब ऐप्लिकेशन को Kubernetes पर डुप्लीकेट ऐप्लिकेशन के तौर पर चलाना होगा. आप अपनी मशीन पर डेवलप किया गया कोड लेंगे, उसे डॉकर कंटेनर इमेज में बदल देंगे, और GKE (जीकेई) पर इमेज चलाएं.

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

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

कोडलैब स्प्रिंग बूट वाला ऐप्लिकेशन बनाना वाली गाइड के नमूने कोड का इस्तेमाल करेगा.

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

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

आप क्या कर सकते हैं

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

आपको क्या चाहिए

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

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

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

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

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

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

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

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

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

Cloud Shell चालू करें

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

अगर आपने &#39 को पहले कभी भी Cloud Shell शुरू नहीं किया है, तो आपको # स्क्रीन के बीच में (पेज के नीचे) जानकारी दी जाएगी कि यह क्या है. अगर ऐसा है तो जारी रखें पर क्लिक करें (और आप इसे कभी भी दोबारा नहीं देख पाएंगे). यहां बताया गया है कि एक बार की स्क्रीन कैसी दिखती है:

प्रावधान करने और Cloud Shell से कनेक्ट होने में कुछ ही समय लगेगा.

इस वर्चुअल मशीन में डेवलपमेंट से जुड़े सभी टूल हैं#39. इसमें 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 बूट प्लग इन के साथ, सामान्य रूप से Spring बूट ऐप्लिकेशन शुरू कर सकते हैं.

$ ./mvnw -DskipTests spring-boot:run

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

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

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

1. ऐप्लिकेशन के लिए इस्तेमाल किया जा सकने वाला JAR बनाएं.

$ ./mvnw -DskipTests package

2. आप जो कंटेनर इमेज बनाते हैं उसे सेव करने के लिए, कंटेनर रजिस्ट्री को चालू करें.

$ gcloud services enable containerregistry.googleapis.com

3. कंटेनर की इमेज बनाने के लिए Jib का इस्तेमाल करें और इसे कंटेनर रजिस्ट्री में भेजें.

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

4. अगर सब कुछ ठीक रहता है, तो आपको कंटेनर रजिस्ट्री / इमेज पर जाकर, कंसोल में मौजूद कंटेनर की इमेज दिखनी चाहिए. अब आपके पास पूरे प्रोजेक्ट के लिए डॉकर इमेज उपलब्ध है. इसे Kubernetes कुछ मिनटों में देख पाएगा.

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

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

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

6. फिर से, Cloud Shell की वेब झलक सुविधा का फ़ायदा उठाएं.

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

आप अपना GKE (जीकेई) क्लस्टर बनाने के लिए तैयार हैं. क्लस्टर में Kubernetes API सर्वर होता है जिसे Google मैनेज करता है. साथ ही, वर्कर नोड का एक सेट होता है. वर्कर नोड, 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 > क्लस्टर > क्लस्टर बनाएं पर क्लिक करें. आप किसी दूसरे ज़ोन में क्लस्टर बना सकते हैं. हालांकि, हमारा सुझाव है कि आप उसी इलाके में रहें जहां कंटेनर रजिस्ट्री का इस्तेमाल होता है.

अब आपके पास पूरी तरह से काम करने वाला Kubernetes क्लस्टर होना चाहिए, जो GKE (जीकेई) की ओर से हो.

अब आपके कंटेनर वाले ऐप्लिकेशन को 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 वर्चुअल नेटवर्क के बाहर से ऐक्सेस करने लायक बनाने के लिए, आपको Pod को Kubernetes सेवा के तौर पर दिखाना होगा.

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

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

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

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

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. क्लाउड शेल मेन्यू में लॉन्च एडिटर पर क्लिक करके कोड एडिटर खोलें.
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

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

आप #39; 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

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

6. http://EXTERNAL_IP:8080 देखकर जांच लें कि यह #39; नया रिस्पॉन्स दे रहा है या नहीं.

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

$ kubectl rollout undo deployment/hello-java

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

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

• Google Cloud पर Java
• Java कोड के नमूने
• GKE (जीकेई) पर क्यूबरनेट्स—मूल रूप से ऐडवांस्ड