Google Kubernetes Engine में, Jib के साथ कंटेनर किया गया Micronaut ऐप्लिकेशन डिप्लॉय करें

1. खास जानकारी

माइक्रोनॉट के बारे में जानकारी

Micronaut जेवीएम पर आधारित एक मॉडर्न और फ़ुल स्टैक फ़्रेमवर्क है. इसकी मदद से, मॉड्यूलर, आसानी से जांच की जा सकने वाली माइक्रोसर्विस, और बिना सर्वर वाले ऐप्लिकेशन बनाए जा सकते हैं. Micronaut का लक्ष्य कम से कम मेमोरी फ़ुटप्रिंट के साथ, शानदार स्टार्टअप समय, तेज़ थ्रूपुट देना है. डेवलपर, Java, Groovy या Kotlin में Micronaut के साथ डेवलप कर सकते हैं.

Micronaut से ये सुविधाएं मिलती हैं:

  • तेज़ी से स्टार्टअप समय और कम मेमोरी की खपत — रिफ़्लेक्शन पर आधारित IoC फ़्रेमवर्क आपके कोड में हर एक फ़ील्ड, तरीके, और कंस्ट्रक्टर के लिए रिफ़्लेक्शन डेटा लोड और कैश करते हैं. वहीं, माइक्रोनॉट का इस्तेमाल करने पर, आपके ऐप्लिकेशन के शुरू होने में लगने वाला समय और मेमोरी का इस्तेमाल आपके कोड बेस के साइज़ से तय नहीं होता है.
  • घोषणात्मक, रीऐक्टिव, कंपाइल-टाइम एचटीटीपी क्लाइंट — एलान के तौर पर, रिऐक्टिव एचटीटीपी क्लाइंट बनाए जाते हैं, जिन्हें कंपाइल करते समय लागू किया जाता है. इससे मेमोरी की खपत कम होती है.
  • Netty पर बनाया गया ऐसा एचटीटीपी सर्वर जो ब्लॉक नहीं करता है — आसानी से सीखने के लिए, Micronaut का एचटीटीपी सर्वर, ऐसे एपीआई को दिखाना बेहद आसान बनाता है जिन्हें एचटीटीपी क्लाइंट इस्तेमाल कर सकते हैं.
  • तेज़ और आसान परीक्षण — अपने यूनिट परीक्षणों में सर्वर और क्लाइंट को आसानी से स्पिन करें और उन्हें तुरंत चलाएं.
  • कुशल कंपाइल-टाइम डिपेंडेंसी इंजेक्शन और एओपी — Micronaut, कंपाइल-टाइम आसपेक्ट-ओरिएंटेड प्रोग्रामिंग एपीआई उपलब्ध कराता है, जो रिफ़्लेक्शन का इस्तेमाल नहीं करता.
  • पूरी तरह से रिऐक्टिव और ब्लॉक न होने वाले ऐप्लिकेशन बनाएं — Micronaut, Reactive Streams को लागू करने वाले किसी भी फ़्रेमवर्क के साथ काम करता है. इनमें RxJava और Reactor शामिल हैं.

ज़्यादा जानकारी के लिए, कृपया Mi Cronaut की वेबसाइट पर जाएं.

Kubernetes के बारे में जानकारी

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

इस लैब में, Kubernetes Engine पर चलने वाले Kubernetes पर, सामान्य ग्रूवी आधारित माइक्रोनॉट माइक्रोसर्विस डिप्लॉय की गई है.

इस कोडलैब का मकसद, आपकी माइक्रोसर्विस को Kubernetes पर चलने वाली सेवा के तौर पर चलाना है. आपने अपनी मशीन पर जो कोड बनाया है उसे लेकर, Docker कंटेनर इमेज में बदलें और फिर उस इमेज को Kubernetes Engine पर चलाएं.

इस कोडलैब में चलने वाले अलग-अलग हिस्सों का डायग्राम यहां दिया गया है. इससे आपको यह समझने में मदद मिलेगी कि अलग-अलग हिस्सों को एक साथ कैसे फ़िट किया जाता है. कोडलैब में आगे बढ़ने पर, रेफ़रंस के तौर पर इसका इस्तेमाल करें; तब तक सब कुछ समझ में आ जाना चाहिए, तब तक समझ में आता है, लेकिन फ़िलहाल इसे बेझिझक अनदेखा कर दें.

