डेवलपर के लिए कोडलैब के लिए Duet AI की टेक्निकल गाइड

1. मकसद

https://bit.ly/duetai-workshop-feedback

कृपया इस वर्कशॉप को बेहतर बनाने में हमारी मदद करने के लिए, सुझाव/शिकायत/राय वाला फ़ॉर्म भरें. इसमें करीब दो मिनट लगेंगे. चाहे आपको इसका इस्तेमाल खरीदारों के डेमो, वर्कशॉप, इवेंट या खुद शिक्षा के लिए करना हो, हमें आपके सुझाव, शिकायत या राय के लिए धन्यवाद.

***** ज़रूरी बातें *****

कोड डेवलपमेंट

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

वर्कशॉप के लिए दिशा-निर्देश

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

इस वर्कशॉप का मकसद, लोगों और पेशेवर लोगों को Duet AI के बारे में जानकारी देना है.

इस कोडलैब में, आपको यह जानकारी मिलती है:

1. अपने GCP प्रोजेक्ट में Duet AI को चालू करें. साथ ही, इसे IDE और Cloud Console में इस्तेमाल करने के लिए कॉन्फ़िगर करें.
2. कोड जनरेट करने, पूरा करने, और पूरी जानकारी पाने के लिए, Duet AI का इस्तेमाल करें.
3. किसी ऐप्लिकेशन से जुड़ी समस्या को समझाने और उसे हल करने के लिए, Duet AI का इस्तेमाल करें.
4. Duet AI की सुविधाएं, जैसे कि IDE चैट और मल्टी-टर्न चैट, चैट बनाम इनलाइन कोड जनरेशन, और स्मार्ट ऐक्शन. जैसे, कोड के बारे में पूरी जानकारी देना, बोलकर प्रॉम्प्ट देना वगैरह.

कहानी सुनाने की कला

यह दिखाने के लिए कि Duet AI for Developers को रोज़मर्रा की ज़िंदगी में किस तरह इस्तेमाल किया जाता है, इस वर्कशॉप की गतिविधियां कहानी के मकसद से की जाती हैं.

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

डेवलपर इस कंपनी के लिए नया है. इसलिए, वह कोड जनरेट करने, उसके बारे में जानकारी देने, और दस्तावेज़ तैयार करने के लिए, Duet AI का इस्तेमाल करेगा.

सेवा को कोड किए जाने के बाद प्लैटफ़ॉर्म एडमिन, Duet AI (चैट) का इस्तेमाल आर्टफ़ैक्ट (docker कंटेनर) बनाने के लिए करेगा.साथ ही, GCP में आर्टफ़ैक्ट को डिप्लॉय करने के लिए ज़रूरी संसाधनों का इस्तेमाल करेगा. जैसे, Artifact Registry, IAM की अनुमतियां, कोड रिपॉज़िटरी, कंप्यूट इन्फ़्रास्ट्रक्चर यानी GKE या CloudRun वगैरह.

GCP पर ऐप्लिकेशन डिप्लॉय होने के बाद, ऐप्लिकेशन ऑपरेटर/एसआरई नई सेवा में कोई गड़बड़ी हल करने के लिए, Duet AI और Cloud Ops का इस्तेमाल करेगा.

व्यक्तित्व

वर्कशॉप में ये पर्सोना शामिल किए जाते हैं:

1. ऐप्लिकेशन डेवलपर - प्रोग्रामिंग और सॉफ़्टवेयर डेवलपमेंट की कुछ जानकारी होना ज़रूरी है.

Duet AI वर्कशॉप का यह वर्शन सिर्फ़ डेवलपर के लिए उपलब्ध है. इसके लिए, GCP के क्लाउड संसाधनों के बारे में जानकारी होना ज़रूरी नहीं है. इस ऐप्लिकेशन को चलाने के लिए, ज़रूरी GCP संसाधन बनाने का तरीका यहां बताया गया है. इस गाइड में दिए गए निर्देशों का पालन करके, ज़रूरी GCP संसाधनों को डिप्लॉय किया जा सकता है.

2. वातावरण को तैयार करना

Duet AI को चालू किया जा रहा है

GCP प्रोजेक्ट में Duet AI को चालू करने के लिए, एपीआई (Terraform जैसे gcloud या IaC टूल) या Cloud Console यूज़र इंटरफ़ेस (यूआई) का इस्तेमाल किया जा सकता है.

Google Cloud प्रोजेक्ट में Duet AI को चालू करने के लिए, आपको Cloud AI Companion API को चालू करना होगा. साथ ही, उपयोगकर्ताओं को Cloud AI Companion के उपयोगकर्ता और सेवा के इस्तेमाल से जुड़ी व्यूअर आइडेंटिटी ऐंड ऐक्सेस मैनेजमेंट (आईएएम) की भूमिकाएं भी देनी होंगी.

gcloud के ज़रिए

Cloud Shell को चालू करें:

क्लाउड शेल

अपने PROJECT_ID, USER को कॉन्फ़िगर करें और Cloud AI Companion API को चालू करें.

export PROJECT_ID=<YOUR PROJECT ID>
export USER=<YOUR USERNAME> # Use your full LDAP, e.g. [e-mail]
gcloud config set project ${PROJECT_ID}
gcloud services enable cloudaicompanion.googleapis.com --project ${PROJECT_ID}

आउटपुट कुछ ऐसा होता है:

Updated property [core/project].
Operation "operations/acat.p2-60565640195-f37dc7fe-b093-4451-9b12-934649e2a435" finished successfully.

उपयोगकर्ता खाते को Cloud AI Companion के उपयोगकर्ता और सेवा के इस्तेमाल से जुड़ी व्यूअर की पहचान और ऐक्सेस मैनेजमेंट (आईएएम) की भूमिकाएं दें. Cloud Companion API हमारे इस्तेमाल किए जाने वाले IDE और कंसोल, दोनों की सुविधाओं पर काम करता है. कंसोल में यूज़र इंटरफ़ेस (यूआई) को चालू करने से पहले, सेवा के इस्तेमाल से जुड़े डेटा देखने की अनुमति वाली सुविधा का इस्तेमाल तुरंत जांच के तौर पर किया जाता है. ऐसा इसलिए किया जाता है, ताकि Duet यूज़र इंटरफ़ेस (यूआई) सिर्फ़ उन प्रोजेक्ट में दिखे जिनमें एपीआई चालू हो.

gcloud projects add-iam-policy-binding  ${PROJECT_ID} \
--member=user:${USER} --role=roles/cloudaicompanion.user

gcloud projects add-iam-policy-binding  ${PROJECT_ID} \
--member=user:${USER} --role=roles/serviceusage.serviceUsageViewer

