Python के साथ InsideLoop डेवलपमेंट

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

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

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

इस लैब में, आपको GCP में कंटेनर को डेवलप करने के तरीकों के बारे में जानकारी मिलेगी. जैसे:

  • नया Python स्टार्टर ऐप्लिकेशन बनाना
  • डेवलपमेंट प्रोसेस के बारे में जानें
  • CRUD के आस-पास आराम करने के लिए आसान टूल बनाएं

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

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

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

b35bf95b8bf3d5d8.png

a99b7ace416376c4.png

bd84a6d3004737c5.png

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

Cloudshell एडिटर शुरू करें

इस लैब को Google Cloud Shell Editor के साथ इस्तेमाल करने के लिए डिज़ाइन और टेस्ट किया गया था. एडिटर को ऐक्सेस करने के लिए,

  1. https://console.cloud.google.com पर जाकर, अपना Google प्रोजेक्ट ऐक्सेस करें.
  2. सबसे ऊपर दाएं कोने में मौजूद, Cloud Shell एडिटर आइकॉन पर क्लिक करें

8560cc8d45e8c112.png

  1. आपकी विंडो के सबसे नीचे एक नया पैनल खुलेगा
  2. 'एडिटर' बटन पर क्लिक करें

9e504cb98a6a8005.png

  1. इसके बाद, दाईं ओर एक एक्सप्लोरर और बीच वाले हिस्से में एडिटर खुलेगा
  2. स्क्रीन के सबसे नीचे टर्मिनल पैनल भी उपलब्ध होना चाहिए
  3. अगर टर्मिनल खुला नहीं है, तो नई टर्मिनल विंडो खोलने के लिए `ctrl+`` के कुंजी कॉम्बिनेशन का इस्तेमाल करें

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

Cloud Shell में, अपना प्रोजेक्ट आईडी और अपने प्रोजेक्ट का प्रोजेक्ट नंबर सेट करें. उन्हें PROJECT_ID और PROJECT_ID वैरिएबल के तौर पर सेव करें.

export PROJECT_ID=$(gcloud config get-value project)
export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID \
    --format='value(projectNumber)')

सोर्स कोड पाना

  1. इस लैब का सोर्स कोड, GitHub पर GoogleCloudPlatform में कंटेनर-developer-वर्कशॉप में मौजूद है. नीचे दिए गए निर्देश से इसे क्लोन करें और फिर डायरेक्ट्री में बदलें.
git clone https://github.com/GoogleCloudPlatform/container-developer-workshop.git &&
cd container-developer-workshop/labs/python
mkdir music-service && cd music-service 
cloudshell workspace .

अगर टर्मिनल खुला नहीं है, तो नई टर्मिनल विंडो खोलने के लिए `ctrl+`` के कुंजी कॉम्बिनेशन का इस्तेमाल करें

इस लैब में इस्तेमाल किए जा रहे इन्फ़्रास्ट्रक्चर का प्रावधान करें

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

../setup.sh

3. नया Python स्टार्टर ऐप्लिकेशन बनाएं

  1. requirements.txt नाम की एक फ़ाइल बनाएं और यहां दिए गए कॉन्टेंट को उसमें कॉपी करें
Flask
gunicorn
google-cloud-spanner
ptvsd==4.3.2
  1. app.py नाम की एक फ़ाइल बनाएं और उसमें यह कोड चिपकाएं
import os
from flask import Flask, request, jsonify
from google.cloud import spanner

app = Flask(__name__)

@app.route("/")
def hello_world():
    message="Hello, World!"
    return message

if __name__ == '__main__':
    server_port = os.environ.get('PORT', '8080')
    app.run(debug=False, port=server_port, host='0.0.0.0')
  1. Dockerfile नाम की एक फ़ाइल बनाएं और उसमें इन्हें चिपकाएं
FROM python:3.8
ARG FLASK_DEBUG=0
ENV FLASK_DEBUG=$FLASK_DEBUG
ENV FLASK_APP=app.py
WORKDIR /app
COPY requirements.txt .
RUN pip install --trusted-host pypi.python.org -r requirements.txt
COPY . .
ENTRYPOINT ["python3", "-m", "flask", "run", "--port=8080", "--host=0.0.0.0"]

ध्यान दें: FLASK_DEBUG=1 आपको Python फ़्लास्क ऐप्लिकेशन में, कोड में हुए बदलावों को अपने-आप फिर से लोड करने की सुविधा देता है. इस Dockerfile की मदद से, इस वैल्यू को बिल्ड आर्ग्युमेंट के तौर पर पास किया जा सकता है.

