Google Kubernetes Engine पर, Kubernetes में ASP.NET कोर ऐप्लिकेशन डिप्लॉय करें

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

ASP.NET Core एक नया ओपन-सोर्स और क्रॉस-प्लैटफ़ॉर्म फ़्रेमवर्क है. इसकी मदद से, C# प्रोग्रामिंग भाषा का इस्तेमाल करके, क्लाउड पर आधारित और इंटरनेट से कनेक्ट किए गए आधुनिक ऐप्लिकेशन बनाए जा सकते हैं.

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

इस लैब में, आपको Kubernetes Engine पर चल रहे Kubernetes पर, एक सामान्य ASP.NET Core ऐप्लिकेशन डिप्लॉय करना है. यह कोडलैब, Google Cloud Shell से ASP.NET Core ऐप्लिकेशन बनाएं और लॉन्च करें कोडलैब पर आधारित है. इस लैब को आज़माने से पहले, आपको वह लैब आज़मानी चाहिए.

इस कोडलैब का मकसद यह है कि आप अपने कोड (यहां एक सामान्य Hello World ASP.NET Core ऐप्लिकेशन) को Kubernetes पर चलने वाले रेप्लिका ऐप्लिकेशन में बदलें. आपने अपनी मशीन पर जो कोड बनाया है उसे Docker कंटेनर इमेज में बदला जाता है. इसके बाद, उस इमेज को Google Kubernetes Engine पर चलाया जाता है.

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

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

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

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

• किसी सामान्य ASP.NET Core ऐप्लिकेशन को Docker कंटेनर के तौर पर पैकेज करने का तरीका.
• Google Kubernetes Engine (GKE) पर Kubernetes क्लस्टर बनाने का तरीका.
• ASP.NET Core ऐप्लिकेशन को पॉड पर डिप्लॉय करने का तरीका.
• अपने पॉड में बाहरी ट्रैफ़िक की अनुमति कैसे दें.
• अपनी सेवा को बड़े पैमाने पर उपलब्ध कराने और अपग्रेड को रोल आउट करने का तरीका.
• Kubernetes के ग्राफ़िकल डैशबोर्ड को चलाने का तरीका.

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

• कोई ब्राउज़र, जैसे कि Chrome या Firefox

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

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

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

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

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

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

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

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

चेतावनी: प्रोजेक्ट आईडी, दुनिया भर में यूनीक होना चाहिए. इसे चुनने के बाद, कोई और इसका इस्तेमाल नहीं कर सकता. उस आईडी का इस्तेमाल सिर्फ़ आपने किया हो. किसी प्रोजेक्ट को मिटाने के बाद भी, आईडी का फिर से इस्तेमाल नहीं किया जा सकता

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

2. इसके बाद, आपको Cloud Console में बिलिंग चालू करनी होगी, ताकि Cloud संसाधनों/एपीआई का इस्तेमाल किया जा सके. इस कोडलैब को पूरा करने में ज़्यादा खर्च नहीं आएगा. इस ट्यूटोरियल के बाद बिलिंग से बचने के लिए, बनाए गए संसाधनों को बंद किया जा सकता है. इसके लिए, बनाए गए संसाधनों को मिटाएं या पूरे प्रोजेक्ट को मिटाएं. Google Cloud के नए उपयोगकर्ताओं को, मुफ़्त में आज़माने के लिए 300 डॉलर का क्रेडिट मिलता है.

Cloud Shell शुरू करें

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

Cloud Shell चालू करें

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

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

Cloud Shell से कनेक्ट होने में कुछ ही सेकंड लगेंगे.

इस वर्चुअल मशीन में, डेवलपमेंट के लिए ज़रूरी सभी टूल पहले से मौजूद होते हैं. यह 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 कमांड-लाइन टूल की खास जानकारी देखें.

