1. मकसद
इस वर्कशॉप का मकसद, उपयोगकर्ताओं और पेशेवरों को Duet AI के बारे में व्यावहारिक जानकारी देना है.
इस कोडलैब में, आपको इनके बारे में जानकारी मिलेगी:
- अपने GCP प्रोजेक्ट में Duet AI को चालू करें. साथ ही, इसे IDE और Cloud Console में इस्तेमाल करने के लिए कॉन्फ़िगर करें.
- कोड जनरेट करने, उसे पूरा करने, और उसके बारे में जानकारी पाने के लिए, Duet AI का इस्तेमाल करें.
- Duet AI का इस्तेमाल करके, किसी ऐप्लिकेशन से जुड़ी समस्या के बारे में जानें और उसे हल करें.
- Duet AI की सुविधाएँ, जैसे कि IDE चैट और फ़ॉलो-अप चैट, चैट बनाम इनलाइन कोड जनरेशन, कोड के बारे में जानकारी देने और कोड को पढ़कर सुनाने की सुविधा जैसी स्मार्ट कार्रवाइयाँ वगैरह.
नैरेटिव
इस वर्कशॉप में, रोज़मर्रा के डेवलपमेंट में Duet AI for Developers का सही तरीके से इस्तेमाल करने का तरीका बताया गया है. इसके लिए, वर्कशॉप की गतिविधियों को एक कहानी के तौर पर पेश किया गया है.
कोई नया डेवलपर, ई-कॉमर्स कंपनी में शामिल होता है. उन्हें मौजूदा ई-कॉमर्स ऐप्लिकेशन में एक नई सेवा जोड़ने का काम सौंपा गया है. इस ऐप्लिकेशन में कई सेवाएं शामिल हैं. इस नई सेवा की मदद से, प्रॉडक्ट कैटलॉग में मौजूद प्रॉडक्ट के बारे में ज़्यादा जानकारी (डाइमेंशन, वज़न वगैरह) मिलती है. इस सेवा की मदद से, प्रॉडक्ट के डाइमेंशन और वज़न के आधार पर, शिपिंग के लिए खरीदार से लिए जाने वाले शुल्क को बेहतर/कम किया जा सकेगा.
डेवलपर कंपनी के लिए नया है. इसलिए, वह कोड जनरेट करने, कोड के बारे में जानकारी पाने, और दस्तावेज़ बनाने के लिए Duet AI का इस्तेमाल करेगा.
सेवा को कोड करने के बाद, प्लैटफ़ॉर्म एडमिन, आर्टफ़ैक्ट (डॉकर कंटेनर) बनाने के लिए Duet AI (चैट) का इस्तेमाल करेगा. साथ ही, आर्टफ़ैक्ट को GCP पर डिप्लॉय करने के लिए ज़रूरी संसाधन (जैसे, Artifact Registry, IAM अनुमतियां, कोड रिपॉज़िटरी, कंप्यूट इंफ़्रास्ट्रक्चर, जैसे कि GKE या CloudRun वगैरह) बनाएगा.
GCP पर ऐप्लिकेशन डिप्लॉय होने के बाद, ऐप्लिकेशन ऑपरेटर/एसआरई, नई सेवा में गड़बड़ी को ठीक करने के लिए Duet AI और Cloud Ops का इस्तेमाल करेगा.
पर्सोना
इस वर्कशॉप में, इन पर्सोना के बारे में बताया गया है:
- ऐप्लिकेशन डेवलपर - प्रोग्रामिंग और सॉफ़्टवेयर डेवलपमेंट के बारे में कुछ जानकारी होना ज़रूरी है.
Duet AI वर्कशॉप का यह वर्शन सिर्फ़ डेवलपर के लिए है. इसके लिए, GCP क्लाउड संसाधनों के बारे में जानकारी होना ज़रूरी नहीं है. इस ऐप्लिकेशन को चलाने के लिए, ज़रूरी GCP संसाधन बनाने के तरीके से जुड़ी स्क्रिप्ट यहां मिल सकती हैं. ज़रूरी GCP संसाधन डिप्लॉय करने के लिए, इस गाइड में दिए गए निर्देशों का पालन करें.
2. एनवायरमेंट तैयार किया जा रहा है
Duet AI को चालू करना
एपीआई (gcloud या Terraform जैसे IaC टूल) या Cloud Console के यूज़र इंटरफ़ेस (यूआई) के ज़रिए, किसी GCP प्रोजेक्ट में Duet AI को चालू किया जा सकता है.
Google Cloud प्रोजेक्ट में Duet AI को चालू करने के लिए, Cloud AI Companion API को चालू करें. साथ ही, उपयोगकर्ताओं को Cloud AI Companion User और Service Usage Viewer Identity and Access Management (IAM) की भूमिकाएं असाइन करें.
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. name@example.com
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.
USER खाते को Cloud AI Companion User और Service Usage Viewer की पहचान और ऐक्सेस मैनेजमेंट (आईएएम) भूमिकाएं असाइन करें. 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 पेज पर जाएं.
प्रोजेक्ट चुनने वाले टूल में जाकर, कोई प्रोजेक्ट चुनें.
चालू करें पर क्लिक करें.
पेज अपडेट हो जाता है और चालू है की स्थिति दिखाता है. Duet AI अब चुने गए Google Cloud प्रोजेक्ट में उन सभी उपयोगकर्ताओं के लिए उपलब्ध है जिनके पास ज़रूरी IAM भूमिकाएं हैं.
Duet AI का इस्तेमाल करने के लिए ज़रूरी आईएएम भूमिकाएं असाइन करने के लिए, आईएएम पेज पर जाएं.
प्रिंसिपल कॉलम में, उस USER को ढूंढें जिसके लिए आपको Duet AI का ऐक्सेस चालू करना है. इसके बाद, उस लाइन में मौजूद पेंसिल आइकॉन ✏️ प्रिंसिपल में बदलाव करें पर क्लिक करें.
बदलाव करें ऐक्सेस पैनल में, जोड़ें कोई और भूमिका जोड़ें पर क्लिक करें.
'भूमिका चुनें' में जाकर, Cloud AI Companion का इस्तेमाल करने वाला व्यक्ति चुनें.
दूसरी भूमिका जोड़ें पर क्लिक करें. इसके बाद, सेवा के इस्तेमाल की जानकारी देखने वाला को चुनें.
सेव करें पर क्लिक करें.
आईडीई सेट अप करना
डेवलपर अपनी ज़रूरतों के हिसाब से, कई तरह के आईडीई में से कोई भी चुन सकते हैं. Duet AI की मदद से कोड लिखने की सुविधा, कई आईडीई में उपलब्ध है. जैसे, Visual Studio Code, JetBrains IDEs (IntelliJ, PyCharm, GoLand, WebStorm वगैरह), Cloud Workstations, Cloud Shell Editor.
इस लैब में, Cloud Workstations या Cloud Shell Editor का इस्तेमाल किया जा सकता है.
इस वर्कशॉप में Cloud Shell Editor का इस्तेमाल किया जाता है.
ध्यान दें कि Cloud Workstations को सेट अप करने में 20 से 30 मिनट लग सकते हैं.
तुरंत इस्तेमाल करने के लिए, Cloud Shell Editor का इस्तेमाल करें.
Cloud Shell की सबसे ऊपर मौजूद मेन्यू बार में, पेंसिल आइकॉन ✏️ पर क्लिक करके Cloud Shell Editor खोलें.
Cloud Shell Editor का यूज़र इंटरफ़ेस (यूआई) और उपयोगकर्ता अनुभव (यूएक्स), VSCode से काफ़ी मिलता-जुलता है.
सेटिंग पैनल में जाने के लिए, CTRL (Windows में)/CMD (Mac में) + , (कॉमा) पर क्लिक करें.
खोज बार में, "duet ai" टाइप करें.
पक्का करें कि Cloudcode › Duet AI: Enable और Cloudcode › Duet AI › Inline Suggestions: Enable Auto चालू हो
सबसे नीचे मौजूद स्टेटस बार में, Cloud Code - Sign In पर क्लिक करें. इसके बाद, साइन इन करने के वर्कफ़्लो का पालन करें.
अगर आपने पहले से साइन इन किया हुआ है, तो स्टेटस बार में Cloud Code - No project दिखता है.
Cloud Code - No project पर क्लिक करें. इसके बाद, सबसे ऊपर कार्रवाई का ड्रॉपडाउन पैनल दिखेगा. कोई Google Cloud प्रोजेक्ट चुनें पर क्लिक करें.
अपना प्रोजेक्ट आईडी टाइप करना शुरू करें. इसके बाद, आपका प्रोजेक्ट सूची में दिखने लगेगा.
प्रोजेक्ट की सूची में से अपना PROJECT_ID चुनें.
सबसे नीचे मौजूद स्टेटस बार अपडेट हो जाता है और उसमें आपका प्रोजेक्ट आईडी दिखता है. अगर ऐसा नहीं होता है, तो आपको Cloud Shell Editor टैब को रीफ़्रेश करना पड़ सकता है.
बाईं ओर मौजूद मेन्यू बार में, Duet AI आइकॉन 
पर क्लिक करें. इसके बाद, Duet AI चैट विंडो दिखेगी. अगर आपको 'GCP प्रोजेक्ट चुनें' मैसेज दिखता है. प्रोजेक्ट पर क्लिक करें और उसे फिर से चुनें.
अब आपको Duet AI की चैट विंडो दिखेगी
3. इन्फ़्रास्ट्रक्चर सेट अप करना
GCP में नई शिपिंग सेवा चलाने के लिए, आपको इन GCP संसाधनों की ज़रूरत होगी:
- डेटाबेस के साथ Cloud SQL इंस्टेंस.
- कंटेनर वाली सेवा को चलाने के लिए, GKE क्लस्टर.
- डॉकर इमेज को सेव करने के लिए, Artifact Registry.
- कोड के लिए Cloud Source Repository.
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
4. Python Flask सेवा डेवलप करना
हम जो सेवा बनाएंगे उसमें ये फ़ाइलें शामिल होंगी. आपको अभी ये फ़ाइलें बनाने की ज़रूरत नहीं है. इन्हें एक-एक करके बनाया जाएगा. इसके लिए, नीचे दिए गए निर्देशों का पालन करें:
package-service.yaml- यह पैकेज सेवा के लिए Open API स्पेसिफ़िकेशन है. इसमें ऊंचाई, चौड़ाई, वज़न, और खास हैंडलिंग के निर्देश जैसे डेटा शामिल होते हैं.data_model.py- पैकेज-सेवा एपीआई स्पेसिफ़िकेशन के लिए डेटा मॉडल. यह product_details DB मेंpackagesटेबल भी बनाता है.connect_connector.py- CloudSQL कनेक्शन (इंजन, सेशन, और बेस ओआरएम तय करता है)db_init.py- इससेpackagesटेबल में सैंपल डेटा जनरेट होता है.main.py- यह Python Flask सेवा है. इसमेंGETएंडपॉइंट होता है. इसकी मदद से, product_id के आधार परpackagesडेटा से पैकेज की जानकारी मिलती है.test.py- यूनिट टेस्टrequirement.txt- Python की ज़रूरी शर्तेंDockerfile- इस ऐप्लिकेशन को कंटेनर में रखने के लिए
अगर आपको एक्सरसाइज़ के दौरान कोई समस्या आती है, तो रेफ़रंस के लिए फ़ाइनल फ़ाइलें इस कोडलैब के APPENDIX में मौजूद हैं.
पिछले चरण में, आपने Cloud Source Repository बनाई थी. डेटा स्टोर करने की जगह को क्लोन करें. क्लोन की गई रिपॉज़िटरी फ़ोल्डर में ऐप्लिकेशन फ़ाइलें बनाई जाएंगी.
रिपॉज़िटरी को क्लोन करने के लिए, Cloud Shell टर्मिनल में यह कमांड चलाएं.
cd ~ gcloud source repos clone shipping shipping cd ~/shipping
Cloud Shell Editor के बाईं ओर मौजूद मेन्यू से, Duet AI चैट साइडबार खोलें. यह आइकॉन 
जैसा दिखता है. अब कोड लिखने में मदद पाने के लिए, Duet AI का इस्तेमाल किया जा सकता है.
package-service.yaml
कोई भी फ़ाइल खोले बिना, Duet से शिपिंग सेवा के लिए Open API स्पेसिफ़िकेशन जनरेट करने के लिए कहें.
पहला प्रॉम्प्ट: किसी ऐसी सेवा के लिए OpenAPI yaml स्पेसिफ़िकेशन जनरेट करो जो संख्यात्मक प्रॉडक्ट आईडी के आधार पर शिपिंग और पैकेज की जानकारी देती है. सेवा में पैकेज की ऊंचाई, चौड़ाई, गहराई, वज़न, और उसे खास तरीके से हैंडल करने के निर्देशों के बारे में जानकारी शामिल होनी चाहिए.
जनरेट किए गए कोड की विंडो में, सबसे ऊपर दाईं ओर तीन विकल्प दिए गए हैं.
आपके पास कोड को COPY 
करने और उसे किसी फ़ाइल में चिपकाने का विकल्प होता है.
एडिटर में फ़िलहाल खुली हुई फ़ाइल में कोड को ADD 
किया जा सकता है.
इसके अलावा, कोड को नई फ़ाइल में OPEN 
किया जा सकता है.
OPEN पर क्लिक करें कोड को नई फ़ाइल में डालें.
फ़ाइल को सेव करने के लिए, CTRL/CMD + s पर क्लिक करें. इसके बाद, फ़ाइल को ऐप्लिकेशन फ़ोल्डर में package-service.yaml नाम से सेव करें. ठीक पर क्लिक करें.
आखिरी फ़ाइल, इस कोडलैब के APPENDIX सेक्शन में है. अगर ऐसा नहीं होता है, तो मैन्युअल तरीके से ज़रूरी बदलाव करें.
Duet AI के जवाब देखने के लिए, अलग-अलग प्रॉम्प्ट आज़माए जा सकते हैं.
Duet AI के चैट इतिहास को रीसेट करने के लिए, Duet AI के साइडबार में सबसे ऊपर मौजूद ट्रैश आइकॉन 
पर क्लिक करें.
data_model.py
इसके बाद, OpenAPI स्पेसिफ़िकेशन के आधार पर, सेवा के लिए डेटा मॉडल की Python फ़ाइल बनाई जाती है.
package-service.yaml फ़ाइल खुली होने पर, यह प्रॉम्प्ट डालें.
पहला प्रॉम्प्ट: Python sqlalchemy ORM का इस्तेमाल करके, इस एपीआई सेवा के लिए डेटा मॉडल जनरेट करें. इसके अलावा, एक अलग फ़ंक्शन और एक मुख्य एंट्रीपॉइंट भी शामिल करें, जो डेटाबेस टेबल बनाता है.
आइए, जनरेट किए गए हर हिस्से पर एक नज़र डालें. Duet AI अब भी एक असिस्टेंट है. यह कोड को तेज़ी से लिखने में आपकी मदद कर सकता है. हालांकि, आपको जनरेट किए गए कॉन्टेंट की समीक्षा करनी चाहिए और उसे समझना चाहिए.
सबसे पहले, क्लास Package है, जो तरह Base की है. यह packages डेटाबेस के लिए डेटा मॉडल तय करती है. जैसे:
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)
आखिर में, आपको एक मुख्य फ़ंक्शन की ज़रूरत होगी, जो create_tables फ़ंक्शन को चलाकर CloudSQL डेटाबेस में टेबल बनाए. जैसे, यहां दिखाया गया है:
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 फ़ाइल खुली होने पर, ये प्रॉम्प्ट डालें.
पहला प्रॉम्प्ट: cloud-sql-python-connector लाइब्रेरी का इस्तेमाल करके, एक ऐसा फ़ंक्शन जनरेट करें जो Postgres के Cloud SQL इंस्टेंस के लिए कनेक्शन पूल को शुरू करता हो.
ध्यान दें कि जवाब में cloud-sql-python-connector लाइब्रेरी का इस्तेमाल नहीं किया गया है. Duet को बेहतर जवाब देने के लिए, प्रॉम्प्ट को बेहतर बनाया जा सकता है. इसके लिए, उसी चैट थ्रेड में ज़्यादा जानकारी जोड़ें.
चलिए, कोई दूसरा प्रॉम्प्ट इस्तेमाल करते हैं.
दूसरा प्रॉम्प्ट: cloud-sql-python-connector लाइब्रेरी का इस्तेमाल करना ज़रूरी है.
पक्का करें कि इसमें cloud-sql-python-connector लाइब्रेरी का इस्तेमाल किया गया हो.
OPEN का इस्तेमाल करके, कोड को पहले की तरह नए फ़ाइल वर्कफ़्लो में जोड़ें. कोड को connect_conector.py नाम की फ़ाइल में सेव करें. आपको pg8000 लाइब्रेरी को मैन्युअल तरीके से इंपोर्ट करना पड़ सकता है. कृपया नीचे दी गई फ़ाइल देखें.
Duet AI की चैट का इतिहास मिटाओ. साथ ही, connect_connector.py फ़ाइल खुली होने पर, ऐप्लिकेशन में इस्तेमाल करने के लिए DB engine, sessionmaker, और base ओआरएम जनरेट करो.
पहला प्रॉम्प्ट: connect_with_connector तरीके का इस्तेमाल करके, इंजन, sessionmaker क्लास, और Base ORM बनाएं
जवाब में, connect_connector.py फ़ाइल में engine, Session, और Base को जोड़ा जा सकता है.
आखिरी फ़ाइल, इस कोडलैब के APPENDIX सेक्शन में है. अगर ऐसा नहीं होता है, तो मैन्युअल तरीके से ज़रूरी बदलाव करें.
Duet AI के जवाबों में संभावित बदलाव देखने के लिए, अलग-अलग प्रॉम्प्ट आज़माए जा सकते हैं.
Duet AI के चैट इतिहास को रीसेट करने के लिए, Duet AI के साइडबार में सबसे ऊपर मौजूद ट्रैश आइकॉन पर क्लिक करें.
data_model.py को अपडेट किया जा रहा है
CloudSQL डेटाबेस में टेबल बनाने के लिए, आपको पिछले चरण में बनाए गए इंजन (connect_connector.py फ़ाइल में) का इस्तेमाल करना होगा.
Duet AI के साथ की गई चैट का इतिहास मिटाएं. data_model.py फ़ाइल खोलें. यह प्रॉम्प्ट आज़माएं.
पहला प्रॉम्प्ट: main फ़ंक्शन में, connect_connector.py से इंजन को इंपोर्ट करें और उसका इस्तेमाल करें
आपको connect_connector (CloudSQL के लिए) से engine इंपोर्ट करने का जवाब दिखेगा. create_table, डिफ़ॉल्ट sqlite लोकल डीबी के बजाय उस इंजन का इस्तेमाल करता है.
data_model.py फ़ाइल अपडेट करें.
आखिरी फ़ाइल, इस कोडलैब के APPENDIX सेक्शन में है. अगर ऐसा नहीं होता है, तो मैन्युअल तरीके से ज़रूरी बदलाव करें.
Duet AI से अलग-अलग जवाब पाने के लिए, अलग-अलग प्रॉम्प्ट आज़माए जा सकते हैं.
Duet AI के चैट इतिहास को रीसेट करने के लिए, Duet AI के साइडबार में सबसे ऊपर मौजूद ट्रैश आइकॉन पर क्लिक करें.
requirements.txt
ऐप्लिकेशन के लिए requirements.txt फ़ाइल बनाएं.
connect_connector.py और data_model.py फ़ाइल, दोनों खोलें. इसके बाद, यह प्रॉम्प्ट डालें.
पहला प्रॉम्प्ट: इस डेटा मॉडल और सेवा के लिए, pip की ज़रूरी शर्तों वाली फ़ाइल जनरेट करो
दूसरा प्रॉम्प्ट: इस डेटा मॉडल और सेवा के लिए, pip की ज़रूरी शर्तों वाली फ़ाइल जनरेट करो. इसके लिए, नए वर्शन का इस्तेमाल करो
पुष्टि करें कि नाम और वर्शन सही हों. उदाहरण के लिए, ऊपर दिए गए जवाब में 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.
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 फ़ाइल खुली होने पर, ये प्रॉम्प्ट आज़माएँ.
पहला प्रॉम्प्ट: ऐसा फ़ंक्शन जनरेट करो जो पैकेज टेबल में 10 सैंपल पैकेज की लाइनें बनाए और उन्हें सेव करे
दूसरा प्रॉम्प्ट: connect_connector से मिले सेशन का इस्तेमाल करके, एक ऐसा फ़ंक्शन जनरेट करें जो पैकेज टेबल में 10 सैंपल पैकेज वाली लाइनें बनाता हो और उन्हें सेव करता हो
OPEN का इस्तेमाल करके, कोड को पहले की तरह नए फ़ाइल वर्कफ़्लो में जोड़ें. कोड को db_init.py नाम की फ़ाइल में सेव करें.
आखिरी फ़ाइल, इस कोडलैब के APPENDIX सेक्शन में है. अगर ऐसा नहीं होता है, तो मैन्युअल तरीके से ज़रूरी बदलाव करें.
Duet AI से अलग-अलग जवाब पाने के लिए, अलग-अलग प्रॉम्प्ट आज़माए जा सकते हैं.
Duet AI के चैट इतिहास को रीसेट करने के लिए, Duet AI के साइडबार में सबसे ऊपर मौजूद ट्रैश आइकॉन पर क्लिक करें.
सैंपल पैकेज का डेटा बनाना
कमांड लाइन से db_init.py चलाएं.
python db_init.py
आउटपुट इस तरह का होता है:
Packages created successfully.
CloudSQL इंस्टेंस से फिर से कनेक्ट करें और पुष्टि करें कि सैंपल डेटा को packages टेबल में जोड़ दिया गया है.
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 बनाएं.
पहला प्रॉम्प्ट: python flask लाइब्रेरी का इस्तेमाल करके, इस सेवा के लिए एचटीटीपी रेस्ट एंडपॉइंट का इस्तेमाल करने वाला एक इंप्लीमेंटेशन बनाएं
दूसरा प्रॉम्प्ट: Python फ़्लास्क लाइब्रेरी का इस्तेमाल करके, इस सेवा के लिए एचटीटीपी रेस्ट एंडपॉइंट का इस्तेमाल करने वाला एक प्रोग्राम बनाएं. connect_conector.py से SessionMaker को इंपोर्ट करें और पैकेज के डेटा के लिए इसका इस्तेमाल करें.
तीसरा प्रॉम्प्ट: python flask लाइब्रेरी का इस्तेमाल करके, इस सेवा के लिए http rest एंडपॉइंट का इस्तेमाल करने वाला एक प्रोग्राम बनाएं. पैकेज के डेटा के लिए, data_model.py से पैकेज और connect_conector.py से SessionMaker को इंपोर्ट करें और उनका इस्तेमाल करें.
चौथा प्रॉम्प्ट: Python Flask लाइब्रेरी का इस्तेमाल करके, इस सेवा के लिए एचटीटीपी रेस्ट एंडपॉइंट का इस्तेमाल करने वाला एक प्रोग्राम बनाएं. packages डेटा के लिए, data_model.py से पैकेज और connect_conector.py से SessionMaker को इंपोर्ट करें और उनका इस्तेमाल करें. Use host IP 0.0.0.0 for app.run
main.py के लिए ज़रूरी शर्तें अपडेट करें.
प्रॉम्प्ट: main.py के लिए ज़रूरी फ़ाइल बनाओ
इसे requirements.txt फ़ाइल में जोड़ें. पक्का करें कि Flask के 3.0.0 वर्शन का इस्तेमाल किया जा रहा हो.
OPEN का इस्तेमाल करके, कोड को पहले की तरह नए फ़ाइल वर्कफ़्लो में जोड़ें. कोड को main.py नाम की फ़ाइल में सेव करें.
आखिरी फ़ाइल, इस कोडलैब के APPENDIX सेक्शन में है. अगर ऐसा नहीं होता है, तो मैन्युअल तरीके से ज़रूरी बदलाव करें.
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 फ़ाइल खुली होने पर, यूनिट टेस्ट जनरेट करें.
पहला प्रॉम्प्ट: यूनिट टेस्ट जनरेट करो.
OPEN का इस्तेमाल करके, कोड को पहले की तरह नए फ़ाइल वर्कफ़्लो में जोड़ें. कोड को test.py नाम की फ़ाइल में सेव करें.
test_get_package फ़ंक्शन में, product_id तय होना चाहिए. इसे मैन्युअल तरीके से जोड़ा जा सकता है.
आखिरी फ़ाइल, इस कोडलैब के APPENDIX सेक्शन में है. अगर ऐसा नहीं होता है, तो मैन्युअल तरीके से ज़रूरी बदलाव करें.
Duet AI के चैट इतिहास को रीसेट करने के लिए, Duet AI के साइडबार में सबसे ऊपर मौजूद ट्रैश आइकॉन पर क्लिक करें.
यूनिट टेस्ट चलाना
यूनिट टेस्ट चलाएं.
python test.py
आउटपुट इस तरह का होता है:
. ---------------------------------------------------------------------- Ran 1 test in 1.061s OK
Cloud Shell Editor में मौजूद सभी फ़ाइलें बंद करें. इसके बाद, सबसे ऊपर मौजूद स्टेटस बार में, ट्रैश आइकॉन 
पर क्लिक करके चैट का इतिहास मिटाएं.
Dockerfile
इस ऐप्लिकेशन के लिए Dockerfile जनरेट करो.
main.py खोलें और यहाँ दिए गए प्रॉम्प्ट आज़माएँ.
पहला प्रॉम्प्ट: इस ऐप्लिकेशन के लिए Dockerfile जनरेट करो.
दूसरा प्रॉम्प्ट: इस ऐप्लिकेशन के लिए 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 नाम की फ़ाइल में सेव करें.
आखिरी फ़ाइल, इस कोडलैब के APPENDIX सेक्शन में है. अगर ऐसा नहीं होता है, तो मैन्युअल तरीके से ज़रूरी बदलाव करें.
ऐप्लिकेशन को स्थानीय तौर पर चलाना
Dockerfile खोलकर, यह प्रॉम्प्ट आज़माएँ.
पहला प्रॉम्प्ट: इस 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
Pods के चालू होने और सेवा को बाहरी लोड बैलेंसर का आईपी पता असाइन होने तक इंतज़ार करें.
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 Autopilot क्लस्टर के लिए, संसाधनों के तैयार होने तक कुछ देर इंतज़ार करें.
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 Client 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
पॉड के रीस्टार्ट होने के बाद, 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 से गड़बड़ी को ठीक करने में मदद लें.
यह प्रॉम्प्ट आज़माएं.
पहला प्रॉम्प्ट: इस गड़बड़ी को ठीक करने में मेरी मदद करो
प्रॉम्प्ट में गड़बड़ी का मैसेज डालें.
प्रॉम्प्ट 2: अनुमति नहीं है: ऐसा लगता है कि पुष्टि किए गए IAM प्रिंसिपल को एपीआई अनुरोध करने की अनुमति नहीं है. पुष्टि करें कि आपके GCP प्रोजेक्ट में ‘Cloud SQL एडमिन एपीआई' चालू हो और IAM प्रिंसिपल को ‘Cloud SQL क्लाइंट' की भूमिका दी गई हो
इसके बाद.
तीसरा प्रॉम्प्ट: 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, Log Explorer, और Log Explainer सुविधा में Duet AI का इस्तेमाल किया है.
8. नतीजा
बधाई हो! आपने इस कोडलैब को पूरा कर लिया है.
इस कोडलैब में, आपने इनके बारे में जाना:
- अपने GCP प्रोजेक्ट में Duet AI को चालू करें. साथ ही, इसे IDE और Cloud Console में इस्तेमाल करने के लिए कॉन्फ़िगर करें.
- कोड जनरेट करने, उसे पूरा करने, और उसके बारे में जानकारी पाने के लिए, Duet AI का इस्तेमाल करें.
- Duet AI का इस्तेमाल करके, किसी ऐप्लिकेशन से जुड़ी समस्या के बारे में जानें और उसे हल करें.
- 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"]