मेनिफ़ेस्ट जनरेट करें

अपने टर्मिनल में, डिफ़ॉल्ट skaffold.yaml और डिप्लॉयमेंट.yaml मोड को जनरेट करने के लिए इस कमांड को एक्ज़ीक्यूट करें

  1. नीचे दिए गए निर्देश से, स्केलोल्ड को शुरू करें
skaffold init --generate-manifests

जब आपसे कहा जाए, तब कर्सर को एक से दूसरी जगह ले जाने के लिए ऐरो का इस्तेमाल करें. साथ ही, विकल्पों को चुनने के लिए स्पेसबार का इस्तेमाल करें.

चुनें:

  • पोर्ट के लिए 8080
  • कॉन्फ़िगरेशन सेव करने के लिए y

स्केलोल्ड कॉन्फ़िगरेशन अपडेट करें

  • ऐप्लिकेशन का डिफ़ॉल्ट नाम बदलना
  • skaffold.yaml खोलें
  • इमेज के उस नाम को चुनें जो फ़िलहाल dockerfile-image के तौर पर सेट है
  • राइट क्लिक करें और 'सभी घटनाएं बदलें' को चुनें
  • नया नाम, python-app के तौर पर लिखें
  • बिल्ड सेक्शन में और बदलाव करके
  • FLASK_DEBUG=1 पास करने के लिए docker.buildArgs जोड़ें
  • IDE से चल रहे कंटेनर तक, *.py फ़ाइलों में किए गए किसी भी बदलाव को लोड करने के लिए सेटिंग सिंक करें

बदलावों के बाद, skaffold.yaml फ़ाइल में बिल्ड सेक्शन कुछ ऐसा दिखेगा:

build:
 artifacts:
 - image: python-app
   docker:
     buildArgs:
       FLASK_DEBUG: 1
     dockerfile: Dockerfile
   sync:
     infer:
     - '**/*.py'

Kubernetes कॉन्फ़िगरेशन फ़ाइल में बदलाव करें

  1. डिफ़ॉल्ट नाम बदलना
  • deployment.yaml फ़ाइल खोलें
  • इमेज के उस नाम को चुनें जो फ़िलहाल dockerfile-image के तौर पर सेट है
  • राइट क्लिक करें और 'सभी घटनाएं बदलें' को चुनें
  • नया नाम, python-app के तौर पर लिखें

4. डेवलपमेंट प्रोसेस की जानकारी

कारोबारी लॉजिक को जोड़कर अब अपने ऐप्लिकेशन को डिप्लॉय और टेस्ट किया जा सकता है. नीचे दिए गए सेक्शन में, Cloud Code प्लगिन के इस्तेमाल के बारे में बताया जाएगा. इसके अलावा, यह प्लगिन आपकी डेवलपमेंट प्रोसेस को आसान बनाने के लिए skaffold के साथ इंटिग्रेट होता है. जब इन चरणों को GKE (जीकेई) पर डिप्लॉय किया जाता है, तो Cloud Code और Skaffold, आपके कंटेनर की इमेज अपने-आप बनाएंगे, उसे कंटेनर रजिस्ट्री में पुश करेंगे, और आपके ऐप्लिकेशन को GKE (जीकेई) पर डिप्लॉय कर देंगे. ऐसा, पर्दे के पीछे की गतिविधियों और डेवलपर फ़्लो से जुड़ी जानकारी को समझकर किया जा सकता है.

Kubernetes में डिप्लॉय करें

  1. Cloud Shell Editor में सबसे नीचे मौजूद पैनल में, Cloud Code फ़ाॅर्म चुनें

fdc797a769040839.png

  1. सबसे ऊपर दिखने वाले पैनल में, Kubernetes पर चलाएं को चुनें.. अगर पूछा जाए, तो मौजूदा Kubernetes संदर्भ इस्तेमाल करने के लिए 'हां' चुनें.

cfce0d11ef307087.png

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

  1. पहली बार निर्देश चलाने पर स्क्रीन के सबसे ऊपर एक प्रॉम्प्ट दिखेगा, जिसमें पूछा जाएगा कि क्या आपको मौजूदा kubernetes कॉन्टेक्स्ट चाहिए या नहीं. इसके लिए, "हां" चुनें और उसका इस्तेमाल मौजूदा संदर्भ के तौर पर करें.
  2. इसके बाद एक प्रॉम्प्ट दिखेगा, जिसमें पूछा जाएगा कि किस कंटेनर रजिस्ट्री का इस्तेमाल करना है. दी गई डिफ़ॉल्ट वैल्यू को स्वीकार करने के लिए, Enter दबाएं
  3. प्रोग्रेस और सूचनाएं देखने के लिए, सबसे नीचे मौजूद पैनल में आउटपुट टैब चुनें