3. यह पुष्टि करने के लिए कि gcloud कमांड को आपके प्रोजेक्ट के बारे में पता है, Cloud Shell में यह कमांड चलाएं:

gcloud config list project

कमांड आउटपुट

[core]
project = <PROJECT_ID>

अगर ऐसा नहीं है, तो इस कमांड का इस्तेमाल करके इसे सेट किया जा सकता है:

gcloud config set project <PROJECT_ID>

कमांड आउटपुट

Updated property [core/project].

3. Cloud Shell में ASP.NET Core ऐप्लिकेशन बनाना

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

dotnet --version

इसके बाद, नया ASP.NET Core वेब ऐप्लिकेशन बनाएं.

dotnet new mvc -o HelloWorldAspNetCore

इससे एक प्रोजेक्ट बन जाएगा और उसकी डिपेंडेंसी वापस आ जाएंगी. आपको नीचे दिए गए मैसेज जैसा कोई मैसेज दिखेगा.

Restore completed in 11.44 sec for HelloWorldAspNetCore.csproj.

Restore succeeded.

4. ASP.NET Core ऐप्लिकेशन चलाना

हमारा ऐप्लिकेशन लॉन्च होने के लिए तैयार है. ऐप्लिकेशन फ़ोल्डर पर जाएं.

cd HelloWorldAspNetCore

आखिर में, ऐप्लिकेशन चलाएं.

dotnet run --urls=http://localhost:8080

ऐप्लिकेशन, पोर्ट 8080 पर सुनना शुरू कर देता है.

Hosting environment: Production
Content root path: /home/atameldev/HelloWorldAspNetCore
Now listening on: http://[::]:8080
Application started. Press Ctrl+C to shut down.

यह पुष्टि करने के लिए कि ऐप्लिकेशन चल रहा है, सबसे ऊपर दाईं ओर मौजूद वेब प्रीव्यू बटन पर क्लिक करें. इसके बाद, ‘पोर्ट 8080 पर झलक देखें’ को चुनें.

आपको डिफ़ॉल्ट ASP.NET Core वेबपेज दिखेगा:

ऐप्लिकेशन के चालू होने की पुष्टि करने के बाद, ऐप्लिकेशन को बंद करने के लिए Ctrl+C दबाएं.

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

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

ऐप्लिकेशन की बेस डायरेक्ट्री में, Docker इमेज तय करने के लिए Dockerfile बनाएं.

touch Dockerfile

अपने पसंदीदा एडिटर (vim, nano,emacs या Cloud Shell का कोड एडिटर) का इस्तेमाल करके, Dockerfile में यह जोड़ें.

# Use Microsoft's official build .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-sdk/
FROM mcr.microsoft.com/dotnet/sdk:6.0-alpine AS build
WORKDIR /app

# Install production dependencies.
# Copy csproj and restore as distinct layers.
COPY *.csproj ./
RUN dotnet restore

# Copy local code to the container image.
COPY . ./
WORKDIR /app

# Build a release artifact.
RUN dotnet publish -c Release -o out

# Use Microsoft's official runtime .NET image.
# https://hub.docker.com/_/microsoft-dotnet-core-aspnet/
FROM mcr.microsoft.com/dotnet/aspnet:6.0-alpine-amd64 AS runtime
WORKDIR /app
COPY --from=build /app/out ./

# Make sure the app binds to port 8080
ENV ASPNETCORE_URLS http://*:8080

# Run the web service on container startup.
ENTRYPOINT ["dotnet", "HelloWorldAspNetCore.dll"]

आपके Dockerfile में शामिल एक अहम कॉन्फ़िगरेशन, वह पोर्ट है जिस पर ऐप्लिकेशन, इनकमिंग ट्रैफ़िक (8080) को सुनता है. इसके लिए, ASPNETCORE_URLS एनवायरमेंट वैरिएबल सेट किया जाता है. ASP.NET Core ऐप्लिकेशन इसका इस्तेमाल यह तय करने के लिए करते हैं कि किस पोर्ट पर सुनना है.

