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

Gemini Code Assist की मदद से, अपने डेवलपमेंट वर्कफ़्लो को बेहतर बनाएं

1. शुरुआती जानकारी

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

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

आपको क्या करना होगा

शुरुआत से OpenAPI स्पेसिफ़िकेशन के आधार पर, वेब ऐप्लिकेशन डिज़ाइन करें, बनाएं, टेस्ट करें, और डिप्लॉय करें

आपको इनके बारे में जानकारी मिलेगी

OpenAPI की खास जानकारी जनरेट करने के लिए, Gemini Code Assist इस्तेमाल करने का तरीका
OpenAPI की खास बातों के लिए Python फ़्लास्क ऐप्लिकेशन डेवलप करने के लिए, Gemini Code Assist कोड जनरेट करने की सुविधाओं को इस्तेमाल करने का तरीका
Gemini Code Assist इस्तेमाल करके, Python Flask ऐप्लिकेशन के लिए वेब फ़्रंट-एंड जनरेट करने का तरीका
Google Cloud Run पर ऐप्लिकेशन को डिप्लॉय करने के बारे में मदद पाने के लिए, Gemini Code Assist इस्तेमाल करने का तरीका
ऐप्लिकेशन बनाते और टेस्ट करते समय, कोड एक्सप्लेनेशन और टेस्ट केस जनरेट करने जैसी Gemini Code Assist सुविधाओं का इस्तेमाल करें

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

Chrome वेब ब्राउज़र
Gmail खाता
ऐसा क्लाउड प्रोजेक्ट जिसमें बिलिंग की सुविधा चालू हो
आपके Cloud प्रोजेक्ट के लिए, Gemini Code Assist की सुविधा चालू कर दी गई है

यह लैब सभी लेवल के डेवलपर के लिए है. इनमें नए उपयोगकर्ता भी शामिल हैं. ऐप्लिकेशन का सैंपल Python भाषा में है, लेकिन आपको इसे समझने के लिए Python प्रोग्रामिंग के बारे में जानने की ज़रूरत नहीं है. हम आपको Gemini Code Assist की सुविधाओं के बारे में जानकारी देंगे.

2. कोड से जुड़ी सहायता देने वाली Gemini की सुविधा सेटअप करें

इस सेक्शन में वह सब कुछ बताया गया है जो आपको इस लैब का इस्तेमाल शुरू करने के लिए करना होगा.

Cloud Shell IDE में Gemini Code असिस्ट की सुविधा चालू करना

अन्य कोडलैब के लिए, हम Cloud Shell IDE का इस्तेमाल करेंगे. यह पूरी तरह से मैनेज किया गया कोड ओएसएस पर आधारित डेवलपमेंट एनवायरमेंट है. हमें Cloud Shell IDE में Code Assist को चालू और कॉन्फ़िगर करना होगा. इसके लिए, यह तरीका अपनाएं:

ide.cloud.google.com पर जाएं. IDE को दिखने में कुछ समय लग सकता है, इसलिए कृपया थोड़ा इंतज़ार करें और सेटअप के डिफ़ॉल्ट विकल्पों को स्वीकार करें. अगर आपको IDE सेट अप करने के बारे में कुछ निर्देश दिखते हैं, तो कृपया आगे बढ़ें और डिफ़ॉल्ट सेटिंग के साथ उन्हें पूरा करें.
सबसे नीचे स्टेटस बार में, दिखाए गए तरीके से Cloud कोड - साइन इन करें बटन पर क्लिक करें. निर्देश के अनुसार प्लग इन को अनुमति दें. अगर आपको स्टेटस बार में "Cloud Code - कोई प्रोजेक्ट नहीं है" दिखता है, तो उसे चुनें. इसके बाद, उन प्रोजेक्ट की सूची में से Google Cloud प्रोजेक्ट चुनें जिन पर आपको काम करना है.

सबसे नीचे दाएं कोने में, कोड असिस्ट बटन पर क्लिक करें. इसके बाद, आखिरी बार सही Google Cloud प्रोजेक्ट चुनें. अगर आपसे Cloud AI Companion API को चालू करने के लिए कहा गया है, तो कृपया इसे चालू करें और आगे बढ़ें.
Google Cloud प्रोजेक्ट चुनने के बाद, यह पक्का करें कि आपको स्टेटस बार के Cloud Code स्थिति मैसेज में यह जानकारी दिख रही हो. साथ ही, यह भी दिख रहा हो कि आपने कोड असिस्ट को चालू किया है. यह स्टेटस बार में दाईं ओर मौजूद स्टेटस बार में दिखता है:

Gemini Code Assist का इस्तेमाल किया जा सकता है!

3. Firestore सेटअप करें

Cloud Firestore पूरी तरह से मैनेज किया गया बिना सर्वर वाला दस्तावेज़ डेटाबेस है. इसका इस्तेमाल हम अपने ऐप्लिकेशन के डेटा के लिए बैकएंड के तौर पर करेंगे. Cloud Firestore में मौजूद डेटा को दस्तावेज़ों के कलेक्शन में व्यवस्थित किया गया है.

हमें अपने डिफ़ॉल्ट Firestore डेटाबेस में sessions नाम का एक कलेक्शन बनाना होगा. इस कलेक्शन में सैंपल डेटा (दस्तावेज़) होगा. डेटा का इस्तेमाल हम ऐप्लिकेशन में करेंगे.

मुख्य मेन्यू के ज़रिए अपने Cloud Shell IDE के अंदर से Terminal खोलें, जैसा कि नीचे दिखाया गया है:

हमें sessions नाम का एक कलेक्शन बनाना होगा. इसमें, सेशन के सैंपल दस्तावेज़ों की एक सूची होगी. हर दस्तावेज़ में नीचे दिए गए एट्रिब्यूट होंगे:

title: स्ट्रिंग
कैटगरी: स्ट्रिंग का अरे
स्पीकर: स्ट्रिंग का अरे
duration: स्ट्रिंग
summary: स्ट्रिंग

इस कलेक्शन में सैंपल डेटा भरने के लिए, आपको उस फ़ाइल को कॉपी करना होगा जिसमें सैंपल डेटा मौजूद हो. इसके लिए, आपके प्रोजेक्ट में एक बकेट का इस्तेमाल करें. यहां से, gcloud firestore import कमांड का इस्तेमाल करके कलेक्शन को इंपोर्ट किया जा सकता है.

Firestore डेटाबेस को शुरू करना

Cloud Console में फ़ायरस्टोर पेज पर जाएं.

अगर आपने प्रोजेक्ट में पहले कोई Firestore डेटाबेस शुरू नहीं किया है, तो default डेटाबेस बनाएं. डेटाबेस बनाते समय, इन वैल्यू का इस्तेमाल करें:

Firestore मोड: Native
जगह की जानकारी: जगह का टाइप Region चुनें और ऐप्लिकेशन के हिसाब से सही इलाका चुनें. इस जगह को नोट कर लें, क्योंकि बकेट की जगह के लिए अगले चरण में आपको इसकी ज़रूरत होगी.
डेटाबेस बनाएं.

अब हम sessions कलेक्शन बनाएंगे. इसके लिए, यह तरीका अपनाएं:

नीचे दिए गए gsutil निर्देश की मदद से, अपने प्रोजेक्ट में बकेट बनाएं. नीचे दिए गए निर्देश में, <PROJECT_ID> वैरिएबल को अपने Google Cloud प्रोजेक्ट आईडी से बदलें. <BUCKET_LOCATION> की जगह कोई ऐसा इलाका डालें जो आपके डिफ़ॉल्ट Firestore डेटाबेस की भौगोलिक जगह से मेल खाता हो (जैसा कि पिछले चरण में बताया गया है), यह US-WEST1, EUROPE-WEST1, ASIA-EAST1 हो सकता है :

gsutil mb -l <BUCKET-LOCATION> gs://<PROJECT_ID>-my-bucket

बकेट बनाने के बाद, हमें इस बकेट में तैयार किए गए डेटाबेस एक्सपोर्ट को कॉपी करना होगा, ताकि हम उसे Firebase डेटाबेस में इंपोर्ट कर सकें. यहां दिए गए निर्देश का इस्तेमाल करें:

gsutil cp -r gs://sessions-master-database-bucket/2024-03-26T09:28:15_95256  gs://<PROJECT_ID>-my-bucket

अब हमारे पास इंपोर्ट करने के लिए डेटा है. इसलिए, अब हम अपने बनाए गए Firebase डेटाबेस (default) में डेटा इंपोर्ट करने के आखिरी चरण पर जा सकते हैं.

नीचे दिए गए gcloud कमांड का इस्तेमाल करें:

gcloud firestore import gs://<PROJECT_ID>-my-bucket/2024-03-26T09:28:15_95256

इंपोर्ट होने में कुछ सेकंड लगेंगे. इसके पूरा होने के बाद, आपके पास अपने Firestore डेटाबेस और कलेक्शन की पुष्टि करने का विकल्प होगा. इसके लिए, https://console.cloud.google.com/firestore/databases पर जाएं. इसके बाद, default डेटाबेस और sessions कलेक्शन को चुनें, जैसा कि यहां दिखाया गया है:

इसके बाद, हम अपने ऐप्लिकेशन में इस्तेमाल किए जाने वाले Firestore कलेक्शन बनाने की प्रक्रिया पूरी कर लेंगे.

4. ऐप्लिकेशन टेंप्लेट बनाएं

हम एक सैंपल ऐप्लिकेशन (Python Flask ऐप्लिकेशन) बनाएंगे, जिसका इस्तेमाल हम कोडलैब के बाकी हिस्सों में करेंगे. यह ऐप्लिकेशन, तकनीकी कॉन्फ़्रेंस के दौरान ऑफ़र किए जाने वाले सभी सेशन में खोज करेगा.

यह तरीका अपनाएं:

नीचे दिए गए स्टेटस बार में, Google Cloud प्रोजेक्ट के नाम पर क्लिक करें.

विकल्पों की एक सूची दिखेगी. नीचे दी गई सूची में, नया ऐप्लिकेशन पर क्लिक करें.

Cloud Run ऐप्लिकेशन चुनें (यह हमारे ऐप्लिकेशन का रनटाइम होगा).
Python (Flask): Cloud Run ऐप्लिकेशन टेंप्लेट चुनें.
ऐप्लिकेशन को नाम दें और उसे अपने पसंदीदा जगह पर सेव करें.
एक सूचना पुष्टि करती है कि आपका ऐप्लिकेशन बना दिया गया है और एक नई विंडो खुलती है, जिसमें आपका ऐप्लिकेशन लोड हो जाता है, जैसा कि नीचे दिखाया गया है. README.md फ़ाइल खुली है. फ़िलहाल, उस व्यू को बंद किया जा सकता है.

5. Gemini Code Assist से इंटरैक्ट करना

इस लैब के लिए, हम Cloud Shell IDE में मौजूद Gemini Code Assist Chat का इस्तेमाल, वीएस कोड में Cloud Code एक्सटेंशन के तौर पर करेंगे. बाईं ओर मौजूद नेविगेशन बार में, कोड असिस्ट बटन पर क्लिक करके इसे ऊपर लाया जा सकता है. बाईं ओर मौजूद नेविगेशन टूलबार में, कोड असिस्ट आइकॉन खोजें और उस पर क्लिक करें.

इससे Cloud Shell IDE में Code Assist चैट पैनल खुल जाएगा और कोड असिस्ट से चैट की जा सकेगी.