f95b620569ba96c5.png

  1. "Kubernetes: रन/डीबग - ज़्यादा जानकारी" चुनें अतिरिक्त विवरण और कंटेनर से लाइव स्ट्रीमिंग लॉग देखने के लिए दाईं ओर दिए गए चैनल ड्रॉप-डाउन में

94acdcdda6d2108.png

बिल्ड और टेस्ट पूरे होने के बाद, आउटपुट टैब में Attached debugger to container "python-app-8476f4bbc-h6dsl" successfully. दिखता है और यूआरएल http://localhost:8080 सूची में शामिल होता है.

  1. Cloud Code टर्मिनल में, आउटपुट में मौजूद पहले यूआरएल (http://localhost:8080) पर कर्सर घुमाएं. इसके बाद, दिखने वाले टूल टिप में 'वेब झलक खोलें' चुनें.
  2. एक नया ब्राउज़र टैब खुलेगा और Hello, World! मैसेज दिखेगा

फिर से लोड करें

  1. app.py फ़ाइल खोलें
  2. वेलकम मैसेज को Hello from Python में बदलें

ध्यान दें कि Output विंडो Kubernetes: Run/Debug व्यू में, वॉचर अपडेट की गई फ़ाइलों को Kubernetes के कंटेनर के साथ सिंक करता है

Update initiated
Build started for artifact python-app
Build completed for artifact python-app

Deploy started
Deploy completed

Status check started
Resource pod/python-app-6f646ffcbb-tn7qd status updated to In Progress
Resource deployment/python-app status updated to In Progress
Resource deployment/python-app status completed successfully
Status check succeeded
...
  1. Kubernetes: Run/Debug - Detailed व्यू पर स्विच करने पर, यह दिखेगा कि ऐप्लिकेशन में किए गए बदलावों की पहचान करने के बाद, यह ऐप्लिकेशन को बनाता और फिर से डिप्लॉय करता है
files modified: [app.py]
Syncing 1 files for gcr.io/veer-pylab-01/python-app:3c04f58-dirty@sha256:a42ca7250851c2f2570ff05209f108c5491d13d2b453bb9608c7b4af511109bd
Copying files:map[app.py:[/app/app.py]]togcr.io/veer-pylab-01/python-app:3c04f58-dirty@sha256:a42ca7250851c2f2570ff05209f108c5491d13d2b453bb9608c7b4af511109bd
Watching for changes...
[python-app] * Detected change in '/app/app.py', reloading
[python-app] * Restarting with stat
[python-app] * Debugger is active!
[python-app] * Debugger PIN: 744-729-662
  1. अपडेट किए गए नतीजे देखने के लिए, अपना ब्राउज़र रीफ़्रेश करें.

डीबग करना

  1. डीबग व्यू पर जाएं और मौजूदा थ्रेड 647213126d7a4c7b.png को रोकें.
  2. ऐप्लिकेशन को debug मोड में चलाने के लिए, सबसे नीचे मौजूद मेन्यू में Cloud Code पर क्लिक करें और Debug on Kubernetes को चुनें.
  • Output विंडो के Kubernetes Run/Debug - Detailed व्यू में, ध्यान दें कि skaffold, इस ऐप्लिकेशन को डीबग मोड में डिप्लॉय करेगा.
  1. पहली बार इस प्रॉम्प्ट को चलाने पर, आपसे पूछा जाएगा कि कंटेनर के अंदर सोर्स कहां है. यह वैल्यू Dockerfile में मौजूद डायरेक्ट्री से जुड़ी है.

डिफ़ॉल्ट सहमति को स्वीकार करने के लिए Enter दबाएं

583436647752e410.png

ऐप्लिकेशन को बनाने और डिप्लॉय करने में कुछ मिनट लगेंगे.

  1. प्रोसेस पूरी होने के बाद. आपको एक डीबगर अटैच दिखेगा.
Port forwarding pod/python-app-8bd64cf8b-cskfl in namespace default, remote port 5678 -> http://127.0.0.1:5678
  1. सबसे नीचे मौजूद स्टेटस बार का रंग नीले से नारंगी रंग में बदल जाता है. इससे पता चलता है कि यह डीबग मोड में है.
  2. Kubernetes Run/Debug व्यू में, देखें कि डीबग किया जा सकने वाला कंटेनर शुरू हो गया है
**************URLs*****************
Forwarded URL from service python-app: http://localhost:8080
Debuggable container started pod/python-app-8bd64cf8b-cskfl:python-app (default)
Update succeeded
***********************************

ब्रेकपॉइंट इस्तेमाल करें

  1. app.py फ़ाइल खोलें
  2. return message वाला स्टेटमेंट ढूंढें
  3. लाइन नंबर की बाईं ओर मौजूद खाली जगह पर क्लिक करके, उस लाइन में एक ब्रेकपॉइंट जोड़ें. ब्रेकपॉइंट सेट होने का पता लगाने के लिए, लाल रंग का इंंडिकेटर दिखेगा
  4. अपने ब्राउज़र को फिर से लोड करें और ध्यान दें कि डीबगर, ब्रेकपॉइंट पर प्रोसेस को रोक देता है. साथ ही, इससे आपको GKE (जीकेई) में रिमोट तरीके से चल रहे ऐप्लिकेशन के वैरिएबल और स्थिति की जांच करने की अनुमति मिलती है
  5. 'वैरिएबल' सेक्शन में नीचे की ओर क्लिक करें
  6. वहां मौजूद 'स्थानीय' पर क्लिक करने पर आपको "message" वैरिएबल दिखेगा.
  7. वैरिएबल के नाम "मैसेज" पर दो बार क्लिक करें और पॉप-अप में, वैल्यू को बदलकर "Greetings from Python" जैसा कुछ करें
  8. डीबग कंट्रोल पैनल में 'जारी रखें' बटन पर क्लिक करें 607c33934f8d6b39.png
  9. अपने ब्राउज़र में उस जवाब की समीक्षा करें जो अब आपकी डाली गई अपडेट की गई वैल्यू दिखाता है.
  10. "डीबग" बंद करना मोड चालू करने के लिए, 'रोकें' बटन 647213126d7a4c7b.png को दबाएं. इसके बाद, ब्रेकपॉइंट पर फिर से क्लिक करके ब्रेकपॉइंट हटाएं.

5. सीआरयूडी के लिए आसान रेस्ट सर्विस डेवलप करना

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

बाकी सेवा को कोड करें

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

  1. app.py को नीचे दिए गए कॉन्टेंट से बदलकर मुख्य ऐप्लिकेशन बनाएं
import os
from flask import Flask, request, jsonify
from google.cloud import spanner


app = Flask(__name__)


instance_id = "music-catalog"

database_id = "musicians"

spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)