आउटपुट कुछ ऐसा होता है:

...
- members:
  - user:<YOUR USER ACCOUNT>
  role: roles/cloudaicompanion.user

...
- members:
  - user:<YOUR USER ACCOUNT>
  role: roles/serviceusage.serviceUsageViewer

Cloud Console के ज़रिए

एपीआई चालू करने के लिए, Google Cloud Console में Cloud AI Companion API पेज पर जाएं. Cloud AI Companion API

प्रोजेक्ट सिलेक्टर में, कोई प्रोजेक्ट चुनें.

चालू करें पर क्लिक करें.

पेज अपडेट हो जाता है और चालू है स्थिति दिखाता है. Duet AI अब चुने गए Google Cloud प्रोजेक्ट में उन सभी उपयोगकर्ताओं के लिए उपलब्ध है जिनके पास आईएएम की ज़रूरी भूमिकाएं हैं.

Duet AI का इस्तेमाल करने के लिए ज़रूरी आईएएम भूमिकाएं देने के लिए, IAM पेज पर जाएं. IAM

प्रिंसिपल कॉलम में, उस उपयोगकर्ता को ढूंढें जिसके लिए आपको Duet AI का ऐक्सेस देना है. इसके बाद, उस लाइन में पेंसिल आइकॉन ✏️ प्रिंसिपल में बदलाव करें पर क्लिक करें.

बदलाव करें ऐक्सेस पैनल में, एक और भूमिका जोड़ें पर क्लिक करें.

'भूमिका चुनें' में, Cloud AI Companion User को चुनें.

दूसरी भूमिका जोड़ें पर क्लिक करें और सेवा के इस्तेमाल की जानकारी देने वाला दस्तावेज़ चुनें.

सेव करें पर क्लिक करें.

IDE सेट अप करना

डेवलपर अपनी ज़रूरतों के हिसाब से, कई तरह के IDE में से किसी को भी चुन सकते हैं. Duet AI कोड इस्तेमाल करने की सुविधा कई आईडीई के लिए उपलब्ध है. जैसे, Visual Studio Code, JetBrains IDEs (InteliJ, PyCharm, GoLand, WebStorm वगैरह), Cloud Workstations, Cloud Shell Editor.

इस लैब में, Cloud Workstations या क्लाउड शेल एडिटर इस्तेमाल किया जा सकता है.

इस वर्कशॉप में, Cloud Shell Editor का इस्तेमाल किया जाता है.

ध्यान दें कि Cloud Workstations को सेट अप होने में 20 से 30 मिनट लग सकते हैं.

तुरंत इस्तेमाल करने के लिए, Cloud Shell Editor का इस्तेमाल करें.

Cloud Shell के सबसे ऊपर मौजूद मेन्यू बार में मौजूद पेंसिल आइकॉन ✏️ पर क्लिक करके, Cloud Shell एडिटर खोलें.

Cloud Shell Editor का यूज़र इंटरफ़ेस (यूआई) और UX VSCode से काफ़ी मिलता-जुलता है.

सेटिंग पैनल में जाने के लिए, CTRL (Windows में)/CMD (Mac में) + , (कॉमा) पर क्लिक करें.

खोज बार में, "Duet ai" टाइप करें.

पक्का करें या चालू करें Cloudcode › Duet AI: चालू करें और Cloudcode › Duet AI › इनलाइन सुझाव: अपने-आप लागू होने की सुविधा चालू करें

सबसे नीचे स्थिति बार में, Cloud Code - साइन इन करें पर क्लिक करें और साइन इन करने के वर्कफ़्लो को फ़ॉलो करें.

अगर आपने पहले से साइन इन किया हुआ है, तो स्टेटस बार में क्लाउड कोड - कोई प्रोजेक्ट नहीं है दिखता है.

Cloud Code पर क्लिक करें - कोई प्रोजेक्ट नहीं है और सबसे ऊपर ऐक्शन ड्रॉपडाउन पैनल दिखेगा. Google Cloud प्रोजेक्ट चुनें पर क्लिक करें.

अपना प्रोजेक्ट आईडी टाइप करें. इसके बाद, आपका प्रोजेक्ट सूची में दिखना चाहिए.

प्रोजेक्ट की सूची में से अपना PROJECT_ID चुनें.

सबसे नीचे मौजूद स्टेटस बार, आपका प्रोजेक्ट आईडी दिखाने के लिए अपडेट हो जाता है. अगर ऐसा नहीं है, तो आपको Cloud Shell Editor टैब को रीफ़्रेश करना पड़ सकता है.

बाईं ओर दिए गए मेन्यू बार में, Duet AI आइकॉन पर क्लिक करें. इसके बाद, Duet AI चैट विंडो दिखेगी. अगर आपको यह मैसेज मिले कि GCP प्रोजेक्ट चुनें. प्रोजेक्ट पर क्लिक करें और उसे फिर से चुनें.

अब आपको Duet AI चैट विंडो दिख रही है

3. इन्फ़्रास्ट्रक्चर सेट अप करना

GCP में नई शिपिंग सेवा चलाने के लिए, आपको इन GCP संसाधनों की ज़रूरत होगी:

1. Cloud SQL इंस्टेंस, जिसमें डेटाबेस मौजूद है.
2. कंटेनर के तौर पर काम करने वाली सेवा को चलाने के लिए, GKE (जीकेई) क्लस्टर.
3. Docker इमेज को सेव करने के लिए, एक Artifact Registry.
4. कोड के लिए क्लाउड सोर्स डेटा स्टोर करने की जगह.

Cloud Shell टर्मिनल में, इस रेपो का क्लोन बनाएं और अपने GCP प्रोजेक्ट में इन्फ़्रास्ट्रक्चर सेट अप करने के लिए, नीचे दिए गए निर्देशों का पालन करें.

# Set your project
export PROJECT_ID=<INSERT_YOUR_PROJECT_ID>
gcloud config set core/project ${PROJECT_ID}

# Enable Cloudbuild and grant Cloudbuild SA owner role 
export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format 'value(projectNumber)')
gcloud services enable cloudbuild.googleapis.com
gcloud projects add-iam-policy-binding ${PROJECT_ID} --member serviceAccount:${PROJECT_NUMBER}@cloudbuild.gserviceaccount.com --role roles/owner

# Clone the repo
git clone https://github.com/duetailabs/dev.git ~/duetaidev
cd ~/duetaidev

# Run Cloudbuild to create the necessary resources
gcloud builds submit --substitutions=_PROJECT_ID=${PROJECT_ID}

# To destroy all GCP resources, run the following
# gcloud builds submit --substitutions=_PROJECT_ID=${PROJECT_ID} --config=cloudbuild_destroy.yaml

