इस पेज का अनुवाद Cloud Translation API से किया गया है.

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 का होस्ट किया गया वर्शन) का इस्तेमाल करने से, आपको बुनियादी इन्फ़्रास्ट्रक्चर को सेट अप करने के बजाय, Kubernetes के अनुभव पर ज़्यादा फ़ोकस करने में मदद मिलती है.

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

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

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

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

Chrome या Firefox ब्राउज़र जैसा कोई ब्राउज़र

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

इसे सिर्फ़ पढ़ें

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

Google Cloud Platform के साथ अपने अनुभव को कैसे रेटिंग दें?

शुरुआती

इंटरमीडिएट

कुशल

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

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

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

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

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

Cloud Shell शुरू करना

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

Cloud Shell चालू करें

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

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

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

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

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

यह पुष्टि करने के लिए 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`

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

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 --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 कोर वेबपेज दिखाई देगा:

यह पुष्टि करने के बाद कि ऐप्लिकेशन चल रहा है, उसे शट डाउन करने के लिए 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

साथ ही, CloudShell की वेब झलक देखने की सुविधा का फिर से फ़ायदा लें :

03-11-2015 17:20:22.png का स्क्रीनशॉट

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 सेवा के रूप में दिखाना होगा.

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

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

अब आप अपने ब्राउज़र को इस पते पर ले जाकर, सेवा तक पहुंच सकते हैं: 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 क्लस्टर की स्थिति के बारे में जानकारी देने वाला डायग्राम यहां दिया गया है:

आप अपनी सेवा को बहुत आसानी से कम भी कर सकते हैं. यहां बताया गया है कि 4 पॉड से 2 पॉड तक कैसे स्केल किया जाए.

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 .

और कंटेनर रजिस्ट्री में जाएं:

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 दस्तावेज़ में देखी जा सकती है.

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

12. Cloud Build

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

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

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

Cloud Build API चालू करने के बाद, कंटेनर बिल्डर सेवा से इमेज बनाने और उसे पुश करने के लिए, नीचे दिया गया कमांड रन किया जा सकता है:

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

इमेज अपने-आप कंटेनर रजिस्ट्री में सेव हो जाती है.

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

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

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

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

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

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

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

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

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

यहां से, लॉग का ज़्यादा विश्लेषण करने या लॉग के आधार पर सूचना देने की सुविधा सेट अप करने के लिए, लॉग को 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 कोर ऐप्लिकेशन को 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 टूल के बारे में ज़्यादा जानें.
PowerShell के लिए Cloud टूल के बारे में ज़्यादा जानें.

लाइसेंस

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