@app.route("/")
def hello_world():
    return "<p>Hello, World!</p>"

@app.route('/singer', methods=['POST'])
def create():
    try:
        request_json = request.get_json()
        singer_id = request_json['singer_id']
        first_name = request_json['first_name']
        last_name = request_json['last_name']
        def insert_singers(transaction):
            row_ct = transaction.execute_update(
                f"INSERT Singers (SingerId, FirstName, LastName) VALUES" \
                f"({singer_id}, '{first_name}', '{last_name}')"
            )
            print("{} record(s) inserted.".format(row_ct))

        database.run_in_transaction(insert_singers)

        return {"Success": True}, 200
    except Exception as e:
        return e



@app.route('/singer', methods=['GET'])
def get_singer():

    try:
        singer_id = request.args.get('singer_id')
        def get_singer():
            first_name = ''
            last_name = ''
            with database.snapshot() as snapshot:
                results = snapshot.execute_sql(
                    f"SELECT SingerId, FirstName, LastName FROM Singers " \
                    f"where SingerId = {singer_id}",
                    )
                for row in results:
                    first_name = row[1]
                    last_name = row[2]
                return (first_name,last_name )
        first_name, last_name = get_singer()  
        return {"first_name": first_name, "last_name": last_name }, 200
    except Exception as e:
        return e


@app.route('/singer', methods=['PUT'])
def update_singer_first_name():
    try:
        singer_id = request.args.get('singer_id')
        request_json = request.get_json()
        first_name = request_json['first_name']
        
        def update_singer(transaction):
            row_ct = transaction.execute_update(
                f"UPDATE Singers SET FirstName = '{first_name}' WHERE SingerId = {singer_id}"
            )

            print("{} record(s) updated.".format(row_ct))

        database.run_in_transaction(update_singer)
        return {"Success": True}, 200
    except Exception as e:
        return e


@app.route('/singer', methods=['DELETE'])
def delete_singer():
    try:
        singer_id = request.args.get('singer')
    
        def delete_singer(transaction):
            row_ct = transaction.execute_update(
                f"DELETE FROM Singers WHERE SingerId = {singer_id}"
            )
            print("{} record(s) deleted.".format(row_ct))

        database.run_in_transaction(delete_singer)
        return {"Success": True}, 200
    except Exception as e:
        return e