सबसे ऊपर ट्रैश कैन के आइकन पर ध्यान दें - यह Code Assist चैट इतिहास के लिए संदर्भ को रीसेट करने का आपका तरीका है. ध्यान दें कि यह चैट इंटरैक्शन उस फ़ाइल(फ़ाइलों) के हिसाब से है जिस पर आप IDE में काम कर रहे हैं.

6. एपीआई डिज़ाइन

हमारा पहला कदम, डिज़ाइन के दौरान Gemini Code Assist की मदद लेना होगा. इस चरण में, हम उन इकाइयों (किसी इवेंट के तकनीकी सेशन) के लिए OpenAPI की खास जानकारी जनरेट करेंगे जिनमें हम खोज करना चाहते हैं.

यह प्रॉम्प्ट दें:

Generate an Open API spec that will allow me to retrieve all sessions, sessions by category, session by id. Each session has the following attributes: id, title, list of speakers, list of categories, summary and duration.

इसे अलग-अलग क्वेरी पैरामीटर के ज़रिए, सभी सेशन में खोजने के लिए OpenAPI स्पेसिफ़िकेशन जनरेट करना चाहिए. स्पेसिफ़िकेशन का सैंपल यहां दिया गया है:

openapi: 3.0.0
info:
 title: Sessions API
 description: This API allows you to retrieve all sessions, sessions by category, and session by id.
 version: 1.0.0
servers:
 - url: https://sessions.example.com
paths:
 /sessions:
   get:
     summary: Get all sessions
     operationId: getSessions
     responses:
       '200':
         description: OK
         content:
           application/json:
             schema:
               type: array
               items:
                 $ref: '#/components/schemas/Session'
 /sessions/{id}:
   get:
     summary: Get session by id
     operationId: getSessionById
     parameters:
       - name: id
         in: path
         required: true
         description: The id of the session
         schema:
           type: string
     responses:
       '200':
         description: OK
         content:
           application/json:
             schema:
               $ref: '#/components/schemas/Session'
 /sessions/categories/{category}:
   get:
     summary: Get sessions by category
     operationId: getSessionsByCategory
     parameters:
       - name: category
         in: path
         required: true
         description: The category of the sessions
         schema:
           type: string
     responses:
       '200':
         description: OK
         content:
           application/json:
             schema:
               type: array
               items:
                 $ref: '#/components/schemas/Session'
components:
 schemas:
   Session:
     type: object
     properties:
       id:
         type: string
         description: The id of the session
       title:
         type: string
         description: The title of the session
       speakers:
         type: array
         items:
           type: string
         description: The list of speakers for the session
       categories:
         type: array
         items:
           type: string
         description: The list of categories for the session
       summary:
         type: string
         description: The summary of the session
       duration:
         type: string
         description: The duration of the session

यह देखा जा सकता है कि स्पेसिफ़िकेशन में ये चीज़ें शामिल हैं:

सेशन टाइप के लिए तय किया गया स्कीमा.
कई एपीआई पाथ तय किए गए:
/sessions
/sessions/{id}
/sessions/categories/{category}

सबसे ऊपर मौजूद फ़ोल्डर में sessionsapi.yaml नाम की फ़ाइल बनाएं और "मौजूदा फ़ाइल विकल्प में डालें" (+ बटन) का इस्तेमाल करके, Code Assist चैट विंडो से कॉन्टेंट को कॉपी करें. इसके बाद, फ़ाइल को Cloud Shell IDE में खोलकर रखें.

अब Gemini Code Assist की दिलचस्प सुविधा के बारे में बताया जा सकता है: उद्धरण. यह जानकारी डेवलपर को तब दिखती है, जब जनरेट किया गया कोड किसी दूसरे सोर्स, जैसे कि मौजूदा ओपन सोर्स कोड से सीधे तौर पर कोट करता है. वह डेवलपर को सोर्स और लाइसेंस देता है, ताकि वह यह तय कर सके कि उस पर क्या कार्रवाई करनी है.

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

7. ऐप्लिकेशन जनरेट करें

अब हम Code Assist से ऐप्लिकेशन जनरेट करने के लिए कहेंगे. sessionsapi.yaml फ़ाइल खुली होने पर, यह प्रॉम्प्ट दें.

Generate a Python Application using the Flask framework, based on the sessionsapi.yaml file. This application uses a local in memory list of sessions. Do not use any Flask extensions.

इससे आपको Python फ़्लास्क ऐप्लिकेशन के लिए एक ढांचा मिलेगा, जो OpenAPI स्पेसिफ़िकेशन फ़ाइल में बताए गए फ़ंक्शन और पाथ पर आधारित है.

इस बात की संभावना है कि Gemini Code Assist, flask_restfull जैसे चुनिंदा फ़्लास्क एक्सटेंशन का इस्तेमाल करके कोड जनरेट कर सकता है. अगर ऐसा है, तो आप एक फ़ॉलो-ऑन प्रॉम्प्ट जारी कर सकते हैं, जिसमें साफ़ तौर पर कुछ ऐसा लिखा होगा, "XYZ एक्सटेंशन का इस्तेमाल न करें" और आपको ऐसा कोड मिलेगा जो खुद कोर फ़्लास्क फ़्रेमवर्क का इस्तेमाल कर रहा है.

दिया गया Python फ़्लास्क ऐप्लिकेशन कोड नीचे दिए गए कोड की तरह ही होना चाहिए:

from flask import Flask, jsonify, request

app = Flask(__name__)

sessions = [
    {
        "id": "1",
        "title": "Session 1",
        "speakers": ["Speaker 1", "Speaker 2"],
        "categories": ["Category 1", "Category 2"],
        "summary": "This is a summary of session 1.",
        "duration": "1 hour",
    },
    {
        "id": "2",
        "title": "Session 2",
        "speakers": ["Speaker 3", "Speaker 4"],
        "categories": ["Category 3", "Category 4"],
        "summary": "This is a summary of session 2.",
        "duration": "1 hour 30 minutes",
    },
]