ध्यान दें: इस चरण को पूरा होने में 15 से 20 मिनट लग सकते हैं.

अगर टेराफ़ॉर्म काम नहीं करता है, तो कृपया इन कमांड को फिर से चलाएं:

gcloud builds submit --substitutions=_PROJECT_ID=${PROJECT_ID}

4. Python Flask सेवा डेवलप करना

हम जो सेवा बनाएंगे उसमें ये फ़ाइलें होंगी. आपको अभी इन फ़ाइलों को बनाने की ज़रूरत नहीं है और एक-एक करके इन फ़ाइलों को बनाने के लिए, नीचे दिए गए निर्देशों का पालन करें:

1. package-service.yaml - पैकेज सेवा के लिए Open API की खास जानकारी, जिसमें लंबाई, चौड़ाई, वज़न, और हैंडलिंग के खास निर्देशों जैसा डेटा होता है.
2. data_model.py - पैकेज-सेवा एपीआई की खास बातों के लिए डेटा मॉडल. product_details DB में packages टेबल भी बनाता है.
3. connect_connector.py - CloudSQL कनेक्शन (इंजन, सेशन, और बेस ORM की जानकारी देता है)
4. db_init.py - packages टेबल में सैंपल डेटा जनरेट करता है.
5. main.py - GET एंडपॉइंट वाली Python फ़्लास्क सेवा, जो product_id के आधार पर packages डेटा से पैकेज की जानकारी हासिल करती है.
6. test.py - यूनिट टेस्ट
7. requirement.txt - Python से जुड़ी शर्तें
8. Dockerfile - इस ऐप्लिकेशन को कंटेनर में रखने के लिए

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

पिछले चरण में, आपने क्लाउड सोर्स का डेटा स्टोर करने की जगह बनाई थी. डेटा स्टोर करने की जगह का क्लोन बनाएं. आपको ऐप्लिकेशन फ़ाइलों को, क्लोन किए गए रिपॉज़िटरी फ़ोल्डर में बनाना होगा.

Cloud Shell टर्मिनल में, रिपॉज़िटरी का क्लोन बनाने के लिए यह कमांड चलाएं.

cd ~
gcloud source repos clone shipping shipping
cd ~/shipping 

Cloud Shell Editor में बाईं ओर मौजूद मेन्यू से, Duet AI चैट साइडबार खोलें. यह आइकॉन, जैसा दिखता है. अब कोड से जुड़ी मदद के लिए, Duet AI का इस्तेमाल किया जा सकता है.

package-service.yaml

कोई भी फ़ाइल खुली न होने पर, Duet से शिपिंग सेवा के लिए Open API की खास जानकारी जनरेट करने के लिए कहें.

प्रॉम्प्ट 1: अंकों वाले प्रॉडक्ट आईडी के आधार पर शिपिंग और पैकेज की जानकारी देने वाली सेवा के लिए, OpenAPI yaml स्पेसिफ़िकेशन जनरेट करें. सेवा में पैकेज की ऊंचाई, चौड़ाई, गहराई, वज़न, और हैंडलिंग के खास निर्देशों की जानकारी शामिल होनी चाहिए.

जनरेट की गई कोड विंडो के सबसे ऊपर दाईं ओर तीन विकल्प होते हैं.

कोड को COPY करके उसे किसी फ़ाइल में चिपकाया जा सकता है.

Editor में हाल ही में खोली गई फ़ाइल में कोड ADD किया जा सकता है.

इसके अलावा, कोड को नई फ़ाइल में OPEN किया जा सकता है.

नई फ़ाइल में मौजूद कोड OPEN पर क्लिक करें.

फ़ाइल सेव करने के लिए CTRL/CMD + s पर क्लिक करें और फ़ाइल को package-service.yaml नाम के ऐप्लिकेशन फ़ोल्डर में स्टोर करें. ठीक पर क्लिक करें.

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

Duet AI के जवाब देखने के लिए, अलग-अलग प्रॉम्प्ट आज़माएं.

Duet AI साइडबार में सबसे ऊपर मौजूद ट्रैश आइकॉन पर क्लिक करके, Duet AI चैट का इतिहास रीसेट करें.

data_model.py

इसके बाद, OpenAPI स्पेसिफ़िकेशन के आधार पर, सेवा के लिए डेटा मॉडल की Python फ़ाइल बनाएं.

package-service.yaml फ़ाइल खोलने के बाद, यह प्रॉम्प्ट डालें.

प्रॉम्प्ट 1: Python स्क्लैल्केमी ORM का इस्तेमाल करके, इस एपीआई सेवा के लिए डेटा मॉडल जनरेट करें. एक अलग फ़ंक्शन और मुख्य एंट्रीपॉइंट भी शामिल करें, जो डेटाबेस टेबल बनाता है.

चलिए, जनरेट किए गए हर हिस्से पर नज़र डालते हैं. Duet AI अब भी असिस्टेंट है. यह लेखक के कोड को तुरंत समझने में मदद कर सकता है. हालांकि, आपको जनरेट किए गए कॉन्टेंट की समीक्षा करते रहना चाहिए. साथ ही, यह समझने की कोशिश भी की जाती है कि समय के साथ क्या होता है.

सबसे पहले, तरह Base की Package नाम की एक क्लास है, जो packages डेटाबेस के लिए डेटा मॉडल के बारे में जानकारी देती है. जैसे:

ध्यान दें: यह कोड Duet AI से जनरेट किया जाना चाहिए. आपको उम्मीद के मुताबिक बदलाव करना पड़ सकता है.

class Package(Base):
    __tablename__ = 'packages'

    id = Column(Integer, primary_key=True)
    product_id = Column(String(255))
    height = Column(Float)
    width = Column(Float)
    depth = Column(Float)
    weight = Column(Float)
    special_handling_instructions = Column(String(255))

इसके बाद, आपको एक ऐसे फ़ंक्शन की ज़रूरत होगी जो डेटाबेस में टेबल बनाता हो, जैसे कि:

def create_tables(engine):
    Base.metadata.create_all(engine)

आखिर में, आपको CloudSQL डेटाबेस में टेबल बनाने के लिए, create_tables फ़ंक्शन को चलाने वाले मुख्य फ़ंक्शन की ज़रूरत होगी, जैसे कि:

if __name__ == '__main__':
    from sqlalchemy import create_engine

    engine = create_engine('sqlite:///shipping.db')
    create_tables(engine)

    print('Tables created successfully.')

ध्यान दें कि main फ़ंक्शन, लोकल sqlite डेटाबेस का इस्तेमाल करके इंजन बना रहा है. CloudSQL का इस्तेमाल करने के लिए, आपको इसे बदलना होगा. आप इंतज़ार करें.