Kubernetes कोडलैब डायग्राम 1 (2).png

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

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

Jib के बारे में जानकारी

Jib एक ओपन सोर्स टूल है, जिसकी मदद से आप अपने Java ऐप्लिकेशन के लिए Docker और OCI इमेज बना सकते हैं. यह Maven और Gradle के लिए प्लगिन के तौर पर, और Java लाइब्रेरी के तौर पर उपलब्ध है.

Jib का मकसद यह है:

  • तेज़ — अपने बदलावों को तेज़ी से लागू करें. Jib आपके ऐप्लिकेशन को एक से ज़्यादा लेयर में बांटता है और क्लास से डिपेंडेंसी को अलग करता है. अब आपको Docker के ज़रिए अपना पूरा Java ऐप्लिकेशन फिर से बनाने तक इंतज़ार करने की ज़रूरत नहीं है - बस उन लेयर को डिप्लॉय करें जिनमें बदलाव हुआ है.
  • फिर से बनाया जा सकता है — एक जैसे कॉन्टेंट के साथ अपने कंटेनर की इमेज को फिर से बनाने पर, हमेशा एक ही इमेज जनरेट होती है. गैर-ज़रूरी अपडेट को फिर से ट्रिगर न करें.
  • नुकसान न पहुंचाने वाला — अपनी सीएलआई डिपेंडेंसी कम करें. Maven या Gradle में से अपनी Docker इमेज बनाएं और अपनी पसंद की किसी भी रजिस्ट्री पर पुश करें. अब Dockerfiles लिखने और डॉकर बिल्ड/पुश को कॉल करने की ज़रूरत नहीं.

आपको GitHub प्रोजेक्ट पेज पर Jib के बारे में ज़्यादा जानकारी मिल सकती है.

इस ट्यूटोरियल के बारे में जानकारी

यह ट्यूटोरियल, Java ऐप्लिकेशन के लिए कंटेनर बनाने के लिए, Jib टूल के सैंपल कोड का इस्तेमाल करता है.

यह सैंपल, एक सामान्य नमस्ते World सेवा है. इसमें Micronaut फ़्रेमवर्क और Apache Groovy प्रोग्रामिंग भाषा का इस्तेमाल किया गया है.

आप इन चीज़ों के बारे में जानेंगे

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

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

  • Google Cloud Platform प्रोजेक्ट
  • ब्राउज़र, जैसे कि Chrome या Firefox
  • Vim, EMAC या Nano जैसे स्टैंडर्ड Linux टेक्स्ट एडिटर के बारे में जानकारी

इस ट्यूटोरियल का इस्तेमाल कैसे किया जाएगा?

इसे सिर्फ़ पढ़ें इसे पढ़ें और कसरतों को पूरा करें

एचटीएमएल/सीएसएस वेब ऐप्लिकेशन बनाने के अपने अनुभव को आप कितनी रेटिंग देंगे?

शुरुआती इंटरमीडिएट कुशल

Google Cloud Platform की सेवाएं इस्तेमाल करने का आपका अनुभव कैसा रहा?

शुरुआती इंटरमीडिएट कुशल

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

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

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

dMbN6g9RawQj_VXCSYpdYncY-DbaRzr2GbnwoV7jFf1u3avxJtmGPmKpMYgiaMH-qu80a_NJ9p2IIXFppYk8x3wyymZXavjglNLJJhuXieCem56H30hwXtd8PvXGpXJO9gEUDu3cZw

ci9Oe6PgnbNuSYlMyvbXF1JdQyiHoEgnhl4PlV_MFagm2ppzhueRkqX4eLjJllZco_2zCp0V0bpTupUSKji9KkQyWqj11pqit1K1faS1V6aFxLGQdkuzGp4rsQTan7F01iePL5DtqQ

8-tA_Lheyo8SscAVKrGii2coplQp2_D1Iosb2ViABY0UUO1A8cimXUu6Wf1R9zJIRExL5OB2j946aIiFtyKTzxDcNnuznmR45vZ2HMoK3o67jxuoUJCAnqvEX6NgPGFjCVNgASc-lg

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

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

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

3. Micronaut का सैंपल सोर्स कोड पाएं

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