port = int(os.environ.get('PORT', 8080))
if __name__ == '__main__':
    app.run(threaded=True, host='0.0.0.0', port=port)

डेटाबेस कॉन्फ़िगरेशन जोड़ें

Spanner से सुरक्षित रूप से कनेक्ट करने के लिए, वर्कलोड आईडी का इस्तेमाल करने के लिए ऐप्लिकेशन को सेट अप करें. इससे, आपका ऐप्लिकेशन अपने सेवा खाते के तौर पर काम करता है. साथ ही, डेटाबेस को ऐक्सेस करते समय, उसे अलग-अलग अनुमतियां मिलती हैं.

  1. deployment.yaml अपडेट करें. फ़ाइल के अंत में निम्न कोड जोड़ें (पक्का करें कि आप नीचे दिए गए उदाहरण में टैब इंडेंट रखें)
      serviceAccountName: python-ksa
      nodeSelector:
        iam.gke.io/gke-metadata-server-enabled: "true"

ऐप्लिकेशन डिप्लॉय करें और उसकी पुष्टि करें

  1. क्लाउड शेल एडिटर में सबसे नीचे मौजूद पैनल में, Cloud Code को चुनें. इसके बाद, स्क्रीन पर सबसे ऊपर मौजूद Debug on Kubernetes को चुनें.
  2. बिल्ड और टेस्ट हो जाने के बाद, आउटपुट टैब में यह मैसेज दिखता है: Resource deployment/python-app status completed successfully और एक यूआरएल दिखता है: "service Python-app से फ़ॉरवर्ड किया गया यूआरएल: http://localhost:8080"
  3. कुछ एंट्री जोड़ें.

Cloud Shell Terminal से, नीचे दिए गए निर्देश को चलाएं

curl -X POST http://localhost:8080/singer -H 'Content-Type: application/json' -d '{"first_name":"Cat","last_name":"Meow", "singer_id": 6}'
  1. टर्मिनल में नीचे दिए गए निर्देश को चलाकर, जीईटी की जांच करें
curl -X GET http://localhost:8080/singer?singer_id=6
  1. परीक्षण हटाएं: अब निम्न आदेश चलाकर किसी प्रविष्टि को हटाने का प्रयास करें. अगर ज़रूरी हो, तो item-id की वैल्यू बदलें.
curl -X DELETE http://localhost:8080/singer?singer_id=6

    This throws an error message

500 Internal Server Error

समस्या की पहचान करना और उसे ठीक करना

  1. डीबग मोड में जाएं और समस्या का पता लगाएं. इसके लिए, यहां कुछ सुझाव दिए गए हैं:
  • हमें पता है कि DELETE में कुछ गड़बड़ी है, क्योंकि यह मनचाहा नतीजा नहीं दे रहा है. इसलिए, आपको delete_singer तरीके में, app.py में ब्रेकपॉइंट सेट करना होगा.
  • सिलसिलेवार तरीके से एक्ज़ीक्यूट करने की सुविधा चालू करें और बाईं विंडो में लोकल वैरिएबल की वैल्यू देखने के लिए, हर चरण पर वैरिएबल देखें.
  • singer_id और request.args जैसी खास वैल्यू देखने के लिए, इन वैरिएबल को वॉच विंडो में जोड़ें.
  1. ध्यान दें कि singer_id के लिए असाइन की गई वैल्यू None है. समस्या ठीक करने के लिए कोड बदलें.

तय कोड स्निपेट ऐसा दिखेगा.

@app.route('/delete-singer', methods=['DELETE', 'GET'])
def delete_singer():
    try:
        singer_id = request.args.get('singer_id')
  1. एक बार ऐप्लिकेशन के रीस्टार्ट होने पर, उसे मिटाने की कोशिश करके दोबारा जांच करें.
  2. डीबग टूलबार में लाल रंग के स्क्वेयर पर क्लिक करके, डीबग करने वाले सेशन को रोकें 647213126d7a4c7b.png

6. साफ़-सफ़ाई सेवा

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

लैब पूरा होने के बाद, स्टोरेज खाली करने के लिए:

  1. लैब में इस्तेमाल की गई फ़ाइलें मिटाना
cd ~ && rm -rf container-developer-workshop
  1. प्रोजेक्ट को मिटाएं, ताकि उससे जुड़े सभी इन्फ़्रास्ट्रक्चर और संसाधनों को हटाया जा सके