इस Dockerfile को सेव करें. अब, इमेज बनाते हैं:

docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 .

यह प्रोसेस पूरी होने के बाद, आपको दिखेगा कि इमेज बन गई है और इसे लोकल तौर पर सेव कर लिया गया है:

docker images

REPOSITORY                             TAG   
gcr.io/yourproject-XXXX/hello-dotnet   v1            

इमेज को स्थानीय तौर पर टेस्ट करने के लिए, यह कमांड डालें. इससे, आपकी बनाई गई नई कंटेनर इमेज से पोर्ट 8080 पर, Docker कंटेनर स्थानीय तौर पर चलेगा:

docker run -p 8080:8080 gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1

इसके बाद, Cloud Shell की वेब झलक सुविधा का फिर से इस्तेमाल करें :

आपको नए टैब में डिफ़ॉल्ट ASP.NET Core वेबपेज दिखेगा.

जब आपको यह पता चल जाए कि ऐप्लिकेशन, Docker कंटेनर में स्थानीय तौर पर ठीक से चल रहा है, तब Ctrl-> C पर जाकर, चल रहे कंटेनर को बंद किया जा सकता है.

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

docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1

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

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

अगर आपको कंटेनर इमेज के बारे में ज़्यादा जानना है, तो इस लिंक पर जाकर उन्हें ब्राउज़ करें: https://console.cloud.google.com/storage/browser/. ये इमेज, Google Cloud Storage में सेव होती हैं. (पूरा लिंक इस तरह का होना चाहिए: https://console.cloud.google.com/project/PROJECT_ID/storage/browser/).

6. Kubernetes क्लस्टर बनाना

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

क्लस्टर में, Google की ओर से मैनेज किया जाने वाला Kubernetes मास्टर एपीआई सर्वर और वर्कर नोड का एक सेट होता है. वर्कर नोड, Compute Engine वर्चुअल मशीनें होती हैं.

आइए, क्लस्टर बनाने के लिए CloudShell सेशन में gcloud CLI का इस्तेमाल करें. अपने ज़ोन को अपने आस-पास की किसी जगह पर सेट करें ( ज़ोन की सूची). इस प्रोसेस को पूरा होने में कुछ मिनट लगेंगे:

gcloud container clusters create hello-dotnet-cluster --cluster-version=latest --num-nodes 4 --zone europe-west1-b

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