$ git clone https://github.com/GoogleContainerTools/jib.git
$ cd jib/examples/micronaut/

4. कोड पर एक नज़र

हम Micronaut की सामान्य सेवा को एक कंट्रोलर से बनाते हैं, जो हैलो वर्ल्ड के मशहूर मैसेज के साथ इस तरह का मैसेज देता है:

@Controller("/hello")
class HelloController {
    @Get("/")
    String index() {
        "Hello World"
    }
}

HelloController कंट्रोलर, /hello पाथ के तहत अनुरोधों का जवाब दे रहा है. साथ ही, index() तरीका, एचटीटीपी जीईटी अनुरोधों को स्वीकार कर रहा है.

Spock टेस्ट क्लास का इस्तेमाल करके यह पता लगाया जा सकता है कि आउटपुट में सही मैसेज दिया गया है या नहीं.

class HelloControllerSpec extends Specification {
    @Shared
    @AutoCleanup
    EmbeddedServer embeddedServer = ApplicationContext.run(EmbeddedServer)

    @Shared
    @AutoCleanup
    RxHttpClient client = embeddedServer.applicationContext.createBean(RxHttpClient, embeddedServer.getURL()) 

    void "test hello world response"() {
        when:
        HttpRequest request = HttpRequest.GET('/hello')
        String rsp  = client.toBlocking().retrieve(request)

        then:
        rsp == "Hello World"
    }
}

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

जांच करने के लिए, नीचे दिया गया कमांड चलाकर देखा जा सकता है कि सब कुछ ठीक है या नहीं:

./gradlew test

5. ऐप्लिकेशन को डिवाइस पर चलाएं

आप नीचे दिए गए Gradle कमांड का इस्तेमाल करके, सामान्य रूप से माइक्रोनॉट सेवा शुरू कर सकते हैं:

$ ./gradlew run

ऐप्लिकेशन शुरू होने के बाद, छोटे + आइकॉन की मदद से अतिरिक्त Cloud Shell इंस्टेंस खोलें. इसके बाद, कर्ल की मदद से यह जांच करें कि आपको सही आउटपुट मिल रहा है या नहीं:

$ curl localhost:8080/hello

साथ ही, आपको स्क्रीन पर एक आसान "नमस्ते दुनिया" दिखेगा तो मैसेज दिखाई देता है.

6. ऐप्लिकेशन को Jib के साथ Docker कंटेनर के तौर पर पैकेज करें

इसके बाद, अपने ऐप्लिकेशन को Kubernetes पर चलाने के लिए तैयार करें. इस काम के लिए, हम यह कोशिश करेंगे कि Jib का इस्तेमाल किया जा सके, क्योंकि हमें खुद Dockerfile को छूना नहीं पड़ेगा!

आइए, अपना कंटेनर बनाने के लिए कमांड चलाएं:

$ ./gradlew jibDockerBuild

आपको यह आउटपुट देखना चाहिए:

Tagging image with generated image reference micronaut-jib:0.1. If you'd like to specify a different tag, you can set the jib.to.image parameter in your build.gradle, or use the --im
age=<MY IMAGE> commandline flag.

Containerizing application to Docker daemon as micronaut-jib:0.1...
warning: Base image 'gcr.io/distroless/java' does not use a specific image digest - build may not be reproducible
Getting base image gcr.io/distroless/java...
Building dependencies layer...
Building resources layer...
Building classes layer...
Finalizing...

