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

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

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

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

Micronaut ये सुविधाएं देता है:

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

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

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

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

इस लैब में, Kubernetes Engine पर चल रहे Kubernetes पर, Groovy पर आधारित एक सामान्य Micronaut माइक्रोसेवा डिप्लॉय की जाती है.

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

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

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

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

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

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

Jib का लक्ष्य ये है:

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

Jib के बारे में ज़्यादा जानकारी, Github के प्रोजेक्ट पेज पर देखी जा सकती है.

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

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

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

आपको क्या सीखने को मिलेगा

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

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

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

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

सिर्फ़ इसे पढ़ें इसे पढ़ें और एक्सरसाइज़ पूरी करें

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

शुरुआती सामान्य एडवांस

Google Cloud Platform की सेवाओं को इस्तेमाल करने के अपने अनुभव को आप क्या रेटिंग देंगे?

शुरुआती सामान्य एडवांस

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

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

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 डॉलर के प्रोग्राम में शामिल हो सकते हैं.

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

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

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

अगर आपको अन्य उदाहरणों के साथ भी काम करना है, तो Jib प्रोजेक्ट रिपॉज़िटरी में Spring Boot या Vert.x जैसे अन्य फ़्रेमवर्क के लिए भी सैंपल प्रोजेक्ट मौजूद हैं.

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

हमारी Micronaut की सामान्य सेवा में एक कंट्रोलर होता है, जो Hello World मैसेज दिखाता है:

@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"
    }
}

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

जांच करने के लिए, यह कमांड चलाएं. इससे आपको पता चलेगा कि सब कुछ ठीक है या नहीं:

./gradlew test

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

Micronaut सेवा को सामान्य तरीके से शुरू करने के लिए, इस Gradle कमांड का इस्तेमाल करें:

$ ./gradlew run

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

$ 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

Jib, अलग-अलग लेयर वाली Docker इमेज बनाता है: आपकी डिपेंडेंसी के लिए, आपके संसाधनों के लिए, और आपके कंपाइल किए गए कोड के लिए. उदाहरण के लिए, अगर आपने अपने कोड में बदलाव किया है, तो सिर्फ़ आपकी कंपाइल की गई क्लास वाली लेयर में बदलाव किया जाएगा. इससे, पहले से मौजूद लेयर का फिर से इस्तेमाल करके, बिल्ड करने में लगने वाला समय बचाया जा सकेगा.

अब हमारी इमेज बन गई है. आइए, 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 कमांड लॉन्च कर सकते हैं. इससे यह देखा जा सकेगा कि यह उम्मीद के मुताबिक काम कर रही है या नहीं:

$ curl localhost:8080/hello
Hello World

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

7. कंटेनर वाली सेवा को रजिस्ट्री में पुश करना

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

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

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

$ 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, Docker को कॉन्फ़िगर और अनुमति देता है, ताकि वह Container Registry के आपके इंस्टेंस में इमेज पुश कर सके. साथ ही, इमेज को टैग कर सके, ताकि वह रजिस्ट्री में उसकी जगह पर पॉइंट कर सके. इसके बाद, वह इमेज को रजिस्ट्री में पुश कर सके.

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

ध्यान दें कि यहां हमने रजिस्ट्री के लिए सामान्य डोमेन (gcr.io) का इस्तेमाल किया है. हालांकि, आपके पास यह तय करने का विकल्प भी होता है कि किस ज़ोन और बकेट का इस्तेमाल करना है. इस बारे में ज़्यादा जानकारी यहां दी गई है: https://cloud.google.com/container-registry/docs/#pushing_to_the_registry

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

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

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

$ 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

इसके अलावा, ऊपर दिखाई गई Console के ज़रिए भी यह क्लस्टर बनाया जा सकता है: Compute > Kubernetes Engine > कंटेनर क्लस्टर > कंटेनर क्लस्टर बनाएं.

आपके पास क्लस्टर को किसी दूसरे ज़ोन में बनाने का विकल्प होता है. हालांकि, हमारा सुझाव है कि इसे उसी क्षेत्र में बनाया जाए जहां कंटेनर रजिस्ट्री के लिए इस्तेमाल किया गया स्टोरेज बकेट मौजूद है. इसके बारे में पिछले चरण में बताया गया है.

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

अब समय आ गया है कि आप अपने कंटेनर वाले ऐप्लिकेशन को Kubernetes क्लस्टर में डिप्लॉय करें! अब आपको kubectl कमांड लाइन का इस्तेमाल करना होगा. यह आपके Cloud Shell एनवायरमेंट में पहले से ही सेट अप है. इस कोडलैब के बाकी हिस्सों के लिए, 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 से, पॉड को सार्वजनिक इंटरनेट पर उपलब्ध कराया जा सकता है. इसके लिए, kubectl expose कमांड के साथ --type=LoadBalancer फ़्लैग का इस्तेमाल करें. बाहर से ऐक्सेस किए जा सकने वाले आईपी पते को बनाने के लिए, इस फ़्लैग की ज़रूरत होती है :

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

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

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

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

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

/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 कमांड का इस्तेमाल करके, Kubernetes से अपने ऐप्लिकेशन के नए वर्शन को पूरे क्लस्टर में एक-एक करके डिप्लॉय करने के लिए कहा जा सकता है. इसके लिए, रोलिंग अपडेट का इस्तेमाल किया जाता है:

$ 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 पर आधारित Micronaut की Hello World सेवा सेट अप की और उसे सीधे Cloud Shell से चलाया. इसके बाद, आपने उसे Jib की मदद से कंटेनर के तौर पर पैकेज किया और Google Kubernetes Engine पर डिप्लॉय किया.

15. बधाई हो!

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

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

• Jib के दस्तावेज़ और सैंपल: https://github.com/GoogleContainerTools/jib/
• Micronaut की वेबसाइट: http://micronaut.io/
• Google Cloud Platform पर Java: https://cloud.google.com/java/
• Java के उदाहरणों के लिए: https://cloud.google.com/java/samples
• Kubernetes के बारे में ज़्यादा जानकारी और पूरा ट्यूटोरियल देखने के लिए, bit.ly/k8s-lab पर जाएं. यहां आपको फ़ुल-स्टैक ऐप्लिकेशन डिप्लॉय करने के बारे में जानकारी मिलेगी.

लाइसेंस

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