Creating cluster hello-dotnet-cluster...done.
Created [https://container.googleapis.com/v1/projects/dotnet-atamel/zones/europe-west1-b/clusters/hello-dotnet-cluster].
kubeconfig entry generated for hello-dotnet-cluster.
NAME                  ZONE            MASTER_VERSION  
hello-dotnet-cluster  europe-west1-b  1.10.7-gke.6

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

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

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

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

7. डिप्लॉयमेंट की सूची बनाएं

Kubernetes pod, कंटेनर का एक ग्रुप होता है. इसे एडमिनिस्ट्रेशन और नेटवर्किंग के लिए एक साथ जोड़ा जाता है. इसमें एक या एक से ज़्यादा कंटेनर हो सकते हैं. यहां आपको सिर्फ़ एक ऐसे कंटेनर का इस्तेमाल करना होगा जिसे आपकी निजी कंटेनर रजिस्ट्री में सेव की गई ASP.NET Core इमेज से बनाया गया है. यह पोर्ट 8080 पर कॉन्टेंट दिखाएगा.

अपने पसंदीदा एडिटर (vim, nano,emacs या Cloud Shell का कोड एडिटर) का इस्तेमाल करके, hello-dotnet.yaml फ़ाइल बनाएं. साथ ही, पॉड के लिए Kubernetes डिप्लॉयमेंट तय करें:

पक्का करें कि आपने YOUR-PROJECT-ID की जगह अपने प्रोजेक्ट का आईडी डाला हो

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: hello-dotnet
  name: hello-dotnet
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      run: hello-dotnet
  template:
    metadata:
      labels:
        run: hello-dotnet
    spec:
      containers:
      - name: hello-dotnet
        image: gcr.io/YOUR-PROJECT-ID/hello-dotnet:v1
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 8080

kubectl की मदद से, डिफ़ॉल्ट नेमस्पेस में डिप्लॉय करें:

kubectl apply -f hello-dotnet.yaml

deployment.apps/hello-dotnet created

जैसा कि आपको दिख रहा है, आपने एक डिप्लॉयमेंट ऑब्जेक्ट बनाया है. पॉड बनाने और उन्हें स्केल करने के लिए, डिप्लॉयमेंट का इस्तेमाल करने का सुझाव दिया जाता है. यहां, नया डिप्लॉयमेंट, hello-dotnet:v1 इमेज चलाने वाली एक पॉड रेप्लिका को मैनेज करता है.

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

kubectl get deployments

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   1         1         1            1           37s

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

kubectl get pods

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

अब kubectl की कुछ दिलचस्प कमांड आज़माने का सही समय है. इनमें से कोई भी कमांड, क्लस्टर की स्थिति में बदलाव नहीं करेगी. पूरा दस्तावेज़ यहां उपलब्ध है:

kubectl get pods
kubectl cluster-info
kubectl config view
kubectl get events
kubectl logs <pod-name>

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

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

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

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

kubectl expose deployment hello-dotnet --type="LoadBalancer" --port=8080

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

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

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

kubectl get services

NAME         CLUSTER-IP     EXTERNAL-IP      PORT(S)    AGE
hello-dotnet 10.3.253.62   104.155.20.69   8080/TCP    1m
kubernetes   10.3.240.1     <none>           443/TCP    5m

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

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

अब इस पते पर जाकर, सेवा को ऐक्सेस किया जा सकता है: http://<EXTERNAL_IP>:8080

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

9. बड़े पैमाने पर सेवा उपलब्ध कराना

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

kubectl scale deployment hello-dotnet --replicas=4

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

kubectl get pods
NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m
hello-dotnet-714049816-sh812   1/1       Running   0          1m
hello-dotnet-714049816-ztzrb   1/1       Running   0          16m

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

यहां एक डायग्राम दिया गया है, जिसमें आपके Kubernetes क्लस्टर की स्थिति के बारे में खास जानकारी दी गई है:

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

kubectl scale deployment hello-dotnet --replicas=2

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m

10. रेज़िलिएंस की जांच करना

Kubernetes (या ज़्यादा सटीक तौर पर ReplicaSet) आपके पॉड पर नज़र रखता है. अगर पॉड में कोई गड़बड़ी होती है और वह बंद हो जाता है, तो यह तुरंत एक नया पॉड बना देता है. आइए, इसे आज़माकर देखते हैं और देखते हैं कि यह कैसे काम करता है.

सबसे पहले, पॉड की सूची पाएं:

kubectl get pods

NAME                         READY     STATUS    RESTARTS   AGE
hello-dotnet-714049816-g4azy   1/1       Running   0          1m
hello-dotnet-714049816-rk0u6   1/1       Running   0          1m

पॉड का नाम पास करके, किसी एक पॉड को मिटाएं:

kubectl delete pod hello-dotnet-714049816-g4azy

पॉड की सूची को फिर से देखने पर, आपको दिखेगा कि एक नया पॉड बनाया जा रहा है और वह तुरंत फिर से चल रहा है:

kubectl get pods

NAME                         READY     STATUS           RESTARTS   AGE
hello-dotnet-714049816-abczy   1/1    ContainerCreating  0          1m
hello-dotnet-714049816-rk0u6   1/1    Running            0          1m

11. अपनी सेवा को अपग्रेड करना

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

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

HelloWorldAspNetCore > Views > Home में जाकर Index.cshtml पर जाएं और कैरसेल के किसी एक मैसेज को अपडेट करें.

यह लाइन ढूंढें:

Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core 

इसे बदलकर यह कर दो:

Learn about <a href="https://docs.microsoft.com/aspnet/core">building Web apps with ASP.NET Core on Google Cloud

बदलावों को सेव करें. इसके बाद, Cloud Shell पर वापस जाएं. HelloWorldAspNetCore,के अंदर, डॉकर इमेज बनाएं:

docker build -t gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 . 

इसके बाद, इसे Container Registry में पुश करें:

docker push gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 

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

अब Kubernetes, रेप्लिकेशन कंट्रोलर को ऐप्लिकेशन के नए वर्शन में आसानी से अपडेट कर सकता है. चालू कंटेनर के लिए इमेज लेबल बदलने के लिए, आपको मौजूदा hello-dotnet deployment में बदलाव करना होगा. साथ ही, इमेज को gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v1 से gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v2 में बदलना होगा.

इसके लिए, आपको kubectl edit कमांड का इस्तेमाल करना होगा. इससे एक टेक्स्ट एडिटर खुलेगा, जिसमें डिप्लॉयमेंट का पूरा YAML कॉन्फ़िगरेशन दिखेगा. फ़िलहाल, पूरे YAML कॉन्फ़िगरेशन को समझने की ज़रूरत नहीं है. इसके बजाय, बस यह समझ लें कि कॉन्फ़िगरेशन में spec.template.spec.containers.image फ़ील्ड को अपडेट करके, डिप्लॉयमेंट को पॉड अपडेट करने के लिए कहा जा रहा है, ताकि नई इमेज का इस्तेमाल किया जा सके.

kubectl edit deployment hello-dotnet

# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: apps/v1
kind: Deployment
metadata:
  annotations:
    deployment.kubernetes.io/revision: "1"
  creationTimestamp: 2017-01-06T10:05:28Z
  generation: 3
  labels:
    run: hello-dotnet
  name: hello-dotnet
  namespace: default
  resourceVersion: "151017"
  selfLink: /apis/extensions/v1beta1/namespaces/default/deployments/hello-dotnet
  uid: 981fe302-f1e9-11e5-9a78-42010af00005
spec:
  replicas: 4
  selector:
    matchLabels:
      run: hello-dotnet
  strategy:
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        run: hello-dotnet
    spec:
      containers:
      - image: gcr.io/PROJECT_ID/hello-dotnet:v1 # Update this line
        imagePullPolicy: IfNotPresent
        name: hello-dotnet
        ports:
        - containerPort: 8080
          protocol: TCP
        resources: {}
        terminationMessagePath: /dev/termination-log
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      securityContext: {}
      terminationGracePeriodSeconds: 30

बदलाव करने के बाद, फ़ाइल को सेव करें और बंद करें. इसके लिए, vi का इस्तेमाल करें. इसलिए, "Esc" दबाएं. इसके बाद, :wq टाइप करें और "Enter" कुंजी दबाएं.

deployment "hello-dotnet" edited

इससे डिप्लॉयमेंट, नई इमेज के साथ अपडेट हो जाता है. इससे नई इमेज के साथ नए पॉड बन जाते हैं और पुराने पॉड मिट जाते हैं.

kubectl get deployments

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-dotnet   4         5         4            3           1h

इस दौरान, उपयोगकर्ताओं को सेवाओं में कोई रुकावट नहीं दिखनी चाहिए. कुछ समय बाद, वे आपके ऐप्लिकेशन के नए वर्शन को ऐक्सेस कर पाएंगे.

रोलिंग अपडेट के बारे में ज़्यादा जानकारी, Kubernetes के दस्तावेज़ में देखी जा सकती है.

हमें उम्मीद है कि इन सुविधाओं की मदद से, आपको यह समझने में आसानी होगी कि Kubernetes, आपके ऐप्लिकेशन पर फ़ोकस करने में आपकी मदद कैसे कर सकता है. इसके लिए, आपको सिर्फ़ अपना एनवायरमेंट (यहां आपका GKE/Kubernetes क्लस्टर) सेट अप करना होगा.

12. Cloud Build

अब तक, हम Docker की सामान्य कमांड (docker build ...) का इस्तेमाल करके कंटेनर बना रहे थे. इसके बाद, हमने इमेज को Google Cloud Platform की Container Registry में मैन्युअल तरीके से पुश किया. दोनों चरणों को सर्वर साइड Cloud Build पर भी टाला जा सकता है. यह Docker को स्थानीय तौर पर इंस्टॉल किए बिना, कंटेनर इमेज बना सकता है और उसे पुश कर सकता है.

सबसे पहले, एपीआई मैनेजर > लाइब्रेरी में जाकर, Cloud Build API चालू करें. Cloud Build खोजें और Cloud Build API पर क्लिक करें:

अगर एपीआई पहले से चालू नहीं है, तो एपीआई चालू करें पर क्लिक करें. आखिर में, आपको एपीआई इस तरह से चालू दिखेगा:

Cloud Build API चालू होने के बाद, Container Builder सेवा से अपनी इमेज को बनाने और पुश करने के लिए, यहां दिया गया निर्देश चलाएं:

$ gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/hello-dotnet:v3

इमेज, Container Registry पर अपने-आप सेव हो जाती है.

13. Kubernetes का ग्राफ़िकल डैशबोर्ड चलाना

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

Kubernetes क्लस्टर डैशबोर्ड को ऐक्सेस करने की सुविधा कॉन्फ़िगर करने के लिए, Cloud Shell विंडो में ये कमांड टाइप करें :

gcloud container clusters get-credentials hello-dotnet-cluster \
    --zone europe-west1-b --project ${GOOGLE_CLOUD_PROJECT}

kubectl proxy --port 8081

इसके बाद, Cloud Shell की झलक वाली सुविधा का फिर से इस्तेमाल करके, पोर्ट 8081 पर जाएं:

इससे आपको एपीआई एंडपॉइंट पर भेज दिया जाएगा. आपको "अनुमति नहीं है" पेज दिख सकता है. हालांकि, इससे कोई फ़र्क़ नहीं पड़ता. डैशबोर्ड पर जाने के लिए, "?authuser=3" को हटाएं और उसकी जगह "/ui" डालें.

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

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

डैशबोर्ड का इस्तेमाल करने के बाद, प्रॉक्सी को रोकने के लिए Control + C दबाएं. डैशबोर्ड टूर लेकर, Kubernetes डैशबोर्ड के बारे में ज़्यादा जानें.

14. लॉग इन हो रहा है

Kubernetes में चल रहे कंटेनर के लॉग वापस पाने के लिए, kubectl logs कमांड का इस्तेमाल किया जा सकता है. मैनेज किए गए Kubernetes क्लस्टर को चलाने के लिए Google Kubernetes Engine का इस्तेमाल करने पर, सभी लॉग अपने-आप Google Cloud Logging में फ़ॉरवर्ड हो जाते हैं और सेव हो जाते हैं. Google Cloud Console में Stackdriver → Logging → Logs पर जाकर, पॉड से मिले सभी लॉग आउटपुट देखे जा सकते हैं:

लॉगिंग कंसोल में जाकर, GKE कंटेनर पर जाएं. यहां आपको STDOUT से इकट्ठा किए गए सभी लॉग दिखेंगे:

यहां से, लॉग का ज़्यादा विश्लेषण करने के लिए, लॉग को Google BigQuery में एक्सपोर्ट किया जा सकता है. इसके अलावा, लॉग पर आधारित सूचनाएं सेट अप की जा सकती हैं. आज लैब के दौरान, हम यह काम नहीं कर पाएँगे.

15. बधाई हो!

ASP.NET Core और Kubernetes के साथ शुरू करने के बारे में यह आसान कोडलैब यहीं खत्म होता है. हमने इस टेक्नोलॉजी के बारे में सिर्फ़ बुनियादी जानकारी दी है. हमारा सुझाव है कि आप अपने पॉड, रेप्लिकेशन कंट्रोलर, और सेवाओं के बारे में ज़्यादा जानें. साथ ही, लाइवनेस प्रोब (हेल्थ चेक) के बारे में भी जानें और Kubernetes API का सीधे तौर पर इस्तेमाल करने के बारे में सोचें.

व्यवस्थित करें

हो गया! इस्तेमाल किए गए संसाधनों को हटाने का समय आ गया है, ताकि लागत कम की जा सके और क्लाउड का बेहतर तरीके से इस्तेमाल किया जा सके.

डिप्लॉयमेंट (इससे चालू पॉड भी मिट जाते हैं) और सेवा (इससे आपका बाहरी लोड बैलेंसर भी मिट जाता है) मिटाएं:

सबसे पहले, सेवा और डिप्लॉयमेंट मिटाएं. इससे आपका बाहरी लोड बैलेंसर भी मिट जाएगा:

kubectl delete service,deployment hello-dotnet

service "hello-dotnet" deleted
deployment "hello-dotnet" deleted

इसके बाद, अपना क्लस्टर मिटाएं:

gcloud container clusters delete hello-dotnet-cluster --zone=europe-west1-b

The following clusters will be deleted.
 - [hello-dotnet-cluster] in [europe-west1-b]
Do you want to continue (Y/n)?  Y
Deleting cluster hello-dotnet-cluster...done.                                                                                                                                                                                            
Deleted [https://container.googleapis.com/v1/projects/<PROJECT_ID>/zones/europe-west1-b/clusters/hello-dotnet-cluster].

इससे Google Compute Engine के वे सभी इंस्टेंस मिट जाते हैं जो क्लस्टर को चला रहे हैं.

आखिर में, Docker रजिस्ट्री के उस स्टोरेज बकेट को मिटाएं जिसमें आपकी इमेज होस्ट की गई हैं:

gsutil ls

gs://artifacts.<PROJECT_ID>.appspot.com/

gsutil rm -r gs://artifacts.${GOOGLE_CLOUD_PROJECT}.appspot.com/
Removing gs://artifacts.<PROJECT_ID>.appspot.com/...

Removing gs://artifacts.<PROJECT_ID>.appspot.com/...

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

हमने क्या-क्या बताया

• किसी सामान्य ASP.NET Core ऐप्लिकेशन को Docker कंटेनर के तौर पर पैकेज करने का तरीका.
• Google Kubernetes Engine पर अपना Kubernetes क्लस्टर बनाने का तरीका.
• ASP.NET Core ऐप्लिकेशन को पॉड पर डिप्लॉय करने का तरीका.
• अपने पॉड में बाहरी ट्रैफ़िक की अनुमति कैसे दें.
• अपनी सेवा को बड़े पैमाने पर उपलब्ध कराने और अपग्रेड को रोल आउट करने का तरीका.
• Kubernetes के ग्राफ़िकल डैशबोर्ड को चलाने का तरीका.

अगले चरण

• Kubernetes के बारे में ज़्यादा जानें ( http://kubernetes.io/).
• Google Cloud Platform पर Windows के बारे में ज़्यादा जानें.
• Google Cloud Platform पर.NET के बारे में ज़्यादा जानें.
• Google Cloud Platform पर SQL Server के बारे में ज़्यादा जानें.
• Cloud Tools for Visual Studio के बारे में ज़्यादा जानें.
• Cloud Tools for PowerShell के बारे में ज़्यादा जानें.

लाइसेंस

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