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

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

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

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

इस लैब में, आपको 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 में बिलिंग चालू करनी होगी, ताकि Cloud संसाधनों/एपीआई का इस्तेमाल किया जा सके. इस कोडलैब को पूरा करने में ज़्यादा खर्च नहीं आएगा. संसाधन बंद करने के लिए, कोडलैब के आखिर में दिए गए "बंद करें" निर्देशों का पालन करें, ताकि इस ट्यूटोरियल के बाद आपको बिलिंग न करनी पड़े. Google Cloud के नए उपयोगकर्ताओं को, मुफ़्त में आज़माने के लिए 300 डॉलर का क्रेडिट मिलता है.

Cloud Shell Editor शुरू करना

इस लैब को 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 में container-developer-workshop में मौजूद है. नीचे दिए गए निर्देश का इस्तेमाल करके इसे क्लोन करें. इसके बाद, डायरेक्ट्री में बदलाव करें.
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 पर कोड डिप्लॉय करना होगा. साथ ही, Spanner डेटाबेस में सेव किए गए डेटा को ऐक्सेस करना होगा. नीचे दी गई सेटअप स्क्रिप्ट, आपके लिए इस इन्फ़्रास्ट्रक्चर को तैयार करती है. इस कॉन्फ़िगरेशन को जोड़ने में 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 और deployment.yaml जनरेट करने के लिए, अपने टर्मिनल में यह कमांड चलाएं

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

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

चुनें:

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

Skaffold कॉन्फ़िगरेशन अपडेट करना

  • डिफ़ॉल्ट ऐप्लिकेशन का नाम बदलना
  • skaffold.yaml खोलें
  • फ़िलहाल dockerfile-image के तौर पर सेट की गई इमेज का नाम चुनें
  • राइट क्लिक करें और 'सभी बदलावों को बदलें' चुनें
  • python-app के तौर पर नया नाम डालें
  • बिल्ड सेक्शन में जाकर,
  • पास FLASK_DEBUG=1 में docker.buildArgs जोड़ें
  • आईडीई से कंटेनर में चल रही *.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 आपकी कंटेनर इमेज को अपने-आप बना देंगे. इसके बाद, वे इसे Container Registry में पुश कर देंगे. इसके बाद, वे आपके ऐप्लिकेशन को GKE पर डिप्लॉय कर देंगे. यह प्रोसेस बैकग्राउंड में होती है. इससे डेवलपर को जानकारी नहीं मिलती.

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

  1. Cloud Shell Editor में सबसे नीचे मौजूद पैनल में, Cloud Code  चुनें

fdc797a769040839.png

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

cfce0d11ef307087.png

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

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

f95b620569ba96c5.png

  1. ज़्यादा जानकारी और कंटेनर से लाइव स्ट्रीम किए जा रहे लॉग देखने के लिए, दाईं ओर मौजूद चैनल ड्रॉप-डाउन में "Kubernetes: Run/Debug - Detailed" चुनें

94acdcdda6d2108.png

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

  1. क्लाउड कोड टर्मिनल में, आउटपुट में मौजूद पहले यूआरएल (http://localhost:8080) पर कर्सर घुमाएं. इसके बाद, दिखने वाले टूलटिप में, Open Web Preview को चुनें.
  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. सबसे नीचे मौजूद मेन्यू में, Cloud Code पर क्लिक करें. इसके बाद, ऐप्लिकेशन को debug मोड में चलाने के लिए, 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. VARIABLES सेक्शन में नीचे की ओर क्लिक करें
  6. वहां मौजूद 'लोकल' पर क्लिक करें. आपको "message" वैरिएबल दिखेगा.
  7. वैरिएबल के नाम "message" पर दो बार क्लिक करें. इसके बाद, पॉप-अप में वैल्यू को किसी दूसरी वैल्यू में बदलें. जैसे, "Greetings from Python"
  8. डीबग कंट्रोल पैनल में मौजूद, जारी रखें बटन पर क्लिक करें 607c33934f8d6b39.png
  9. अपने ब्राउज़र में जवाब देखें. इसमें अब वह अपडेट की गई वैल्यू दिखेगी जिसे आपने अभी डाला है.
  10. स्टॉप बटन 647213126d7a4c7b.png दबाकर, "डीबग" मोड बंद करें. इसके बाद, ब्रेकपॉइंट पर फिर से क्लिक करके, ब्रेकपॉइंट हटाएं.

5. सामान्य CRUD रेस्ट सर्विस डेवलप करना

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

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

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

  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 से सुरक्षित तरीके से कनेक्ट करने के लिए, ऐप्लिकेशन को Workload Identities का इस्तेमाल करने के लिए सेट अप करें. इससे आपका ऐप्लिकेशन, अपने सेवा खाते के तौर पर काम कर पाता है. साथ ही, डेटाबेस को ऐक्सेस करते समय उसके पास अलग-अलग अनुमतियां होती हैं.

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

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

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

Cloud Shell टर्मिनल में, यहां दिया गया कमांड चलाएं

curl -X POST http://localhost:8080/singer -H 'Content-Type: application/json' -d '{"first_name":"Cat","last_name":"Meow", "singer_id": 6}'
  1. टर्मिनल में यहां दिया गया निर्देश चलाकर, GET की जांच करें
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. प्रोजेक्ट मिटाकर, उससे जुड़े सभी इन्फ़्रास्ट्रक्चर और संसाधन हटाएं