Container entrypoint set to [java, -cp, /app/resources:/app/classes:/app/libs/*, example.micronaut.Application]
Loading to Docker daemon...

Built image to Docker daemon as micronaut-jib:0.1

इमेज बन जाने के बाद, अब हम Cloud Shell के पहले टैब में Docker इमेज चलाकर, अपना फ़्रेंडली हैलो मैसेज देखते हैं:

$ docker run -it -p 8080:8080 micronaut-jib:0.1
16:57:20.255 [main] INFO  i.m.context.env.DefaultEnvironment - Established active environments: [cloud, gcp]
16:57:23.203 [main] INFO  io.micronaut.runtime.Micronaut - Startup completed in 2926ms. Server Running: http://97b7d76ccf3f:8080

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

$ curl localhost:8080/hello
Hello World

Cloud Shell में Ctrl+C को दबाकर कंटेनर को रोका जा सकता है.

7. कंटेनर के तौर पर दी गई हमारी सेवा को रजिस्ट्री में भेजना

इमेज उम्मीद के मुताबिक काम कर रही है. इसे Google Container Registry में भेजा जा सकता है. यह Docker इमेज के लिए एक निजी रिपॉज़िटरी है, जिसे हर Google Cloud प्रोजेक्ट से ऐक्सेस किया जा सकता है. हालांकि, Google Cloud Platform के बाहर से भी इसे ऐक्सेस किया जा सकता है.

रजिस्ट्री में शामिल होने से पहले, यह पक्का कर लें कि कंटेनर रजिस्ट्री हमारे प्रोजेक्ट के लिए चालू है. इसके लिए, Tools > कंटेनर रजिस्ट्री. अगर यह चालू नहीं है, तो आपको यह डायलॉग बॉक्स दिखेगा. इसके बाद, कृपया "Container Registry API को चालू करें" पर क्लिक करें इसे चालू करने के लिए:

ac812e6260ac7dfb.png

रजिस्ट्री तैयार होने के बाद, इमेज को रजिस्ट्री में पुश करने के लिए, ये कमांड लॉन्च करें:

$ gcloud auth configure-docker
$ docker tag micronaut-jib:0.1 \
         gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.1
$ docker push gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.1

ऊपर दिए गए निर्देशों से gcloud SDK टूल, डॉकर को कॉन्फ़िगर करने देता है और डॉकर को कंटेनर Registry के आपके इंस्टेंस में इमेज पुश करने की अनुमति देता है. इससे, इमेज को रजिस्ट्री में उसकी जगह पर दिखाने के लिए टैग किया जा सकता है और फिर उसे रजिस्ट्री में भेजा जा सकता है.

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

12224c4e42183b4e.png

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

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

20c0587c0108b8ba.png

क्लस्टर में Google के मैनेज किया जाने वाला Kubernetes मास्टर एपीआई सर्वर और वर्कर नोड का एक सेट होता है. वर्कर नोड, Compute Engine वर्चुअल मशीन होते हैं. दो n1-standard-1 नोड वाला क्लस्टर बनाने के लिए, आपके CloudShell सेशन से gcloud सीएलआई का इस्तेमाल करें (इसे पूरा होने में कुछ मिनट लगेंगे):

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

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

Creating cluster hello-cluster in us-central1-c...done.
Created [https://container.googleapis.com/v1/projects/mn-gke-test/zones/us-central1-c/clusters/hello-cluster].
To inspect the contents of your cluster, go to: https://console.cloud.google.com/kubernetes/workload_/gcloud/us-central1-c/hello-cluster?project=mn-gke-test
kubeconfig entry generated for hello-cluster.
NAME           LOCATION       MASTER_VERSION  MASTER_IP       MACHINE_TYPE   NODE_VERSION  NUM_NODES  STATUS
hello-cluster  us-central1-c  1.9.7-gke.7     35.239.224.115  n1-standard-1  1.9.7-gke.7   2          RUNNING

अब आपके पास Google Kubernetes Engine की मदद से, पूरी तरह से काम करने वाला Kubernetes क्लस्टर होना चाहिए:

d9e1e314769753e7.png

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

9. अपने ऐप्लिकेशन को Kubernetes में डिप्लॉय करें

आपने अभी-अभी जो कंटेनर इमेज बनाई है उसका इस्तेमाल करके Kubernetes डिप्लॉयमेंट की मदद से, आपके ऐप्लिकेशन के कई इंस्टेंस बनाए, मैनेज, और स्केल किए जा सकते हैं. आइए, kubectl create deployment कमांड का इस्तेमाल करके आपके ऐप्लिकेशन को Kubernetes में डिप्लॉय करें:

$ kubectl create deployment hello-micronaut \
  --image=gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.1

अपने अभी बनाए गए डिप्लॉयमेंट को देखने के लिए, बस इसे चलाएं:

$ kubectl get deployments
NAME              DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-micronaut   1         1         1            1           5m

डिप्लॉयमेंट के ज़रिए बनाए गए ऐप्लिकेशन इंस्टेंस देखने के लिए, इस निर्देश को चलाएं:

$ kubectl get pods
NAME                               READY     STATUS    RESTARTS   AGE
hello-micronaut-5647fb98c5-lh5h7   1/1       Running   0          5m

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

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

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

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

$ kubectl expose deployment hello-micronaut --type=LoadBalancer --port=8080

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

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

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

$ kubectl get services
NAME              TYPE           CLUSTER-IP      EXTERNAL-IP     PORT(S)          AGE
hello-micronaut   LoadBalancer   10.39.243.251   aaa.bbb.ccc.ddd 8080:30354/TCP   1m
kubernetes        ClusterIP      10.39.240.1     <none>          443/TCP          31m

ध्यान दें कि आपकी सेवा के लिए दो आईपी पते दिए गए हैं. ये दोनों पोर्ट 8080 काम करते हैं. एक ऐसा इंटरनल आईपी होता है जो सिर्फ़ आपके क्लाउड वर्चुअल नेटवर्क में दिखता है; दूसरा है बाहरी लोड-संतुलित IP. इस उदाहरण में, बाहरी आईपी पता aaa.bbb.ccc.ddd है.

अब आप अपने ब्राउज़र को इस पते पर ले जाकर, इस सेवा तक पहुंच पाएंगे: http://<EXTERNAL_IP>:8080/hello

11. अपनी सेवा का दायरा बढ़ाएं

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

$ kubectl scale deployment hello-micronaut --replicas=3
deployment.extensions "hello-micronaut" scaled

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

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

12. अपनी सेवा को अपग्रेड करने का रोल आउट करें

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

सबसे पहले, आइए ऐप्लिकेशन में बदलाव करते हैं. Cloud Shell से कोड एडिटर खोलें.

5aee8f3d1e003571.png

/jib/examples/micronaut/src/main/groovy/example/micronaut/HelloController.groovy पर जाएं और जवाब की वैल्यू अपडेट करें:

@Controller("/hello")
class HelloController {
    @Get("/")
    String index() {
        "Hello Kubernetes World"
    }
}

/jib/examples/micronaut/build.gradle में, हम इस लाइन को अपडेट करके अपनी इमेज के वर्शन को 0.1 से 0.2 में अपग्रेड करेंगे:

version '0.2'

इसके बाद ऐप्लिकेशन को नए बदलावों के साथ फिर से बनाएं और पैकेज करें:

$ ./gradlew jibDockerBuild

और इमेज को कंटेनर इमेज रजिस्ट्री में टैग करें और पुश करें:

$ docker tag micronaut-jib:0.2 \
         gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.2
$ docker push gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.2

अब आप Kubernetes के ज़रिए अपने प्रतिकृति नियंत्रक को ऐप्लिकेशन के नए वर्शन में आसानी से अपडेट करने के लिए तैयार हैं. अपने चल रहे कंटेनर का इमेज लेबल बदलने के लिए, आपको मौजूदा hello-micronaut deployment में बदलाव करना होगा और इमेज को gcr.io/PROJECT_ID/micronaut-jib:0.1 से बदलकर gcr.io/PROJECT_ID/micronaut-jib:0.2 करना होगा.

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

$ kubectl set image deployment/hello-micronaut \
          micronaut-jib=gcr.io/$GOOGLE_CLOUD_PROJECT/micronaut-jib:0.2

deployment.apps "hello-micronaut" image updated

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

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

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

$ kubectl rollout undo deployment/hello-micronaut

अगर आपने इस सेवा का आउटपुट देखा है, तो हम वापस अपने शुरुआती "नमस्ते वर्ल्ड" पर बात करेंगे दिखाई देगा.

14. खास जानकारी

इस चरण में, आपने एक आसान Apache Groovy पर आधारित माइक्रोनॉट हैलो वर्ल्ड सेवा को सेट अप किया है और इसे सीधे Cloud Shell से चलाया है. साथ ही, इसे Jib के कंटेनर के रूप में पैक किया है और Google Kubernetes Engine पर डिप्लॉय किया है.

15. बधाई हो!

आपने जाना कि Google Kubernetes Engine पर, Kubernetes पर नई Apache Groovy / Micronaut की वेब आधारित माइक्रोसेवा को बनाने और डिप्लॉय करने का क्या तरीका है.

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

लाइसेंस

इस काम को क्रिएटिव कॉमंस एट्रिब्यूशन 2.0 जेनरिक लाइसेंस के तहत लाइसेंस मिला है.