फ़ाइल के नए वर्कफ़्लो में पहले की तरह, OPEN कोड का इस्तेमाल करके. कोड को data_model.py नाम वाली फ़ाइल में सेव करें (नाम में अंडरस्कोर लिखें, डैश नहीं).

Duet AI साइडबार में सबसे ऊपर मौजूद ट्रैश आइकॉन पर क्लिक करके, Duet AI चैट का इतिहास रीसेट करें.

connect-connector.py

CloudSQL कनेक्टर बनाएं.

data_model.py फ़ाइल खुली होने पर, ये प्रॉम्प्ट डालें.

प्रॉम्प्ट 1: cloud-sql-python-connector लाइब्रेरी का इस्तेमाल करके, एक ऐसा फ़ंक्शन जनरेट करें जो Postgres के Cloud SQL इंस्टेंस के लिए कनेक्शन पूल शुरू करता है.

ध्यान दें कि जवाब, cloud-sql-python-connector लाइब्रेरी का इस्तेमाल नहीं करता. आपके पास प्रॉम्प्ट को बेहतर बनाने का विकल्प है, ताकि Duet पर उपयोगकर्ताओं को जवाब देने के लिए ध्यान दिया जा सके. इसके लिए, उन्हें उसी चैट थ्रेड में खास जानकारी जोड़नी होगी.

चलिए, एक और प्रॉम्प्ट का इस्तेमाल करते हैं.

प्रॉम्प्ट 2: cloud-sql-python-connector लाइब्रेरी का इस्तेमाल करना ज़रूरी है.

पक्का करें कि यह cloud-sql-python-connector लाइब्रेरी का इस्तेमाल करता हो.

फ़ाइल के नए वर्कफ़्लो में पहले की तरह, OPEN कोड का इस्तेमाल करके. कोड को connect_conector.py नाम वाली फ़ाइल में सेव करें. आपको pg8000 लाइब्रेरी को मैन्युअल तरीके से इंपोर्ट करना पड़ सकता है. कृपया नीचे दी गई फ़ाइल देखें.

Duet AI के साथ की गई चैट का इतिहास मिटाएं और connect_connector.py फ़ाइल खुली होने पर, ऐप्लिकेशन में इस्तेमाल करने के लिए DB engine, sessionmaker, और base ओआरएम जनरेट करें.

प्रॉम्प्ट 1: connect_with_connector तरीके का इस्तेमाल करके इंजन, सेशनमेकर क्लास, और बेस ओआरएम बनाएं

रिस्पॉन्स के तौर पर engine, Session, और Base को connect_connector.py फ़ाइल में जोड़ा जा सकता है.

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

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

Duet AI के जवाबों के संभावित वैरिएशन देखने के लिए, अलग-अलग प्रॉम्प्ट आज़माएं.

Duet AI साइडबार में सबसे ऊपर मौजूद ट्रैश आइकॉन पर क्लिक करके, Duet AI चैट का इतिहास रीसेट करें.

data_model.py को अपडेट किया जा रहा है

CloudSQL डेटाबेस में टेबल बनाने के लिए, आपको पिछले चरण (connect_connector.py फ़ाइल में) में बनाए गए इंजन का इस्तेमाल करना होगा.

Duet AI की चैट का इतिहास मिटाएं. data_model.py फ़ाइल खोलें. नीचे दिया गया प्रॉम्प्ट आज़माएं.

प्रॉम्प्ट 1: मुख्य फ़ंक्शन में, Connected_connector.py से इंजन को इंपोर्ट करें और उसका इस्तेमाल करें

आपको connect_connector (CloudSQL के लिए) से engine को इंपोर्ट करने का रिस्पॉन्स दिखेगा. create_table उस इंजन का इस्तेमाल करता है, न कि डिफ़ॉल्ट sqlite लोकल DB.

data_model.py फ़ाइल अपडेट करें.

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

Duet AI के अलग-अलग जवाब देखने के लिए, अलग-अलग प्रॉम्प्ट आज़माएं.

Duet AI साइडबार में सबसे ऊपर मौजूद ट्रैश आइकॉन पर क्लिक करके, Duet AI चैट का इतिहास रीसेट करें.

requirements.txt

ऐप्लिकेशन के लिए requirements.txt फ़ाइल बनाएं.

connect_connector.py और data_model.py, दोनों फ़ाइल को खोलें और यह प्रॉम्प्ट डालें.

प्रॉम्प्ट 1: इस डेटा मॉडल और सेवा के लिए, पीआईपी की ज़रूरी शर्तों वाली फ़ाइल जनरेट करना

प्रॉम्प्ट 2: नए वर्शन का इस्तेमाल करके, इस डेटा मॉडल और सेवा के लिए पीआईपी की ज़रूरी शर्तों वाली फ़ाइल जनरेट करना

पुष्टि करें कि नाम और वर्शन सही हैं. उदाहरण के लिए, ऊपर दिए गए जवाब में, google-cloud-sql-connecter का नाम और वर्शन, दोनों गलत हैं. मैन्युअल तरीके से वर्शन ठीक करें और इस तरह दिखने वाली requirements.txt फ़ाइल बनाएं:

cloud-sql-python-connector==1.2.4
sqlalchemy==1.4.36
pg8000==1.22.0

कमांड टर्मिनल में, ये काम करें:

pip3 install -r requirements.txt

Duet AI साइडबार में सबसे ऊपर मौजूद ट्रैश आइकॉन पर क्लिक करके, Duet AI चैट का इतिहास रीसेट करें.

CloudSQL में पैकेज टेबल बनाना

CloudSQL डेटाबेस कनेक्टर के लिए, एनवायरमेंट वैरिएबल सेट करें.

export INSTANCE_NAME=$(gcloud sql instances list --format='value(name)')
export INSTANCE_CONNECTION_NAME=$(gcloud sql instances describe ${INSTANCE_NAME} --format="value(connectionName)")
export DB_USER=evolution
export DB_PASS=evolution
export DB_NAME=product_details

अब data_model.py चलाएं.

python data_model.py

आउटपुट, नीचे दिए गए नतीजों जैसा होता है (कोड की जांच करके देखें कि असल में क्या उम्मीद है):

Tables created successfully.

ध्यान दें: इस गड़बड़ी को अनदेखा किया जा सकता है:

CryptographyDeprecationWarning: Properties that return a naïve datetime object have been deprecated. Please switch to not_valid_after_utc.

expiration = x509.not_valid_after

CloudSQL इंस्टेंस से कनेक्ट करें और देखें कि डेटाबेस बन गया है.

gcloud sql connect ${INSTANCE_NAME} --user=evolution --database=product_details

पासवर्ड डालने के बाद (साथ ही evolution), टेबल पाएं.

