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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

b35bf95b8bf3d5d8.png

a99b7ace416376c4.png

bd84a6d3004737c5.png

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

Cloud Shell चालू करें

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

55efc1aaa7a4d3ad.png

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

9c92662c6a846a5c.png

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

9f0e51b578fecce5.png

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

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

  1. यह पुष्टि करने के लिए 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`
  1. Cloud Shell में यह कमांड चलाएं, ताकि यह पुष्टि की जा सके कि gcloud के लिए कमांड को आपके प्रोजेक्ट के बारे में जानकारी है:
gcloud config list project

कमांड आउटपुट

[core]
project = <PROJECT_ID>

अगर ऐसा नहीं है, तो आप इसे इस निर्देश की मदद से सेट कर सकते हैं:

gcloud config set project <PROJECT_ID>

कमांड आउटपुट

Updated property [core/project].

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
  1. आप Spring बूट प्लगिन के ज़रिए Spring बूट ऐप्लिकेशन को सामान्य रूप से शुरू कर सकते हैं.
$ ./mvnw -DskipTests spring-boot:run
  1. ऐप्लिकेशन शुरू होने के बाद, Cloud Shell टूलबार में वेब झलक1a94d5bd10bfc072.png पर क्लिक करें और पोर्ट 8080 पर झलक देखें को चुनें.

6252b94905f3f7bd.png

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

9b6c29059957bd0.jpeg

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

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

  1. ऐप्लिकेशन के लिए डिप्लॉय किया जा सकने वाला JAR बनाएं.
$ ./mvnw -DskipTests package
  1. आपको जो कंटेनर इमेज बनानी है उसे स्टोर करने के लिए, Artifact Registry API को चालू करें.
$ gcloud services enable artifactregistry.googleapis.com
  1. अगर Docker रिपॉज़िटरी मौजूद नहीं है, तो नया रिपॉज़िटरी बनाएं. किसी इमेज को पुश करने से पहले, आपको रिपॉज़िटरी बनाना होगा:
$ gcloud artifacts repositories create codelabrepo     --repository-format=docker --location=us-central1
  1. आपकी इमेज इस प्रारूप में होगी:

{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

  1. कंटेनर की इमेज बनाने के लिए Jib का इस्तेमाल करें और उसे Artifact Registry में भेजें.
$ 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
  1. Cloud Console में आर्टफ़ैक्ट रजिस्ट्री इमेज पेज पर जाकर, कंसोल में मौजूद कंटेनर की इमेज देखी जा सकती है. अब आपके पास पूरे प्रोजेक्ट के लिए Docker इमेज उपलब्ध है. इसे ऐक्सेस करने और व्यवस्थित करने की सुविधा Kubernetes दे सकती है. ऐसा कुछ ही मिनटों में होता है.
  2. (ज़रूरी नहीं) पूरी प्रोसेस को डाउनलोड करने और एक्सट्रैक्ट करने में कुछ समय लगेगा. इसके बाद, यहां दिए गए निर्देश की मदद से इमेज की जांच करें. इससे, आपकी नई बनाई गई कंटेनर इमेज से, पोर्ट 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
  1. Cloud Shell की वेब झलक देखने की सुविधा का फ़ायदा फिर से लें.

6252b94905f3f7bd.png

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

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

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

  1. सबसे पहले, यह पक्का करें कि इससे जुड़ी एपीआई की सुविधाएं चालू हों.
$ gcloud services enable compute.googleapis.com container.googleapis.com
  1. दो 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  ...

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

758c7fca14f70623.png

अब कंटेनर के तौर पर बनाए गए ऐप्लिकेशन को Kubernetes क्लस्टर में डिप्लॉय करने का समय आ गया है! अब से, आपको kubectl कमांड लाइन इस्तेमाल करनी होगी. इसे पहले से ही क्लाउड शेल एनवायरमेंट में सेट अप किया जा सकता है. बाकी कोडलैब के लिए, 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
  1. अपने बनाए गए डिप्लॉयमेंट को देखने के लिए, बस नीचे दिया गया कमांड चलाएं:
$ kubectl get deployments

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-java   1         1         1            1           37s
  1. डिप्लॉयमेंट के ज़रिए बनाए गए ऐप्लिकेशन इंस्टेंस देखने के लिए, नीचे दिया गया कमांड चलाएं:
$ kubectl get pods

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

इस स्थिति में, आपके पास अपने कंटेनर को Kubernetes के नियंत्रण में चलाने के लिए होना चाहिए, लेकिन फिर भी आपको इसे बाहरी दुनिया के लिए ऐक्सेस करने लायक बनाना होगा.

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

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

  1. Cloud Shell में, Kubernetes Load Balancer सेवा बनाकर, पॉड को सार्वजनिक रूप से इंटरनेट पर दिखाया जा सकता है.
$ kubectl create service loadbalancer hello-java --tcp=8080:8080

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

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

  1. सेवा का सार्वजनिक रूप से ऐक्सेस किया जा सकने वाला आईपी पता ढूंढने के लिए, 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
  1. अब आप अपने ब्राउज़र को 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. क्लाउड शेल मेन्यू में, एडिटर खोलें 2109d75686c889a.pngपर क्लिक करके कोड एडिटर खोलें.
  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!";
    }
}
  1. कंटेनर इमेज का नया वर्शन बनाने और पुश करने के लिए 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 के ज़रिए ऐप्लिकेशन के नए वर्शन में, अपने रेप्लिकेशन कंट्रोलर को आसानी से अपडेट करने के लिए तैयार हैं!

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

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

  1. रोलिंग अपडेट के साथ, एक बार में पूरे क्लस्टर में अपने ऐप्लिकेशन के नए वर्शन को डिप्लॉय करने के लिए, kubectl set image कमांड का इस्तेमाल किया जा सकता है.
$ 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
  1. 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

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