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

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

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

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

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

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

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

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

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

• तेज़ी से — बदलावों को तेज़ी से डिप्लॉय करें. Jib, आपके ऐप्लिकेशन को कई लेयर में बांटता है. साथ ही, क्लास से डिपेंडेंसी को अलग करता है. अब आपको पूरे Java ऐप्लिकेशन को फिर से बनाने के लिए, Docker का इंतज़ार नहीं करना पड़ेगा. बस उन लेयर को डिप्लॉय करें जिनमें बदलाव हुआ है.
• दोहराई जा सकने वाली — एक ही कॉन्टेंट का इस्तेमाल करके कंटेनर इमेज को फिर से बनाने पर, हमेशा एक जैसी इमेज जनरेट होती है. अब से, बिना वजह अपडेट ट्रिगर नहीं होगा.
• 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

इसके बाद, आपको "Hello World" मैसेज दिखेगा.

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

15. बधाई हो!

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

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

• 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 जेनेरिक लाइसेंस के तहत लाइसेंस मिला है.