product_details=> \dt

आउटपुट इससे मिलता-जुलता है:

           List of relations
 Schema |   Name   | Type  |   Owner   
--------+----------+-------+-----------
 public | packages | table | evolution
(1 row)

आपके पास डेटा मॉडल और टेबल की जानकारी देखने का विकल्प भी है.

product_details=> \d+ packages

आउटपुट इससे मिलता-जुलता है:

                                                                        Table "public.packages"
            Column             |       Type        | Collation | Nullable |               Default                | Storage  | Compression | Stats target | Description 
-------------------------------+-------------------+-----------+----------+--------------------------------------+----------+-------------+--------------+-------------
 id                            | integer           |           | not null | nextval('packages_id_seq'::regclass) | plain    |             |              | 
 product_id                    | integer           |           | not null |                                      | plain    |             |              | 
 height                        | double precision  |           | not null |                                      | plain    |             |              | 
 width                         | double precision  |           | not null |                                      | plain    |             |              | 
 depth                         | double precision  |           | not null |                                      | plain    |             |              | 
 weight                        | double precision  |           | not null |                                      | plain    |             |              | 
 special_handling_instructions | character varying |           |          |                                      | extended |             |              | 
Indexes:
    "packages_pkey" PRIMARY KEY, btree (id)
Access method: heap

CloudSQL से बाहर निकलने के लिए, \q टाइप करें.

db_init.py

अब हम packages टेबल में, सैंपल डेटा जोड़ते हैं.

Duet AI की चैट का इतिहास मिटाएं. data_model.py फ़ाइल खुली होने पर, ये प्रॉम्प्ट आज़माएं.

प्रॉम्प्ट 1: ऐसा फ़ंक्शन जनरेट करें जो सैंपल पैकेज की 10 पंक्तियां बनाता है और उन्हें पैकेज टेबल से कम करता है

प्रॉम्प्ट 2: Connect_connector से सेशन का इस्तेमाल करके, एक ऐसा फ़ंक्शन जनरेट करें जो सैंपल पैकेज की 10 लाइनें बनाता है और उन्हें पैकेज टेबल में भेजता है

फ़ाइल के नए वर्कफ़्लो में पहले की तरह, OPEN कोड का इस्तेमाल करके. कोड को db_init.py नाम वाली फ़ाइल में सेव करें.

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

Duet AI के अलग-अलग जवाब देखने के लिए, अलग-अलग प्रॉम्प्ट आज़माएं.

Duet AI साइडबार में सबसे ऊपर मौजूद ट्रैश आइकॉन पर क्लिक करके, Duet AI चैट का इतिहास रीसेट करें.

पैकेज के लिए सैंपल डेटा बनाना

कमांड लाइन से db_init.py चलाएं.

python db_init.py

आउटपुट इससे मिलता-जुलता है:

Packages created successfully.

ध्यान दें: इस गड़बड़ी को अनदेखा किया जा सकता है:

CryptographyDeprecationWarning: Properties that return a naïve datetime object have been deprecated. Please switch to not_valid_after_utc.

expiration = x509.not_valid_after

CloudSQL इंस्टेंस से फिर से कनेक्ट करें और पुष्टि करें कि पैकेज टेबल में सैंपल डेटा जोड़ा गया है.

CloudSQL इंस्टेंस से कनेक्ट करें और देखें कि डेटाबेस बन गया है.

gcloud sql connect ${INSTANCE_NAME} --user=evolution --database=product_details

पासवर्ड डालने के बाद, पैकेज टेबल से भी पूरा डेटा डाउनलोड करें. इसके अलावा, पासवर्ड एवोल्यूशन भी डालें.

product_details=> SELECT * FROM packages;

आउटपुट इससे मिलता-जुलता है:

 id | product_id | height | width | depth | weight |   special_handling_instructions   
----+------------+--------+-------+-------+--------+-----------------------------------
  1 |          0 |     10 |    10 |    10 |     10 | No special handling instructions.
  2 |          1 |     10 |    10 |    10 |     10 | No special handling instructions.
  3 |          2 |     10 |    10 |    10 |     10 | No special handling instructions.
  4 |          3 |     10 |    10 |    10 |     10 | No special handling instructions.
  5 |          4 |     10 |    10 |    10 |     10 | No special handling instructions.
  6 |          5 |     10 |    10 |    10 |     10 | No special handling instructions.
  7 |          6 |     10 |    10 |    10 |     10 | No special handling instructions.
  8 |          7 |     10 |    10 |    10 |     10 | No special handling instructions.
  9 |          8 |     10 |    10 |    10 |     10 | No special handling instructions.
 10 |          9 |     10 |    10 |    10 |     10 | No special handling instructions.
(10 rows)

CloudSQL से बाहर निकलने के लिए, \q टाइप करें.

main.py

data_model.py, package-service.yaml, और connect_connector.py फ़ाइलें खुली होने पर, ऐप्लिकेशन के लिए main.py बनाएं.

प्रॉम्प्ट 1: Python फ़्लास्क लाइब्रेरी का इस्तेमाल करना - ऐसा इंप्लिमेंटेशन बनाना जो इस सेवा के लिए एचटीटीपी रेस्ट एंडपॉइंट का इस्तेमाल करता हो

प्रॉम्प्ट 2: Python फ़्लास्क लाइब्रेरी का इस्तेमाल करना - ऐसा इंप्लिमेंटेशन बनाना जो इस सेवा के लिए एचटीटीपी रेस्ट एंडपॉइंट का इस्तेमाल करता हो. पैकेज डेटा के लिए, Connect_conector.py से Sessionमेकर को इंपोर्ट करना और उसका इस्तेमाल करना.

प्रॉम्प्ट 3: Python फ़्लास्क लाइब्रेरी का इस्तेमाल करना - इस सेवा के लिए http रेस्ट एंडपॉइंट का इस्तेमाल करने वाला इंप्लिमेंटेशन बनाएं. डेटा पैकेज के लिए, data_model.py और SessionMaker से Connected_conector.py से पैकेज इंपोर्ट करना और इस्तेमाल करना हो.

प्रॉम्प्ट 4: Python फ़्लास्क लाइब्रेरी का इस्तेमाल करना - इस सेवा के लिए http रेस्ट एंडपॉइंट का इस्तेमाल करने वाला इंप्लिमेंटेशन बनाएं. पैकेज डेटा के लिए, Connect_conector.py से SessionMaker और data_model.py से पैकेज इंपोर्ट करना और इस्तेमाल करना. app.run के लिए होस्ट आईपी 0.0.0.0 का इस्तेमाल करना

main.py के लिए ज़रूरी शर्तों को अपडेट करें.