@app.route('/sessions', methods=['GET'])
def get_sessions():
    return jsonify(sessions)

@app.route('/sessions/<id>', methods=['GET'])
def get_session_by_id(id):
    session = next((session for session in sessions if session['id'] == id), None)
    if session is None:
        return jsonify({}), 404
    return jsonify(session)

@app.route('/sessions/categories/<category>', methods=['GET'])
def get_sessions_by_category(category):
    sessions_by_category = [session for session in sessions if category in session['categories']]
    return jsonify(sessions_by_category)

if __name__ == '__main__':
    app.run()

पिछले चरण के तहत, एक app.py फ़ाइल जनरेट हुई है. बस इसकी सामग्री को Code Assist से जनरेट किए गए कोड से बदलें और फ़ाइल सेव करें.

हमें पोर्ट 8080 और होस्ट पते 0.0.0.0 का इस्तेमाल करने के लिए, app.run() लाइन में बदलाव करना है. साथ ही, लोकल एक्ज़ीक्यूशन के दौरान डीबग मोड में भी चलाना है. इसके लिए यहां दिया गया तरीका अपनाएं. आइए, सबसे पहले इस लाइन को हाइलाइट करें या चुनें:

app.run()

इसके बाद, कोड असिस्ट चैट के इंटरफ़ेस में यह प्रॉम्प्ट टाइप करें: Explain this.

इससे उस लाइन की पूरी जानकारी मिलनी चाहिए, जिसका एक उदाहरण नीचे दिया गया है:

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

update the code to run the application on port 8080, host address 0.0.0.0, and in debug mode

सुझाया गया जनरेट किया गया कोड इस तरह का होना चाहिए: : :

app.run(host='0.0.0.0', port=8080, debug=True)

इस स्निपेट की मदद से app.py फ़ाइल को अपडेट करना न भूलें.

ऐप्लिकेशन को स्थानीय तौर पर चलाएं

हमने पहले जो ऐप्लिकेशन बनाया था उसके हिसाब से, ऐप्लिकेशन की ज़रूरी शर्तों की पुष्टि करने के लिए, अब ऐप्लिकेशन को डिवाइस पर चलाएं.

सबसे पहले आपको requirements.txt में Python पैकेज डिपेंडेंसी के साथ वर्चुअल Python एनवायरमेंट बनाना होगा. इस एनवायरमेंट को वर्चुअल एनवायरमेंट में इंस्टॉल करना होगा. ऐसा करने के लिए, Cloud Shell IDE में Command Palette (Ctrl+Shift+P) पर जाएं और Create Python Enterprise टाइप करें. वर्चुअल एनवायरमेंट (venv), Python 3.x अनुवादक और ज़रूरी शर्तें.txt फ़ाइल चुनने के लिए, अगले कुछ निर्देशों का पालन करें.