प्रॉम्प्ट: Main.py के लिए ज़रूरी शर्तों वाली फ़ाइल बनाएं

इसे requirements.txt फ़ाइल में जोड़ें. फ़्लास्क वर्शन 3.0.0 का इस्तेमाल ज़रूर करें.

ध्यान दें: Duet AI के बारे में खास जानकारी देने पर बेहतर नतीजे मिलते हैं. कुछ मामलों में, ऐसा हो सकता है कि आपको सबसे सटीक/अपनी पसंद के जवाब पाने के लिए, किसी लाइब्रेरी का मनचाहा वर्शन देना पड़े.

फ़ाइल के नए वर्कफ़्लो में पहले की तरह, OPEN कोड का इस्तेमाल करके. कोड को main.py नाम वाली फ़ाइल में सेव करें.

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

Duet AI साइडबार में सबसे ऊपर मौजूद ट्रैश आइकॉन पर क्लिक करके, Duet AI चैट का इतिहास रीसेट करें.

5. ऐप्लिकेशन की जांच करना और उसे चलाना

ज़रूरी शर्तें इंस्टॉल करें.

pip3 install -r requirements.txt

main.py चलाएं.

python main.py

आउटपुट इससे मिलता-जुलता है:

 * Serving Flask app 'main'
 * Debug mode: off
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on all addresses (0.0.0.0)
 * Running on http://127.0.0.1:5000
 * Running on http://10.88.0.3:5000
Press CTRL+C to quit

दूसरे टर्मिनल से, /packages/<product_id> एंडपॉइंट की जांच करें.

curl localhost:5000/packages/1

आउटपुट इससे मिलता-जुलता है:

{"depth":10.0,"height":10.0,"special_handling_instructions":"No special handling instructions.","weight":10.0,"width":10.0}

सैंपल डेटा में, किसी दूसरे प्रॉडक्ट आईडी को भी टेस्ट किया जा सकता है.

टर्मिनल में चल रहे डॉकर कंटेनर से बाहर निकलने के लिए CTRL_C डालें.

यूनिट टेस्ट जनरेट करना

main.py फ़ाइल खुली होने पर, यूनिट टेस्ट जनरेट करें.

प्रॉम्प्ट 1: यूनिट टेस्ट जनरेट करें.

फ़ाइल के नए वर्कफ़्लो में पहले की तरह, OPEN कोड का इस्तेमाल करके. कोड को test.py नाम वाली फ़ाइल में सेव करें.

test_get_package फ़ंक्शन में, product_id तय करना ज़रूरी है. इसे मैन्युअल तरीके से भी जोड़ा जा सकता है.

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

Duet AI साइडबार में सबसे ऊपर मौजूद ट्रैश आइकॉन पर क्लिक करके, Duet AI चैट का इतिहास रीसेट करें.

यूनिट टेस्ट चलाना

यूनिट टेस्ट करें.

python test.py

आउटपुट इससे मिलता-जुलता है:

.
----------------------------------------------------------------------
Ran 1 test in 1.061s

OK

Cloud Shell Editor में सभी फ़ाइलें बंद करें. साथ ही, सबसे ऊपर स्टेटस बार में ट्रैश आइकॉन पर क्लिक करके चैट का इतिहास मिटाएं.

Dockerfile

इस ऐप्लिकेशन के लिए Dockerfile बनाएं.

main.py खोलें और नीचे दिए गए प्रॉम्प्ट आज़माएं.

प्रॉम्प्ट 1: इस ऐप्लिकेशन के लिए Dockerfile जनरेट करें.

Prompt 2: इस ऐप्लिकेशन के लिए Dockerfile जनरेट करें. सभी फ़ाइलें कंटेनर में कॉपी करें.

आपको INSTANCE_CONNECTION_NAME, DB_USER, DB_PASS, और DB_NAME के लिए भी ENVARS को सेट करना होगा. इसे मैन्युअल तरीके से भी किया जा सकता है. आपकी Dockerfile कुछ ऐसी दिखनी चाहिए:

FROM python:3.10-slim

WORKDIR /app

COPY . ./

RUN pip install -r requirements.txt

# Add these manually for your project
ENV INSTANCE_CONNECTION_NAME=YOUR_INSTANCE_CONNECTION_NAME
ENV DB_USER=evolution
ENV DB_PASS=evolution
ENV DB_NAME=product_details

CMD ["python", "main.py"]

फ़ाइल के नए वर्कफ़्लो में पहले की तरह, OPEN कोड का इस्तेमाल करके. कोड को Dockerfile नाम की फ़ाइल में सेव करें.

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

स्थानीय रूप से ऐप्लिकेशन चलाना

Dockerfile को खोलकर, यह प्रॉम्प्ट आज़माएं.

प्रॉम्प्ट 1: मैं इस Dockerfile का इस्तेमाल करके, कंटेनर को स्थानीय तौर पर कैसे चलाऊं

निर्देशों का पालन करें.

# Build
docker build -t shipping .
# And run
docker run -p 5000:5000 -it shipping

आउटपुट इससे मिलता-जुलता है:

 * Serving Flask app 'main'
 * Debug mode: off
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on all addresses (0.0.0.0)
 * Running on http://127.0.0.1:5000
 * Running on http://172.17.0.2:5000
Press CTRL+C to quit

दूसरी टर्मिनल विंडो से, कंटेनर को ऐक्सेस करें.

curl localhost:5000/packages/1

आउटपुट इससे मिलता-जुलता है:

{"depth":10.0,"height":10.0,"special_handling_instructions":"No special handling instructions.","weight":10.0,"width":10.0}

कंटेनर वाला ऐप्लिकेशन काम कर रहा है.

टर्मिनल में चल रहे डॉकर कंटेनर से बाहर निकलने के लिए CTRL_C डालें.

Artifact Registry में कंटेनर की इमेज

कंटेनर की इमेज बनाएं और Artifact Registry में भेजें.

cd ~/shipping
gcloud auth configure-docker us-central1-docker.pkg.dev
docker build -t us-central1-docker.pkg.dev/${PROJECT_ID}/shipping/shipping .
docker push us-central1-docker.pkg.dev/${PROJECT_ID}/shipping/shipping

ऐप्लिकेशन कंटेनर अब us-central1-docker.pkg.dev/${PROJECT_ID}/shipping/shipping पर मौजूद है, जिसे GKE (जीकेई) पर डिप्लॉय किया जा सकता है.

6. ऐप्लिकेशन को GKE (जीकेई) क्लस्टर में डिप्लॉय किया जा रहा है

जब आपने इस वर्कशॉप के लिए GCP संसाधन बनाए, तब एक GKE (जीकेई) Autopilot क्लस्टर बनाया गया. GKE (जीकेई) क्लस्टर से कनेक्ट करें.

gcloud container clusters get-credentials gke1 \
    --region=us-central1

Kubernetes डिफ़ॉल्ट सेवा खाते को, Google सेवा खाते के साथ जोड़ें.

kubectl annotate serviceaccount default iam.gke.io/gcp-service-account=cloudsqlsa@${PROJECT_ID}.iam.gserviceaccount.com

आउटपुट इससे मिलता-जुलता है:

serviceaccount/default annotated

k8s.yaml फ़ाइल को तैयार करें और लागू करें.

cp ~/duetaidev/k8s.yaml_tmpl ~/shipping/.
export INSTANCE_NAME=$(gcloud sql instances list --format='value(name)')
export INSTANCE_CONNECTION_NAME=$(gcloud sql instances describe ${INSTANCE_NAME} --format="value(connectionName)")
export IMAGE_REPO=us-central1-docker.pkg.dev/${PROJECT_ID}/shipping/shipping
envsubst < ~/shipping/k8s.yaml_tmpl > k8s.yaml
kubectl apply -f k8s.yaml

आउटपुट इससे मिलता-जुलता है:

deployment.apps/shipping created
service/shipping created

पॉड के चालू होने और सेवा के लिए बाहरी लोड बैलेंसर का आईपी पता असाइन होने तक इंतज़ार करें.

kubectl get pods
kubectl get service shipping

आउटपुट इससे मिलता-जुलता है:

# kubectl get pods
NAME                      READY   STATUS    RESTARTS   AGE
shipping-f5d6f8d5-56cvk   1/1     Running   0          4m47s
shipping-f5d6f8d5-cj4vv   1/1     Running   0          4m48s
shipping-f5d6f8d5-rrdj2   1/1     Running   0          4m47s

# kubectl get service shipping
NAME       TYPE           CLUSTER-IP       EXTERNAL-IP    PORT(S)        AGE
shipping   LoadBalancer   34.118.225.125   34.16.39.182   80:30076/TCP   5m41s

GKE (जीकेई) ऑटो पायलट क्लस्टर के लिए, संसाधन तैयार होने तक कुछ देर इंतज़ार करें.

EXTERNAL-IP पते से सेवा को ऐक्सेस करें.

export EXTERNAL_IP=$(kubectl get svc shipping --output jsonpath='{.status.loadBalancer.ingress[0].ip}')
curl http://${EXTERNAL_IP}/packages/1

आउटपुट इससे मिलता-जुलता है:

{"depth":10.0,"height":10.0,"special_handling_instructions":"No special handling instructions.","weight":10.0,"width":10.0}

7. अतिरिक्त क्रेडिट: आवेदन से जुड़ी समस्या हल करना

cloudsqlsa सेवा खाते से, CloudSQL क्लाइंट IAM की भूमिका हटाएं. इससे CloudSQL डेटाबेस से कनेक्ट करने में गड़बड़ी होती है.

gcloud projects remove-iam-policy-binding ${PROJECT_ID} \
    --member="serviceAccount:cloudsqlsa@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/cloudsql.client"

शिपिंग पॉड को रीस्टार्ट करें.

kubectl rollout restart deployment shipping

Pod रीस्टार्ट होने के बाद, shipping की सेवा को फिर से ऐक्सेस करके देखें.

export EXTERNAL_IP=$(kubectl get svc shipping --output jsonpath='{.status.loadBalancer.ingress[0].ip}')
curl http://${EXTERNAL_IP}/packages/1 

आउटपुट इससे मिलता-जुलता है:

...
<title>500 Internal Server Error</title>
<h1>Internal Server Error</h1>
<p>The server encountered an internal error and was unable to complete your request. Either the server is overloaded or there is an error in the application.</p>

Kubernetes Engine > पर जाकर, लॉग की जांच करें वर्कलोड

shipping डिप्लॉयमेंट पर क्लिक करें. इसके बाद, लॉग टैब पर क्लिक करें.

स्टेटस बार की दाईं ओर मौजूद, लॉग एक्सप्लोरर में देखें आइकॉन पर क्लिक करें. इससे एक नई लॉग एक्सप्लोरर विंडो खुलती है.

Traceback गड़बड़ी की एंट्री में से किसी एक पर क्लिक करें. इसके बाद, इस लॉग एंट्री के बारे में बताएं पर क्लिक करें.

आप गड़बड़ी के बारे में जानकारी पढ़ सकते हैं.

चलिए, गड़बड़ी को हल करने के लिए Duet AI का इस्तेमाल करते हैं.

नीचे दिया गया प्रॉम्प्ट आज़माएं.

प्रॉम्प्ट 1: इस गड़बड़ी को हल करने में मेरी मदद करो

प्रॉम्प्ट में गड़बड़ी का मैसेज डालें.

प्रॉम्प्ट 2: अनुमति नहीं है: ऐसा लगता है कि पुष्टि किए गए आईएएम का मुख्य खाता, एपीआई अनुरोध करने की अनुमति नहीं देता है. ‘Cloud SQL एडमिन एपीआई' की पुष्टि करें आपके GCP प्रोजेक्ट और ‘Cloud SQL Client' में चालू हो को आईएएम प्रिंसिपल की भूमिका दी गई है

और फिर.

प्रॉम्प्ट 3: मैं gcloud का इस्तेमाल करने वाले Google सेवा खाते को Cloud SQL क्लाइंट की भूमिका कैसे असाइन करूं?

cloudsqlsa को Cloud SQL क्लाइंट की भूमिका असाइन करें.

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member="serviceAccount:cloudsqlsa@${PROJECT_ID}.iam.gserviceaccount.com" \
    --role="roles/cloudsql.client"

कुछ देर इंतज़ार करें और ऐप्लिकेशन को फिर से ऐक्सेस करने की कोशिश करें.

export EXTERNAL_IP=$(kubectl get svc shipping --output jsonpath='{.status.loadBalancer.ingress[0].ip}')
curl http://${EXTERNAL_IP}/packages/1

आउटपुट इससे मिलता-जुलता है:

{"depth":10.0,"height":10.0,"special_handling_instructions":"No special handling instructions.","weight":10.0,"width":10.0}

आपने इस समस्या को हल करने के लिए, Cloud Logging, लॉग एक्सप्लोरर, और लॉग एक्सप्लेनर सुविधा का इस्तेमाल करके, Duet AI का इस्तेमाल कर लिया है.

8. नतीजा

बधाई हो! आपने यह कोडलैब पूरा कर लिया है.

इस कोडलैब में, आपने ये बातें सीखी हैं:

1. अपने GCP प्रोजेक्ट में Duet AI को चालू करें. साथ ही, इसे IDE और Cloud Console में इस्तेमाल करने के लिए कॉन्फ़िगर करें.
2. कोड जनरेट करने, पूरा करने, और पूरी जानकारी पाने के लिए, Duet AI का इस्तेमाल करें.
3. किसी ऐप्लिकेशन से जुड़ी समस्या को समझाने और उसे हल करने के लिए, Duet AI का इस्तेमाल करें.
4. Duet AI की सुविधाएं, जैसे कि IDE चैट और मल्टी-टर्न चैट, चैट बनाम इनलाइन कोड जनरेशन, और स्मार्ट ऐक्शन. जैसे, कोड के बारे में पूरी जानकारी देना, बोलकर प्रॉम्प्ट देना वगैरह.

9. अन्य जानकारी

package-service.yaml

swagger: "2.0"
info:
 title: Shipping and Package Information API
 description: This API provides information about shipping and packages.
 version: 1.0.0
host: shipping.googleapis.com
schemes:
 - https
produces:
 - application/json
paths:
 /packages/{product_id}:
   get:
     summary: Get information about a package
     description: This method returns information about a package, including its height, width, depth, weight, and any special handling instructions.
     parameters:
       - name: product_id
         in: path
         required: true
         type: integer
         format: int64
     responses:
       "200":
         description: A successful response
         schema:
           type: object
           properties:
             height:
               type: integer
               format: int64
             width:
               type: integer
               format: int64
             depth:
               type: integer
               format: int64
             weight:
               type: integer
               format: int64
             special_handling_instructions:
               type: string
       "404":
         description: The product_id was not found

data_model.py

from sqlalchemy import Column, Integer, String, Float
from sqlalchemy.ext.declarative import declarative_base

from connect_connector import engine

Base = declarative_base()

class Package(Base):
    __tablename__ = 'packages'

    id = Column(Integer, primary_key=True)
    product_id = Column(Integer, nullable=False)
    height = Column(Float, nullable=False)
    width = Column(Float, nullable=False)
    depth = Column(Float, nullable=False)
    weight = Column(Float, nullable=False)
    special_handling_instructions = Column(String, nullable=True)

def create_tables():
    Base.metadata.create_all(engine)

if __name__ == '__main__':
    create_tables()

    print('Tables created successfully.')

connect_connector.py

import os

from google.cloud.sql.connector import Connector, IPTypes
import sqlalchemy

# You may need to manually import pg8000 and Base as follows
import pg8000
from sqlalchemy.ext.declarative import declarative_base


def connect_with_connector() -> sqlalchemy.engine.base.Engine:
   """Initializes a connection pool for a Cloud SQL instance of Postgres."""
   # Note: Saving credentials in environment variables is convenient, but not
   # secure - consider a more secure solution such as
   # Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
   # keep secrets safe.
   instance_connection_name = os.environ[
       "INSTANCE_CONNECTION_NAME"
   ]  # e.g. 'project:region:instance'
   db_user = os.environ["DB_USER"]  # e.g. 'my-database-user'
   db_pass = os.environ["DB_PASS"]  # e.g. 'my-database-password'
   db_name = os.environ["DB_NAME"]  # e.g. 'my-database'

   ip_type = IPTypes.PRIVATE if os.environ.get("PRIVATE_IP") else IPTypes.PUBLIC

   connector = Connector()

   def getconn() -> sqlalchemy.engine.base.Engine:
       conn: sqlalchemy.engine.base.Engine = connector.connect(
           instance_connection_name,
           "pg8000",
           user=db_user,
           password=db_pass,
           db=db_name,
           ip_type=ip_type,
       )
       return conn

   pool = sqlalchemy.create_engine(
       "postgresql+pg8000://",
       creator=getconn,
       # ...
   )
   return pool

# Create a connection pool
engine = connect_with_connector()

# Create a sessionmaker class to create new sessions
SessionMaker = sqlalchemy.orm.sessionmaker(bind=engine)

# Create a Base class for ORM
# You may need to manually fix the following
Base = declarative_base()

db_init.py

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from connect_connector import engine

from data_model import Package

def create_packages():
    # Create a session
    session = sessionmaker(bind=engine)()

    # Create 10 sample packages
    for i in range(10):
        package = Package(
            product_id=i,
            height=10.0,
            width=10.0,
            depth=10.0,
            weight=10.0,
            special_handling_instructions="No special handling instructions."
        )

        # Add the package to the session
        session.add(package)

    # Commit the changes
    session.commit()

if __name__ == '__main__':
    create_packages()

    print('Packages created successfully.')

main.py

from flask import Flask, request, jsonify

from data_model import Package
from connect_connector import SessionMaker

app = Flask(__name__)

session_maker = SessionMaker()

@app.route("/packages/<int:product_id>", methods=["GET"])
def get_package(product_id):
  """Get information about a package."""

  session = session_maker

  package = session.query(Package).filter(Package.product_id == product_id).first()

  if package is None:
    return jsonify({"message": "Package not found."}), 404

  return jsonify(
      {
          "height": package.height,
          "width": package.width,
          "depth": package.depth,
          "weight": package.weight,
          "special_handling_instructions": package.special_handling_instructions,
      }
  ), 200

if __name__ == "__main__":
  app.run(host="0.0.0.0")

test.py

import unittest

from data_model import Package
from connect_connector import SessionMaker

from main import app

class TestPackage(unittest.TestCase):

    def setUp(self):
        self.session_maker = SessionMaker()

    def tearDown(self):
        self.session_maker.close()

    def test_get_package(self):
        """Test the `get_package()` function."""

        package = Package(
        product_id=11, # Ensure that the product_id different from the sample data
        height=10,
        width=10,
        depth=10,
        weight=10,
        special_handling_instructions="Fragile",
        )

        session = self.session_maker

        session.add(package)
        session.commit()

        response = app.test_client().get("/packages/11")

        self.assertEqual(response.status_code, 200)

        self.assertEqual(
            response.json,
            {
                "height": 10,
                "width": 10,
                "depth": 10,
                "weight": 10,
                "special_handling_instructions": "Fragile",
            },
        )

if __name__ == "__main__":
    unittest.main()

requirements.txt

cloud-sql-python-connector==1.2.4
sqlalchemy==1.4.36
pg8000==1.22.0
Flask==3.0.0
gunicorn==20.1.0
psycopg2-binary==2.9.3

Dockerfile

FROM python:3.10-slim

WORKDIR /app

COPY . ./

RUN pip install -r requirements.txt

# Add these manually for your project
ENV INSTANCE_CONNECTION_NAME=YOUR_INSTANCE_CONNECTION_NAME
ENV DB_USER=evolution
ENV DB_PASS=evolution
ENV DB_NAME=product_details

CMD ["python", "main.py"]