एनवायरमेंट बन जाने के बाद, एक नई टर्मिनल विंडो (Ctrl+Shift+`) लॉन्च करें और यह निर्देश दें:

python app.py

एक्ज़ीक्यूशन का उदाहरण नीचे दिखाया गया है:

(.venv) romin@cloudshell: $ python app.py 
 * Serving Flask app 'app'
 * Debug mode: on
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:8080
 * Running on http://10.88.0.3:8080
Press CTRL+C to quit
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 132-247-368

अब एपीआई की झलक, नीचे दिए गए यूआरएल पर देखी जा सकती है. हम यह मान रहे हैं कि आपका डेवलपमेंट सर्वर पोर्ट 8080 पर चल रहा है. अगर ऐसा नहीं है, तो कृपया इसे सही पोर्ट नंबर पर बदलें.

https://<host-name>:8080/sessions
https://<host-name>:8080/sessions/{id}
https://<host-name>:8080/sessions/categories/{category}

नीचे दिया गया तरीका अपनाकर पक्का करें कि app.py फ़ाइल में मौजूद JSON डेटा को, इन यूआरएल का इस्तेमाल करके वापस लाया जा सकता है:

नई टर्मिनल विंडो खोलें और इनमें से कोई भी निर्देश आज़माएं:

curl -X GET http://127.0.0.1:8080/sessions
curl -X GET http://127.0.0.1:8080/sessions/<ID>
curl -X GET http://127.0.0.1:8080/sessions/categories/<CATEGORY_NAME>

8. कोड रीफ़ैक्टरिंग

app.py में हार्ड कोड किया गया JSON डेटा शामिल नहीं होना चाहिए, बल्कि हम इसे किसी दूसरे मॉड्यूल में अलग करना/एक्सट्रैक्ट करना चाहेंगे, ताकि हम कोड और डेटा को साफ़ तौर पर अलग कर सकें. चलिए, शुरू करते हैं!

app.py फ़ाइल को खुला रखें और यह प्रॉम्प्ट दें:

Can I improve this code and separate out the sessions data from this app.py file?

इससे आपको उन तरीकों के बारे में कुछ सुझाव मिल सकते हैं. यहां एक सैंपल सुझाव दिया गया है, जो हमें मिला है और आपको इससे मिलता-जुलता कुछ सुझाव मिल सकता है:

आइए, इसे देखते हुए, अपने डेटा को Code Assist के सुझावों के हिसाब से sessions.py फ़ाइल में बांटते हैं.

sessions.py नाम की नई फ़ाइल बनाएं

, हमारे जनरेट किए गए डेटा के मुताबिक, JSON सूची का कॉन्टेंट नीचे दिया गया है:

sessions = [
   {
       "id": "1",
       "title": "Session 1",
       "speakers": ["Speaker 1", "Speaker 2"],
       "categories": ["Category 1", "Category 2"],
       "summary": "This is a summary of session 1.",
       "duration": "1 hour",
   },
   {
       "id": "2",
       "title": "Session 2",
       "speakers": ["Speaker 3", "Speaker 4"],
       "categories": ["Category 3", "Category 4"],
       "summary": "This is a summary of session 2.",
       "duration": "1 hour 30 minutes",
   },
]

app.py फ़ाइल अब बहुत आसान है. इसे नीचे दिखाया गया है:

from flask import Flask, jsonify, request
from sessions import sessions

app = Flask(__name__)

@app.route('/sessions', methods=['GET'])
def get_sessions():
   return jsonify(sessions.sessions)

@app.route('/sessions/<id>', methods=['GET'])
def get_session_by_id(id):
   session = next((session for session in sessions.sessions if session['id'] == id), None)
   if session is None:
       return jsonify({}), 404
   return jsonify(session)

@app.route('/sessions/categories/<category>', methods=['GET'])
def get_sessions_by_category(category):
   sessions_by_category = [session for session in sessions.sessions if category in session['categories']]
   return jsonify(sessions_by_category)

if __name__ == '__main__':
   app.run(host='0.0.0.0', port=8080, debug=True)

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

9. Firestore कलेक्शन के साथ इंटिग्रेट करना

अगला कदम, अपने सेशन के लिए मौजूद लोकल इन-मेमोरी JSON सूची से दूर जाना है. साथ ही, अपने ऐप्लिकेशन को Firestore डेटाबेस में मौजूद सेशन कलेक्शन से जोड़ना है, जिसे हमने इस कोडलैब की शुरुआत में बनाया था.

sessions.py फ़ाइल को खुला रखें और यह प्रॉम्प्ट दें:

Can you further refactor the sessions.py code to read from a Firestore database that has a collection named sessions. The collection has the same attributes as the session object that we have defined. Use the Python module google-cloud-firestore.

हमें Firestore कलेक्शन के सभी सेशन पढ़ने के लिए यह सुझाव मिला:

import google.cloud.firestore

# Create a Firestore client
db = google.cloud.firestore.Client()

# Get the sessions collection
sessions_collection = db.collection("sessions")

# Create a list of sessions
sessions = []

# Iterate over the documents and add them to the list
for doc in sessions_collection.stream():
   session = doc.to_dict()
   session["id"] = doc.id
   sessions.append(session)

आगे बढ़ें और sessions.py में कोड शामिल करें.

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

उदाहरण के लिए, Code Assist से सवाल पूछें. requirements.txt फ़ाइल में कौनसा Python मॉड्यूल जोड़ना ज़रूरी है, इसके बारे में यहां बताया गया है:

Which Python package needs to be installed to make the firestore code work?

इससे आपको Python मॉड्यूल का नाम मिलेगा (उदाहरण के लिए, google-cloud-firestore). उसे requirements.txt फ़ाइल में जोड़ें.

आपको जोड़े गए नए मॉड्यूल (google-cloud-firestore) की मदद से Python एनवायरमेंट को फिर से बनाना होगा. ऐसा करने के लिए, मौजूदा टर्मिनल विंडो में यह कमांड दें:

pip install -r requirements.txt

ऐप्लिकेशन को फिर से चलाएं (इसे python app.py के साथ फिर से शुरू करें) और /sessions यूआरएल पर जाएं. अब आपको उन दस्तावेज़ों के सैंपल मिलेंगे जिन्हें हमने sessions कलेक्शन में जोड़ा है.

जैसा कि पहले के चरणों में बताया गया है, किसी कैटगरी के खास सेशन या सभी सेशन को फिर से पाने के लिए, बेझिझक अन्य यूआरआई से क्वेरी करें.

10. कोड की जानकारी

कोड को अच्छी तरह से समझने के लिए, Gemini Code Assist की "Explain this" सुविधा का इस्तेमाल करें. किसी भी फ़ाइल में जाएं या कोड के खास स्निपेट चुनें और इस निर्देश की मदद से Code Assist से पूछें: Explain this.

कसरत के तौर पर, sessions.py फ़ाइल पर जाएं और Firestore के खास कोड को हाइलाइट करें और उसके बारे में कोड की जानकारी पाएं. इस सुविधा को अपने प्रोजेक्ट की अन्य फ़ाइलों पर भी इस्तेमाल करके देखें, न कि सिर्फ़ Python कोड पर.

11. वेब ऐप्लिकेशन जनरेट करें

अब हमने एपीआई जनरेट कर लिया है और उसे लाइव Firestore कलेक्शन के साथ इंटिग्रेट कर दिया है, तो हमें ऐप्लिकेशन के लिए वेब पर आधारित फ़्रंट-एंड जनरेट करने दें. फ़िलहाल, हमारा वेब फ़्रंट-एंड, अपनी फ़ंक्शन की परफ़ॉर्मेंस को सबसे कम रखेगा. इसका मतलब है कि वह किसी खास कैटगरी से जुड़े सेशन को खोज पाएगा. ध्यान रखें कि हमारे पास उसके लिए एक एपीआई पाथ है, जैसे कि /sessions/categories/{category}. इसलिए, हमारे वेब ऐप्लिकेशन को उसे इस्तेमाल करके नतीजे पाना चाहिए.

आइए, इस बारे में विस्तार से जानें. Code Assist को यह निर्देश दें:

Generate a web application that allows me to search for sessions by category and uses the Flask application that we created. Please use basic HTML, CSS and JS. Embed all the Javascript and CSS code into a single HTML file only.

इससे उस वेब ऐप्लिकेशन का एचटीएमएल जनरेट होगा जिसमें JavaScript और सीएसएस एम्बेड की गई हैं. इसमें आपसे app.py फ़ाइल में नया रूट जोड़ने के लिए भी कहा जाएगा, ताकि रूट या बेस यूआरएल पर आने वाले किसी भी उपयोगकर्ता को होम पेज दिखाया जाएगा. अगर इसमें उस जानकारी के बारे में नहीं बताया गया है, तो इसके बारे में पूछें या नीचे दिए गए स्निपेट का इस्तेमाल करें:

@app.route('/')
def index():
   return render_template('index.html')

इसे index.html के तौर पर सेव किया जा सकता है. हालांकि, आपके पास यह सवाल हो सकता है कि फ़ाइल कहां सेव की जाए (जैसे कि किस फ़ोल्डर में?). हम Code Assist से फ़ॉलो अप सवाल पूछ सकते हैं.

Given that I am using the flask framework, where should I put the index.html file?

इससे आपको साफ़ तौर पर जानकारी मिलनी चाहिए कि इसमें render_template फ़्रेमवर्क का इस्तेमाल किया गया है. इसलिए, index.html फ़ाइल को templates फ़ोल्डर में रखा जाना चाहिए. आपको यह फ़ोल्डर तब उपलब्ध होगा, जब हमने इस कोडलैब की शुरुआत में फ़्लास्क टेंप्लेट पर आधारित ऐप्लिकेशन जनरेट किया था. इस वजह से, एक index.html फ़ाइल मौजूद है. इसलिए, आपको इसके कॉन्टेंट को यहां जनरेट की गई नई फ़ाइल से बदलना होगा. कोड असिस्ट आपकी app.py फ़ाइल में render_template को इंपोर्ट करने के बारे में भी बताता है.

वेब ऐप्लिकेशन कोड को index.html फ़ाइल में सेव करें और उस फ़ाइल को templates फ़ोल्डर में रखना न भूलें.

ऐप्लिकेशन को स्थानीय तौर पर चलाएं

पक्का करें कि स्थानीय फ़्लास्क सर्वर अब भी चल रहा है और कोई गड़बड़ी नहीं दिखा रहा है. अगर गड़बड़ी होती है, तो उसे ठीक करें और सर्वर चालू करें.

ऐप्लिकेशन खुलने के बाद, उसके होम यूआरएल पर जाएं. इसमें आपको index.html फ़ाइल दिखेगी, जो नीचे दी गई है:

इनपुट के तौर पर डेटा की कोई एक कैटगरी दें (जैसे, AI) और Search बटन पर क्लिक करें. इससे AI कैटगरी के साथ टैग किए गए सेशन दिखेंगे.

इसके अलावा, हर सेशन की अवधि, कैटगरी, स्पीकर, और खास जानकारी जैसा अतिरिक्त मेटाडेटा भी दिखाया जा सकता है. हालांकि, ऐसा करना ज़रूरी नहीं है.

12. टेस्ट केस जनरेट करना

हमने सेशन एपीआई जनरेट किया है. अब Gemini Code Assist का इस्तेमाल करके, अलग-अलग एपीआई पाथ के लिए यूनिट टेस्ट केस जनरेट किए जा सकते हैं.

app.py फ़ाइल को खुला रखें और यह प्रॉम्प्ट दें:

Generate unit test cases for app routes. Use unittest module.

हमें यह जवाब मिला है:

import unittest
from app import app

class FlaskAppTestCase(unittest.TestCase):

    def test_index(self):
        tester = app.test_client()
        response = tester.get('/')
        self.assertEqual(response.status_code, 200)

    def test_get_sessions(self):
        tester = app.test_client()
        response = tester.get('/sessions')
        self.assertEqual(response.status_code, 200)

    def test_get_session_by_id(self):
        tester = app.test_client()
        response = tester.get('/sessions/1')
        self.assertEqual(response.status_code, 200)

    def test_get_sessions_by_category(self):
        tester = app.test_client()
        response = tester.get('/sessions/categories/category1')
        self.assertEqual(response.status_code, 200)

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

ऊपर दिए गए कोड के साथ tests.py नाम की फ़ाइल बनाएं.

टेस्ट केस जनरेट करने से जुड़ी जानकारी

आपको ऊपर दी गई कोड लिस्टिंग से अलग कोड लिस्टिंग दिख सकती है. इस वजह से, टेस्ट केस चलाने में कुछ समस्याएं आ सकती हैं. उदाहरण के लिए, हमने देखा कि हमारे कुछ रन में कोड के ये मुख्य हिस्से छूट गए थे:

from app import app

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

if __name__ == '__main__':

`unittest.main()`

टेस्ट केस चलाने के लिए ऊपर दिए गए कोड की ज़रूरत है.

हमारा सुझाव है कि आप हर टेस्ट केस पर नज़र डालें. इसके बाद, जनरेट किए गए कोड में मौजूद assertEqual और अन्य शर्तों की जांच करके पक्का करें कि यह काम करेगा. यह डेटा, Firestore कलेक्शन में मौजूद बाहरी है. इसलिए, हो सकता है कि इसके पास इसका ऐक्सेस न हो और यह किसी डमी डेटा का इस्तेमाल कर सकता हो. इस वजह से, जांच में गड़बड़ी हो सकती है. इसलिए, अपने टेस्ट केस में ज़रूरत के मुताबिक बदलाव करें या कुछ ऐसे टेस्ट केस के बारे में बताएं जिनकी आपको तुरंत ज़रूरत नहीं है.

डेमो के तौर पर, हमने यहां दिए गए कमांड का इस्तेमाल करके टेस्ट केस चलाए. लोकल डेवलपमेंट सर्वर ज़रूर चलाएं, क्योंकि कॉल लोकल एपीआई एंडपॉइंट पर किए जाएंगे:

python tests.py

हमें खास जानकारी वाला यह नतीजा मिला:

Ran 4 tests in 0.274s

FAILED (failures=2)

यह वाकई सही है, क्योंकि तीसरे टेस्ट में सेशन आईडी सही नहीं था और category1 नाम की कोई कैटगरी नहीं है

इसलिए, टेस्ट केस में अपने हिसाब से बदलाव करें और उनकी जांच करें.

13। टेस्ट ड्रिवन डेवलपमेंट

आइए, अब हमारे सेशन एपीआई में, टेस्ट ड्रिवन डेवलपमेंट (टीडीडी) के तरीके का इस्तेमाल करके, खोज का एक नया तरीका जोड़ते हैं. टीडीडी में टेस्ट केस लिखने से जुड़े नियम शामिल होते हैं. इन मामलों में, Gemini Code Assist का इस्तेमाल नहीं किया जा सकता, ताकि टेस्ट पास न हो पाएं. इससे, टेस्ट केस पास नहीं होंगे.

test.py फ़ाइल पर जाएं (यह मानते हुए कि आपने tests.py फ़ाइल को ठीक कर लिया है, ताकि सभी टेस्ट पास हो जाएं). Code Assist से यह प्रॉम्प्ट पूछें:

Generate a new test case to search for sessions by speaker

इससे हमें यह टेस्ट केस लागू करने का निर्देश मिला, जिसे हमने tests.py फ़ाइल में सही तरीके से शामिल किया.

  def test_get_sessions_by_speaker(self):
        tester = app.test_client()
        response = tester.get('/sessions/speakers/speaker1')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.json, [sessions.sessions[0], sessions.sessions[1]])

अगर जांच की जाती है, तो आपको यह गड़बड़ी दिखेगी:

$ python tests.py 
.F.
======================================================================
FAIL: test_get_sessions_by_speaker (__main__.FlaskAppTestCase)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/home/romin/hello-world-5/tests.py", line 21, in test_get_sessions_by_speaker
    self.assertEqual(response.status_code, 200)
AssertionError: 404 != 200

----------------------------------------------------------------------
Ran 3 tests in 0.010s

FAILED (failures=1)

इसकी वजह यह है कि टेस्ट केस ने नीचे दिए गए पाथ (/sessions/speakers/) को शुरू किया है और app.py में उसे लागू नहीं किया गया है.

चलिए, Code Assist से इसे लागू करने का अनुरोध करने के लिए कहते हैं. app.py फ़ाइल पर जाएं और Code Assist को यह निर्देश दें:

Add a new route to search for sessions by a specific speaker

हमें Code Assist से सुझाया गया यह काम करने का सुझाव मिला है, जिसे हमने app.py फ़ाइल में जोड़ दिया है:

@app.route('/sessions/speakers/<speaker>', methods=['GET'])
def get_sessions_by_speaker(speaker):
    sessions_by_speaker = [session for session in sessions.sessions if speaker in session['speakers']]
    return jsonify(sessions_by_speaker)

tests.py फ़ाइल पर फिर से जाएं और हमने तुरंत जांच करने के लिए अपने टेस्ट केस में ये बदलाव किए हैं:

   def test_get_sessions_by_speaker(self):
       tester = app.test_client()
       response = tester.get('/sessions/speakers/Romin Irani')
       self.assertEqual(response.status_code, 200)
       self.assertEqual(len(response.json), 1)

जांच सही तरीके से की गई. हम जनरेट किए गए टेस्ट केस को देखने के लिए, इसे एक कसरत की तरह छोड़ देते हैं. Firestore में आपके पास मौजूद डेटा के हिसाब से उनमें थोड़ा बदलाव करते हैं. साथ ही, Python यूनिट टेस्ट केस में सही assert* तरीके अपनाते हैं.

14. Google Cloud Run में डिप्लॉय किया जा रहा है

अब जब हमें अपने डेवलपमेंट की क्वालिटी अच्छी लग रही है, तो हमारा आखिरी चरण इस ऐप्लिकेशन को Google Cloud Run पर डिप्लॉय करना होगा. हालांकि, अगर हम कुछ भूल गए हैं, तो कृपया Code Assist से संपर्क करें. app.py खुला होने पर, यह प्रॉम्प्ट सबमिट करें :

Is there something here I should change before I deploy to production?

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

जैसा कि बताया गया है, डीबग करने की सुविधा को बंद करें. इसके बाद, Gemini Code Assist से मदद पाने के लिए gcloud निर्देश का अनुरोध करें. इस निर्देश का इस्तेमाल करके, ऐप्लिकेशन को सीधे सोर्स से Cloud Run पर डिप्लॉय किया जा सकता है. इसके लिए, आपको कंटेनर बनाने की ज़रूरत नहीं है.

यह प्रॉम्प्ट दें:

I would like to deploy the application to Cloud Run directly from source. What is the gcloud command to do that?

ऊपर दिए गए प्रॉम्प्ट के कुछ वैरिएशन आज़माएं. हमने एक और तरीका आज़माया:

I would like to deploy this application to Cloud Run. I don't want to build a container image locally but deploy directly from source to Cloud Run. What is the gcloud command for that?

आम तौर पर, आपको यह gcloud निर्देश मिलना चाहिए:

gcloud run deploy sessions --source .

आपको यह जानकारी भी मिल सकती है:

gcloud run deploy <service-name> --source . \
—-platform managed \
—-allow-unauthenticated

ऐप्लिकेशन के रूट फ़ोल्डर से ऊपर दिया गया निर्देश चलाएं. जब region के बारे में पूछा जाए, तो us-central1 को चुनें. साथ ही, जब unauthenticated invocations की अनुमति देने के लिए पूछा जाए, तो Y को चुनें. आपसे Artifact Registry, Cloud Build और Cloud Run जैसे Google Cloud API को चालू करने और Artifact Registry का डेटा स्टोर करने की जगह बनाने की अनुमति भी मांगी जा सकती है. कृपया अनुमति दें.

डिप्लॉयमेंट की प्रोसेस पूरी होने में करीब दो मिनट लगेंगे. इसलिए, कृपया थोड़ा इंतज़ार करें.

डिप्लॉयमेंट पूरा होने के बाद, आपको Cloud Run सेवा का यूआरएल दिखेगा. उस सार्वजनिक URL पर जाएं और आपको वही वेब ऐप्लिकेशन डिप्लॉय और सफलतापूर्वक चलता हुआ दिखेगा.

बधाई हो, बहुत अच्छे !

15. (ज़रूरी नहीं) क्लाउड लॉगिंग का इस्तेमाल करें

हम अपने ऐप्लिकेशन में इस तरह से लॉग इन करना शुरू कर सकते हैं कि ऐप्लिकेशन के लॉग को किसी एक Google Cloud सेवा (Cloud Logging) में ही रखा जा सके. इसके बाद, हम लॉग एंट्री को समझने के लिए, Gemini की ऑब्ज़रवेबिलिटी सुविधा का इस्तेमाल कर सकते हैं.

ऐसा करने के लिए, हमें पहले Google Cloud की मौजूदा Python Cloud Logging लाइब्रेरी का इस्तेमाल करना होगा. साथ ही, इसका इस्तेमाल लॉग / गंभीरता के लेवल के आधार पर, जानकारी देने, चेतावनी या गड़बड़ी के मैसेज लॉग करने के लिए करना होगा.

आइए, पहले इसे Code Assist से पूछें. यह प्रॉम्प्ट आज़माएं:

How do I use the google-cloud-logging package in Python?

आपको एक जवाब मिलेगा, जिसमें इस बारे में कुछ जानकारी दी गई होगी, जैसा कि यहां बताया गया है:

आइए, उस फ़ंक्शन में लॉगिंग स्टेटमेंट जोड़ें, जो श्रेणी के आधार पर सेशन की खोज करता है.

सबसे पहले, requirements.txt फ़ाइल में google-cloud-logging Python पैकेज जोड़ें.

अब आपको कोड का एक स्निपेट दिखेगा, जिसमें दिखाया गया है कि हमने लॉग इन करने के लिए कोड को कैसे इंटिग्रेट किया:

...
from google.cloud import logging
...
app = Flask(__name__)

# Create a logger
logger = logging.Client().logger('my-log')

@app.route('/sessions/categories/<category>', methods=['GET'])
def get_sessions_by_category(category):
   logger.log_text(f"Fetching sessions with category {category}")
   sessions_by_category = [session for session in sessions.sessions if category in session['categories']]
   logger.log_text(f'Found {len(sessions_by_category)} sessions with category {category}')
   return jsonify(sessions_by_category)

# # Other App Routes

पिछले सेक्शन में दिए गए निर्देश का इस्तेमाल करके, सेवा को Cloud Run पर फिर से डिप्लॉय करें. इसके बाद, /sessions/categories/<category> एंडपॉइंट पर कुछ कॉल लागू करें.

Cloud Console → Logs Explorer पर जाएँ

...और आप इन लॉगिंग स्टेटमेंट को फ़िल्टर कर सकते हैं, जैसा कि नीचे दिखाया गया है:

किसी भी लॉग स्टेटमेंट पर क्लिक करके उसे बड़ा करें. इसके बाद, Explain this log entry पर क्लिक करें. इससे, आपको लॉग के बारे में ज़्यादा जानकारी देने के लिए Gemini का इस्तेमाल करना होगा. ध्यान दें कि अगर आपने Google Cloud के लिए Gemini को चालू नहीं किया है, तो आपसे Cloud AI Companion API को चालू करने के लिए कहा जाएगा. कृपया आगे बढ़ें और निर्देशों के मुताबिक ऐसा करें.

रिस्पॉन्स का सैंपल यहां दिया गया है:

16. बधाई

बधाई हो, आपने एसडीएलसी के डिज़ाइन, बिल्ड, टेस्टिंग, और डिप्लॉयमेंट जैसे कामों के लिए, Gemini Code Assist का इस्तेमाल शुरू से कर लिया है.

आगे क्या होगा?

इनमें से कुछ कोडलैब देखें...

Gemini Code Assist की मदद से, अपने डेवलपमेंट वर्कफ़्लो को बेहतर बनाएं

1. शुरुआती जानकारी

आपको क्या करना होगा

आपको इनके बारे में जानकारी मिलेगी

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

2. कोड से जुड़ी सहायता देने वाली Gemini की सुविधा सेटअप करें

Cloud Shell IDE में Gemini Code असिस्ट की सुविधा चालू करना

3. Firestore सेटअप करें

Firestore डेटाबेस को शुरू करना

4. ऐप्लिकेशन टेंप्लेट बनाएं

5. Gemini Code Assist से इंटरैक्ट करना

6. एपीआई डिज़ाइन

7. ऐप्लिकेशन जनरेट करें

ऐप्लिकेशन को स्थानीय तौर पर चलाएं

8. कोड रीफ़ैक्टरिंग

9. Firestore कलेक्शन के साथ इंटिग्रेट करना

10. कोड की जानकारी

11. वेब ऐप्लिकेशन जनरेट करें

ऐप्लिकेशन को स्थानीय तौर पर चलाएं

12. टेस्ट केस जनरेट करना

टेस्ट केस जनरेट करने से जुड़ी जानकारी

13। टेस्ट ड्रिवन डेवलपमेंट

14. Google Cloud Run में डिप्लॉय किया जा रहा है

15. (ज़रूरी नहीं) क्लाउड लॉगिंग का इस्तेमाल करें

16. बधाई

आगे क्या होगा?

पहचान फ़ाइलें