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

Python में जनरेटिव एआई ऐप्लिकेशन के लिए, मॉनिटर करने की काम की तकनीकें

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

जेन एआई ऐप्लिकेशन को किसी भी दूसरे ऐप्लिकेशन की तरह निगरानी की ज़रूरत होती है. क्या जनरेटिव एआई के लिए, निगरानी करने की खास तकनीकों की ज़रूरत होती है?

इस लैब में, आपको जनरेटिव एआई का एक आसान ऐप्लिकेशन बनाना होगा. इसे Cloud Run पर डिप्लॉय करें. साथ ही, Google Cloud की निगरानी से जुड़ी सेवाओं और प्रॉडक्ट का इस्तेमाल करके, इसे निगरानी और लॉगिंग की ज़रूरी सुविधाओं से जोड़ें.

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

Cloud Shell Editor की मदद से, Vertex AI का इस्तेमाल करने वाला ऐप्लिकेशन लिखना
अपने ऐप्लिकेशन का कोड GitHub में सेव करना
अपने ऐप्लिकेशन के सोर्स कोड को Cloud Run पर डिप्लॉय करने के लिए, gcloud CLI का इस्तेमाल करना

अपने जेन एआई ऐप्लिकेशन में मॉनिटरिंग और लॉगिंग की सुविधाएं जोड़ना
लॉग-आधारित मेट्रिक का इस्तेमाल करना
Open Telemetry SDK टूल की मदद से लॉगिंग और मॉनिटरिंग लागू करना
ज़िम्मेदारी से डेटा मैनेज करने वाले एआई के बारे में अहम जानकारी पाना

2. ज़रूरी शर्तें

अगर आपके पास पहले से कोई Google खाता नहीं है, तो आपको नया खाता बनाना होगा.

3. प्रोजेक्ट सेटअप करना

अपने Google खाते से Google Cloud Console में साइन इन करें.
नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें. आपने अभी-अभी जो प्रोजेक्ट बनाया है या चुना है उसका प्रोजेक्ट आईडी लिखें.
प्रोजेक्ट के लिए बिलिंग चालू करें.
- इस लैब को पूरा करने के लिए, बिलिंग शुल्क 5 डॉलर से कम होना चाहिए.
- आगे कोई शुल्क न देना हो, तो इस लैब के आखिर में दिए गए तरीके का इस्तेमाल करके संसाधन मिटाएं.
- नए उपयोगकर्ताओं को 300 डॉलर का मुफ़्त क्रेडिट मिलता है.
Cloud Billing में मेरे प्रोजेक्ट में जाकर, पुष्टि करें कि बिलिंग की सुविधा चालू है
- अगर आपके नए प्रोजेक्ट के Billing account कॉलम में Billing is disabled दिखता है, तो:
  1. Actions कॉलम में मौजूद तीन बिंदुओं पर क्लिक करें
  2. बिलिंग बदलें पर क्लिक करें
  3. वह बिलिंग खाता चुनें जिसका इस्तेमाल करना है
- अगर लाइव इवेंट में हिस्सा लिया जा रहा है, तो खाते का नाम Google Cloud Platform का ट्रायल बिलिंग खाता होगा

4. Cloud Shell एडिटर तैयार करना

Cloud Shell एडिटर पर जाएं. अगर आपको नीचे दिया गया मैसेज दिखता है, तो cloud shell को अपने क्रेडेंशियल के साथ gcloud को कॉल करने की अनुमति देने के लिए कहा जाएगा. जारी रखने के लिए, अनुमति दें पर क्लिक करें.
टर्मिनल विंडो खोलें
1. हैमबर्गर मेन्यू पर क्लिक करें
2. Terminal पर क्लिक करें
3. नया टर्मिनल
  पर क्लिक करें
टर्मिनल में, अपना प्रोजेक्ट आईडी कॉन्फ़िगर करें:
```
gcloud config set project [PROJECT_ID]
```
[PROJECT_ID] की जगह अपने प्रोजेक्ट का आईडी डालें. उदाहरण के लिए, अगर आपका प्रोजेक्ट आईडी lab-example-project है, तो कमांड यह होगा:
```
gcloud config set project lab-project-id-example
```
अगर आपको यह मैसेज दिखता है कि gcloud, GCPI API से आपके क्रेडेंशियल का अनुरोध कर रहा है, तो जारी रखने के लिए अनुमति दें पर क्लिक करें.

कार्रवाई पूरी होने पर, आपको यह मैसेज दिखेगा:
```
Updated property [core/project].
```
अगर आपको WARNING दिखता है और आपसे Do you want to continue (Y/N)? पूछा जाता है, तो हो सकता है कि आपने प्रोजेक्ट आईडी गलत डाला हो. सही प्रोजेक्ट आईडी मिलने के बाद, N दबाएं, Enter दबाएं, और gcloud config set project कमांड को फिर से चलाने की कोशिश करें.
(ज़रूरी नहीं) अगर आपको प्रोजेक्ट आईडी ढूंढने में समस्या आ रही है, तो अपने सभी प्रोजेक्ट के प्रोजेक्ट आईडी देखने के लिए, नीचे दिया गया निर्देश चलाएं. इन प्रोजेक्ट को बनाने के समय के हिसाब से, घटते क्रम में लगाया गया है:
```
gcloud projects list \
     --format='value(projectId,createTime)' \
     --sort-by=~createTime
```

5. Google API चालू करना

टर्मिनल में, इस लैब के लिए ज़रूरी Google API चालू करें:

gcloud services enable \
     run.googleapis.com \
     cloudbuild.googleapis.com \
     aiplatform.googleapis.com \
     logging.googleapis.com \
     monitoring.googleapis.com \
     cloudtrace.googleapis.com

इस निर्देश को पूरा होने में कुछ समय लगेगा. आखिर में, यह इस तरह का मैसेज दिखाता है:

Operation "operations/acf.p2-73d90d00-47ee-447a-b600" finished successfully.

अगर आपको गड़बड़ी का कोई ऐसा मैसेज मिलता है जो ERROR: (gcloud.services.enable) HttpError accessing से शुरू होता है और जिसमें गड़बड़ी की जानकारी नीचे दी गई तरह की होती है, तो एक से दो मिनट बाद फिर से कोशिश करें.

"error": {
  "code": 429,
  "message": "Quota exceeded for quota metric 'Mutate requests' and limit 'Mutate requests per minute' of service 'serviceusage.googleapis.com' ...",
  "status": "RESOURCE_EXHAUSTED",
  ...
}

6. Gen AI Python ऐप्लिकेशन बनाना

इस चरण में, आपको अनुरोध पर काम करने वाले ऐसे आसान ऐप्लिकेशन का कोड लिखना होगा जो आपकी पसंद के किसी जानवर के बारे में 10 मज़ेदार बातें दिखाने के लिए, Gemini मॉडल का इस्तेमाल करता है. ऐप्लिकेशन कोड बनाने के लिए, यह तरीका अपनाएं.

टर्मिनल में, codelab-o11y डायरेक्ट्री बनाएं:
```
mkdir ~/codelab-o11y
```
मौजूदा डायरेक्ट्री को codelab-o11y में बदलने के लिए:
```
cd ~/codelab-o11y
```

डिपेंडेंसी की सूची के साथ requirements.txt बनाएं:

cat > requirements.txt << EOF
Flask==3.0.0
gunicorn==23.0.0
google-cloud-aiplatform==1.59.0
google-auth==2.32.0
EOF

main.py फ़ाइल बनाएं और उसे Cloud Shell Editor में खोलें:
```
cloudshell edit main.py
```
अब आपको टर्मिनल के ऊपर मौजूद एडिटर विंडो में एक खाली फ़ाइल दिखेगी. आपकी स्क्रीन कुछ इस तरह दिखेगी:

नीचे दिया गया कोड कॉपी करके, खोली गई main.py फ़ाइल में चिपकाएं:

import os
from flask import Flask, request
import google.auth
import vertexai
from vertexai.generative_models import GenerativeModel

_, project = google.auth.default()
app = Flask(__name__)

@app.route('/')
def fun_facts():
    vertexai.init(project=project, location='us-central1')
    model = GenerativeModel('gemini-1.5-flash')
    animal = request.args.get('animal', 'dog') 
    prompt = f'Give me 10 fun facts about {animal}. Return this as html without backticks.'
    response = model.generate_content(prompt)
    return response.text

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

कुछ सेकंड बाद, Cloud Shell Editor आपका कोड अपने-आप सेव कर देगा.

जेन एआई ऐप्लिकेशन के कोड को Cloud Run पर डिप्लॉय करना

टर्मिनल विंडो में, ऐप्लिकेशन के सोर्स कोड को Cloud Run पर डिप्लॉय करने के लिए कमांड चलाएं.
```
gcloud run deploy codelab-o11y-service \
     --source="${HOME}/codelab-o11y/" \
     --region=us-central1 \
     --allow-unauthenticated
```
अगर आपको नीचे दिया गया प्रॉम्प्ट दिखता है, तो इसका मतलब है कि यह कमांड एक नया रिपॉज़िटरी बनाएगा. Enter पर क्लिक करें.
```
Deploying from source requires an Artifact Registry Docker repository to store built containers.
A repository named [cloud-run-source-deploy] in region [us-central1] will be created.

Do you want to continue (Y/n)?
```
डिप्लॉयमेंट की प्रोसेस में कुछ मिनट लग सकते हैं. डिप्लॉयमेंट की प्रोसेस पूरी होने के बाद, आपको ऐसा आउटपुट दिखेगा:
```
Service [codelab-o11y-service] revision [codelab-o11y-service-00001-t2q] has been deployed and is serving 100 percent of traffic.
Service URL: https://codelab-o11y-service-12345678901.us-central1.run.app
```
Cloud Run सेवा का दिख रहा यूआरएल, अपने ब्राउज़र के किसी अलग टैब या विंडो में कॉपी करें. इसके अलावा, सेवा का यूआरएल प्रिंट करने के लिए, टर्मिनल में यह कमांड चलाएं. इसके बाद, यूआरएल खोलने के लिए Ctrl बटन को दबाकर दिखाए गए यूआरएल पर क्लिक करें:
```
gcloud run services list \
     --format='value(URL)' \
     --filter='SERVICE:"codelab-o11y-service"'
```
यूआरएल खोलने पर, आपको 500 गड़बड़ी का कोड या यह मैसेज दिख सकता है:
```
Sorry, this is just a placeholder...
```
इसका मतलब है कि सेवाएं डिप्लॉय नहीं हुईं. कुछ देर इंतज़ार करें और पेज को रीफ़्रेश करें. आखिर में, आपको कुत्तों के बारे में मज़ेदार बातें से शुरू होने वाला टेक्स्ट दिखेगा. इसमें कुत्तों के बारे में 10 मज़ेदार बातें होंगी.

अलग-अलग जानवरों के बारे में मज़ेदार तथ्य जानने के लिए, ऐप्लिकेशन के साथ इंटरैक्ट करें. ऐसा करने के लिए, यूआरएल में animal पैरामीटर जोड़ें, जैसे कि ?animal=[ANIMAL], जहां [ANIMAL] किसी जानवर का नाम है. उदाहरण के लिए, बिल्लियों के बारे में 10 मज़ेदार बातें जानने के लिए ?animal=cat या समुद्री कछुओं के बारे में 10 मज़ेदार बातें जानने के लिए ?animal=sea turtle जोड़ें.

7. अपने Vertex एपीआई कॉल का ऑडिट करना

Google API कॉल का ऑडिट करने से, "किसी खास एपीआई को कौन, कहां, और कब कॉल करता है?" जैसे सवालों के जवाब मिलते हैं. अपने ऐप्लिकेशन की समस्या हल करने, संसाधनों के इस्तेमाल की जांच करने या सॉफ़्टवेयर फ़ॉरेंसिक विश्लेषण करने के लिए, ऑडिट करना ज़रूरी है.

ऑडिट लॉग की मदद से, एडमिन और सिस्टम की गतिविधियों को ट्रैक किया जा सकता है. साथ ही, "डेटा पढ़ने" और "डेटा लिखने" वाले एपीआई ऑपरेशन के लिए कॉल को लॉग किया जा सकता है. कॉन्टेंट जनरेट करने के लिए Vertex AI के अनुरोधों का ऑडिट करने के लिए, आपको Cloud Console में "डेटा पढ़ना" ऑडिट लॉग चालू करने होंगे.

Cloud Console में ऑडिट लॉग पेज खोलने के लिए, नीचे दिए गए बटन पर क्लिक करें
पक्का करें कि पेज पर वह प्रोजेक्ट हो जिसे आपने इस लैब के लिए बनाया है. चुना गया प्रोजेक्ट, पेज के सबसे ऊपर बाएं कोने में है. यह हैमबर्गर मेन्यू के ठीक सामने होता है:

अगर ज़रूरी हो, तो कॉम्बोबॉक्स से सही प्रोजेक्ट चुनें.
डेटा ऐक्सेस ऑडिट लॉग कॉन्फ़िगरेशन टेबल में, सेवा कॉलम में Vertex AI API सेवा ढूंढें. इसके बाद, सेवा के नाम के बाईं ओर मौजूद चेकबॉक्स को चुनकर सेवा चुनें.
दाईं ओर मौजूद जानकारी वाले पैनल में, "डेटा पढ़ा गया" ऑडिट टाइप चुनें.
सेव करें पर क्लिक करें.

ऑडिट लॉग जनरेट करने के लिए, सेवा का यूआरएल खोलें. अलग-अलग नतीजे पाने के लिए, ?animal= पैरामीटर की वैल्यू बदलते समय पेज को रीफ़्रेश करें.

ऑडिट लॉग एक्सप्लोर करना

Cloud Console में लॉग एक्सप्लोरर पेज खोलने के लिए, नीचे दिए गए बटन पर क्लिक करें:
क्वेरी पैनल में यह फ़िल्टर चिपकाएं.
```
LOG_ID("cloudaudit.googleapis.com%2Fdata_access") AND
protoPayload.serviceName="aiplatform.googleapis.com"
```
क्वेरी पैनल, लॉग एक्सप्लोरर पेज के सबसे ऊपर मौजूद एक एडिटर है:
क्वेरी चलाएं पर क्लिक करें.
ऑडिट लॉग की किसी एंट्री को चुनें और लॉग में कैप्चर की गई जानकारी की जांच करने के लिए, फ़ील्ड को बड़ा करें.
Vertex API कॉल के बारे में जानकारी देखी जा सकती है. इसमें, इस्तेमाल किए गए तरीके और मॉडल की जानकारी भी शामिल है. आपको यह भी दिख सकता है कि कॉल किसने किया और कॉल के लिए किन अनुमतियों की अनुमति दी गई है.

8. जेन एआई के साथ इंटरैक्शन को लॉग करना

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

Python का logging पैकेज, Google Cloud में लॉग लिखने की जानकारी नहीं रखता. यह स्टैंडर्ड आउटपुट (डिफ़ॉल्ट रूप से stderr) या फ़ाइल में लिखने की सुविधा देता है. हालांकि, Cloud Run में स्टैंडर्ड आउटपुट में प्रिंट की गई जानकारी को कैप्चर करने और उसे Cloud Logging में अपने-आप डालने की सुविधाएं हैं. हमारे जेन एआई ऐप्लिकेशन में लॉगिंग की सुविधाएं जोड़ने के लिए, नीचे दिए गए निर्देशों का पालन करें.

अपने ब्राउज़र में, ‘Cloud Shell' विंडो (या टैब) पर वापस जाएं.
टर्मिनल में, main.py को फिर से खोलें:
```
cloudshell edit ~/codelab-o11y/main.py
```
ऐप्लिकेशन के कोड में ये बदलाव करें:
1. इंपोर्ट का पिछला स्टेटमेंट ढूंढें. यह पांचवीं लाइन होनी चाहिए:
```
from vertexai.generative_models import GenerativeModel
```
  कर्सर को अगली लाइन (छठी लाइन) पर ले जाएं और यहां दिया गया कोड ब्लॉक चिपकाएं.
```
import sys, json, logging
class JsonFormatter(logging.Formatter):
    def format(self, record):
        json_log_object = {
            'severity': record.levelname,
            'message': record.getMessage(),
        }
        json_log_object.update(getattr(record, 'json_fields', {}))
        return json.dumps(json_log_object)
logger = logging.getLogger(__name__)
sh = logging.StreamHandler(sys.stdout)
sh.setFormatter(JsonFormatter())
logger.addHandler(sh)
logger.setLevel(logging.DEBUG)
```
2. वह कोड ढूंढें जो कॉन्टेंट जनरेट करने के लिए मॉडल को कॉल करता है. यह 30वीं लाइन होनी चाहिए:
```
response = model.generate_content(prompt)
```
  कर्सर को अगली लाइन की शुरुआत (लाइन 31) में रखें और यहां दिया गया कोड ब्लॉक चिपकाएं.
```
    json_fields = {
         'animal': animal,
         'prompt': prompt,
         'response': response.to_dict(),
    }
    logger.debug('content is generated', extra={'json_fields': json_fields})
```
  ध्यान दें: इस कोड ब्लॉक को fun_fact() तरीके में फ़िट करने के लिए इंडेंट किया गया है. अगर इंडेंटेशन में कोई गड़बड़ी है, तो Cloud Shell Editor, समस्या वाले हिस्से को मार्क करने के लिए लाल रंग की घुमावदार लाइन दिखाएगा. Python सिंटैक्स के हिसाब से, इंडेंटेशन को मैन्युअल तरीके से अडजस्ट करें.
इन बदलावों से, Python स्टैंडर्ड लॉगिंग को कॉन्फ़िगर किया जाता है, ताकि स्ट्रिंग में बदले गए JSON को जनरेट करने के लिए कस्टम फ़ॉर्मैटर का इस्तेमाल किया जा सके. यह JSON, स्ट्रक्चर्ड फ़ॉर्मैटिंग के दिशा-निर्देशों का पालन करता है. लॉगिंग को stdout में लॉग प्रिंट करने के लिए कॉन्फ़िगर किया गया है. यहां Cloud Run लॉगिंग एजेंट इसे इकट्ठा करता है और Cloud Logging में असिंक्रोनस तरीके से डालता है. लॉग में, अनुरोध के जानवर पैरामीटर के साथ-साथ मॉडल के प्रॉम्प्ट और जवाब को कैप्चर किया जाता है.कुछ सेकंड बाद, Cloud Shell Editor आपके बदलावों को अपने-आप सेव कर देता है.

जेन एआई ऐप्लिकेशन के कोड को Cloud Run पर डिप्लॉय करना

टर्मिनल विंडो में, ऐप्लिकेशन के सोर्स कोड को Cloud Run पर डिप्लॉय करने के लिए कमांड चलाएं.
```
gcloud run deploy codelab-o11y-service \
     --source="${HOME}/codelab-o11y/" \
     --region=us-central1 \
     --allow-unauthenticated
```
अगर आपको नीचे दिया गया प्रॉम्प्ट दिखता है, तो इसका मतलब है कि यह कमांड एक नया रिपॉज़िटरी बनाएगा. Enter पर क्लिक करें.
```
Deploying from source requires an Artifact Registry Docker repository to store built containers.
A repository named [cloud-run-source-deploy] in region [us-central1] will be created.

Do you want to continue (Y/n)?
```
डिप्लॉयमेंट की प्रोसेस में कुछ मिनट लग सकते हैं. डिप्लॉयमेंट की प्रोसेस पूरी होने के बाद, आपको ऐसा आउटपुट दिखेगा:
```
Service [codelab-o11y-service] revision [codelab-o11y-service-00001-t2q] has been deployed and is serving 100 percent of traffic.
Service URL: https://codelab-o11y-service-12345678901.us-central1.run.app
```
Cloud Run सेवा का दिख रहा यूआरएल, अपने ब्राउज़र के किसी अलग टैब या विंडो में कॉपी करें. इसके अलावा, सेवा का यूआरएल प्रिंट करने के लिए, टर्मिनल में यह कमांड चलाएं. इसके बाद, यूआरएल खोलने के लिए Ctrl बटन को दबाकर दिखाए गए यूआरएल पर क्लिक करें:
```
gcloud run services list \
     --format='value(URL)' \
     --filter='SERVICE:"codelab-o11y-service"'
```
यूआरएल खोलने पर, आपको 500 गड़बड़ी का कोड या यह मैसेज दिख सकता है:
```
Sorry, this is just a placeholder...
```
इसका मतलब है कि सेवाएं डिप्लॉय नहीं हुईं. कुछ देर इंतज़ार करें और पेज को रीफ़्रेश करें. आखिर में, आपको कुत्तों के बारे में मज़ेदार बातें से शुरू होने वाला टेक्स्ट दिखेगा. इसमें कुत्तों के बारे में 10 मज़ेदार बातें होंगी.

ऐप्लिकेशन लॉग जनरेट करने के लिए, सेवा का यूआरएल खोलें. अलग-अलग नतीजे पाने के लिए, ?animal= पैरामीटर की वैल्यू बदलते समय पेज को रीफ़्रेश करें.
ऐप्लिकेशन लॉग देखने के लिए, यह तरीका अपनाएं:

Cloud Console में लॉग एक्सप्लोरर पेज खोलने के लिए, नीचे दिए गए बटन पर क्लिक करें:
क्वेरी पैनल में यह फ़िल्टर चिपकाएं (लॉग एक्सप्लोरर इंटरफ़ेस में #2):
```
LOG_ID("run.googleapis.com%2Fstdout") AND
severity=DEBUG
```
क्वेरी चलाएं पर क्लिक करें.

क्वेरी के नतीजे में, प्रॉम्प्ट और Vertex AI के जवाब के साथ लॉग दिखते हैं. इनमें सुरक्षा रेटिंग भी शामिल होती हैं.

9. जेन एआई के साथ इंटरैक्शन की गिनती करना

Cloud Run, मैनेज की जा सकने वाली मेट्रिक लिखता है. इनका इस्तेमाल, डिप्लॉय की गई सेवाओं पर नज़र रखने के लिए किया जा सकता है. उपयोगकर्ता के मैनेज की जाने वाली मॉनिटरिंग मेट्रिक, डेटा और मेट्रिक अपडेट की फ़्रीक्वेंसी को ज़्यादा कंट्रोल करने की सुविधा देती हैं. इस तरह की मेट्रिक लागू करने के लिए, एक कोड लिखना ज़रूरी है. यह कोड डेटा इकट्ठा करता है और उसे क्लाउड मॉनिटरिंग में सेव करता है. OpenTelemetry SDK टूल का इस्तेमाल करके, इसे लागू करने का तरीका जानने के लिए अगला (ज़रूरी नहीं) चरण देखें.

इस चरण में, कोड में उपयोगकर्ता मेट्रिक लागू करने का विकल्प दिखाया गया है - लॉग पर आधारित मेट्रिक. लॉग पर आधारित मेट्रिक की मदद से, उन लॉग एंट्री से निगरानी मेट्रिक जनरेट की जा सकती हैं जिन्हें आपका ऐप्लिकेशन, Cloud Logging में लिखता है. हम टाइप काउंटर की लॉग-आधारित मेट्रिक तय करने के लिए, पिछले चरण में लागू किए गए ऐप्लिकेशन लॉग का इस्तेमाल करेंगे. यह मेट्रिक, Vertex API को भेजे गए कॉल की संख्या की गिनती करेगी.

उस लॉग एक्सप्लोरर की विंडो देखें जिसका इस्तेमाल हमने पिछले चरण में किया था. क्वेरी पैनल में, कार्रवाइयां ड्रॉप-डाउन मेन्यू ढूंढें और उसे खोलने के लिए उस पर क्लिक करें. मेन्यू ढूंढने के लिए, नीचे दिया गया स्क्रीनशॉट देखें:
खुले हुए मेन्यू में, लॉग पर आधारित मेट्रिक बनाएं पैनल खोलने के लिए, मेट्रिक बनाएं चुनें.
लॉग पर आधारित मेट्रिक बनाएं पैनल में नई काउंटर मेट्रिक कॉन्फ़िगर करने के लिए, यह तरीका अपनाएं:
1. मेट्रिक टाइप सेट करें: काउंटर चुनें.
2. जानकारी सेक्शन में, ये फ़ील्ड सेट करें:
  - मेट्रिक का नाम लॉग करें: नाम को model_interaction_count पर सेट करें. नाम रखने से जुड़ी कुछ पाबंदियां लागू होती हैं. ज़्यादा जानकारी के लिए, नाम रखने से जुड़ी पाबंदियों से जुड़ी समस्या हल करना लेख पढ़ें.
  - जानकारी: मेट्रिक के लिए जानकारी डालें. उदाहरण के लिए, Number of log entries capturing successful call to model inference.
  - इकाइयां: इसे खाली छोड़ें या अंक 1 डालें.
3. फ़िल्टर चुनना सेक्शन में वैल्यू छोड़ें. ध्यान दें कि फ़िल्टर बनाएं फ़ील्ड में वही फ़िल्टर है जिसका इस्तेमाल हमने ऐप्लिकेशन लॉग देखने के लिए किया था.
4. (ज़रूरी नहीं) एक लेबल जोड़ें, ताकि हर जानवर की आवाज़ की संख्या को गिना जा सके. ध्यान दें: इस लेबल से मेट्रिक की एलिमेंट की संख्या काफ़ी बढ़ सकती है. इसलिए, इसका इस्तेमाल प्रोडक्शन में करने का सुझाव नहीं दिया जाता:
  1. लेबल जोड़ें पर क्लिक करें.
  2. लेबल सेक्शन में, ये फ़ील्ड सेट करें:
    - लेबल का नाम: नाम को animal पर सेट करें.
    - जानकारी: लेबल की जानकारी डालें. उदाहरण के लिए, Animal parameter.
    - लेबल का टाइप: STRING चुनें.
    - फ़ील्ड का नाम: jsonPayload.animal टाइप करें.
    - रेगुलर एक्सप्रेशन: इसे खाली छोड़ दें.
  3. हो गया पर क्लिक करें
5. मेट्रिक बनाने के लिए, मेट्रिक बनाएं पर क्लिक करें.

gcloud logging metrics create सीएलआई कमांड या google_logging_metric Terraform रिसॉर्स का इस्तेमाल करके, लॉग पर आधारित मेट्रिक पेज से भी लॉग पर आधारित मेट्रिक बनाई जा सकती है.

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

लॉग पर आधारित मेट्रिक डेटा खोजने के लिए, PromQL क्वेरी डालें. PromQL क्वेरी डालने के लिए, यह तरीका अपनाएं:

Cloud Console में मेट्रिक एक्सप्लोरर पेज खोलने के लिए, नीचे दिए गए बटन पर क्लिक करें:
क्वेरी बिल्डर पैनल के टूलबार में, वह बटन चुनें जिसका नाम < > MQL या < > PromQL है. बटन की जगह देखने के लिए, नीचे दी गई इमेज देखें.
पुष्टि करें कि भाषा टॉगल में PromQL चुना गया हो. भाषा टॉगल उसी टूलबार में होता है जिससे क्वेरी को फ़ॉर्मैट किया जा सकता है.
क्वेरी एडिटर में अपनी क्वेरी डालें:
```
sum(rate(logging_googleapis_com:user_model_interaction_count{monitored_resource="cloud_run_revision"}[${__interval}]))
```
PromQL का इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, क्लाउड मॉनिटरिंग में PromQL लेख पढ़ें.
क्वेरी चलाएं पर क्लिक करें. आपको इस स्क्रीनशॉट जैसा लाइन चार्ट दिखेगा:

ध्यान दें कि अपने-आप चलने वाला टॉगल चालू होने पर, क्वेरी चलाएं बटन नहीं दिखता.

10. (ज़रूरी नहीं) मॉनिटर करने और ट्रैक करने के लिए, Open Telemetry का इस्तेमाल करना

पिछले चरण में बताया गया था कि OpenTelemetry (Otel) SDK टूल का इस्तेमाल करके मेट्रिक लागू की जा सकती हैं. हमारा सुझाव है कि माइक्रो-सेवा आर्किटेक्चर पर OTel का इस्तेमाल करें. इस चरण में इनके बारे में बताया गया है:

ऐप्लिकेशन को ट्रैक और मॉनिटर करने के लिए, OTel कॉम्पोनेंट को शुरू करना
Cloud Run एनवायरमेंट के संसाधन मेटाडेटा की मदद से, OTel कॉन्फ़िगरेशन को पॉप्युलेट करना
अपने-आप ट्रैकिंग की सुविधाओं की मदद से, flask ऐप्लिकेशन को इंस्ट्रूमेंट करना
मॉडल के कॉल की संख्या को मॉनिटर करने के लिए, काउंटर मेट्रिक लागू करना
ऐप्लिकेशन लॉग के साथ ट्रैकिंग को जोड़ना

प्रॉडक्ट-लेवल की सेवाओं के लिए, हमारा सुझाव है कि आप OTel कलेक्टर का इस्तेमाल करें. इससे, एक या उससे ज़्यादा सेवाओं के लिए, निगरानी से जुड़ा सारा डेटा इकट्ठा और डाला जा सकता है. इस चरण में मौजूद कोड, आसानी से समझने के लिए कलेक्टर का इस्तेमाल नहीं करता. इसके बजाय, यह OTel एक्सपोर्ट का इस्तेमाल करता है, जो डेटा को सीधे Google Cloud में लिखता है.

ट्रैकिंग और मेट्रिक मॉनिटरिंग के लिए OTel कॉम्पोनेंट सेट अप करना

अपने ब्राउज़र में, ‘Cloud Shell' विंडो (या टैब) पर वापस जाएं.

टर्मिनल में, requirements.txt को डिपेंडेंसी की अतिरिक्त सूची के साथ अपडेट करें:

cat >> ~/codelab-o11y/requirements.txt << EOF
opentelemetry-api==1.24.0
opentelemetry-sdk==1.24.0
opentelemetry-exporter-otlp-proto-http==1.24.0
opentelemetry-instrumentation-flask==0.45b0
opentelemetry-instrumentation-requests==0.45b0
opentelemetry-exporter-gcp-trace==1.7.0
opentelemetry-exporter-gcp-monitoring==1.7.0a0   
EOF

नई फ़ाइल बनाने के लिए setup_opentelemetry.py:
```
cloudshell edit ~/codelab-o11y/setup_opentelemetry.py
```
अब आपको टर्मिनल के ऊपर मौजूद एडिटर विंडो में एक खाली फ़ाइल दिखेगी.

नीचे दिया गया कोड कॉपी करके, खोली गई setup_opentelemetry.py फ़ाइल में चिपकाएं:

import os

from opentelemetry import metrics
from opentelemetry import trace
from opentelemetry.exporter.cloud_monitoring import CloudMonitoringMetricsExporter
from opentelemetry.exporter.cloud_trace import CloudTraceSpanExporter
from opentelemetry.resourcedetector.gcp_resource_detector import GoogleCloudResourceDetector
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from opentelemetry.sdk.resources import get_aggregated_resources, Resource, CLOUD_ACCOUNT_ID, SERVICE_NAME
from opentelemetry.sdk.trace.export import BatchSpanProcessor

resource = get_aggregated_resources(
    [GoogleCloudResourceDetector(raise_on_error=True)]
)
resource = resource.merge(Resource.create(attributes={
    SERVICE_NAME: os.getenv("K_SERVICE"),
}))

meter_provider = MeterProvider(
    resource=resource,
    metric_readers=[
        PeriodicExportingMetricReader(
            CloudMonitoringMetricsExporter(), export_interval_millis=5000
        )
    ],
)
metrics.set_meter_provider(meter_provider)
meter = metrics.get_meter(__name__)

trace_provider = TracerProvider(resource=resource)
processor = BatchSpanProcessor(CloudTraceSpanExporter(
    # send all resource attributes
    resource_regex=r".*"
))
trace_provider.add_span_processor(processor)
trace.set_tracer_provider(trace_provider)

def google_trace_id_format(trace_id: int) -> str:
    project_id = resource.attributes[CLOUD_ACCOUNT_ID]
    return f'projects/{project_id}/traces/{trace.format_trace_id(trace_id)}'

कुछ सेकंड बाद, Cloud Shell Editor आपका कोड अपने-आप सेव कर देगा.

OTel का इस्तेमाल करके, ऐप्लिकेशन कोड को ट्रेसिंग और मॉनिटर करने की सुविधाओं के साथ इंस्ट्रूमेंट करना

टर्मिनल में, main.py को फिर से खोलें:
```
cloudshell edit ~/codelab-o11y/main.py
```
ऐप्लिकेशन के कोड में ये बदलाव करें:
1. import os लाइन (लाइन 1) से पहले, यह कोड डालें (आखिर में खाली लाइन का ध्यान रखें):
```
from setup_opentelemetry import google_trace_id_format
from opentelemetry import metrics, trace
from opentelemetry.instrumentation.requests import RequestsInstrumentor
from opentelemetry.instrumentation.flask import FlaskInstrumentor
```
2. format() तरीके (लाइन 9) का एलान करने के बाद, यह कोड डालें (इंडेंटेशन का ध्यान रखें):
```
        span = trace.get_current_span()
```
3. "message": record.getMessage() वाली लाइन 13 के बाद, यह कोड डालें (इनडेंटेशन का ध्यान रखें):
```
            "logging.googleapis.com/trace": google_trace_id_format(span.get_span_context().trace_id),
            "logging.googleapis.com/spanId": trace.format_span_id(span.get_span_context().span_id),
```
  इन दो अतिरिक्त एट्रिब्यूट की मदद से, ऐप्लिकेशन लॉग और OTel ट्रैकिंग स्पैन को जोड़ा जा सकता है.
4. app = Flask(__name__) लाइन (लाइन 31) के बाद, यह कोड डालें:
```
FlaskInstrumentor().instrument_app(app)
RequestsInstrumentor().instrument()
```
  ये लाइन, हमारे फ़्लैस्क ऐप्लिकेशन के सभी इनकमिंग और आउटगोइंग अनुरोधों को ट्रैकिंग के साथ इंस्ट्रूमेंट करती हैं.
5. जोड़े गए नए कोड के ठीक बाद (33वीं लाइन के बाद), यह कोड जोड़ें:
```
meter = metrics.get_meter(__name__)
requests_counter = meter.create_counter(
    name="model_call_counter",
    description="number of model invocations",
    unit="1"
)
```
  ये लाइनें, model_call_counter नाम के साथ काउंटर टाइप की नई मेट्रिक बनाती हैं और उसे एक्सपोर्ट के लिए रजिस्टर करती हैं.
6. logger.debug() (लाइन 49) को कॉल करने के बाद, यह कोड डालें:
```
    requests_counter.add(1, {'animal': animal})
```
  इस बदलाव से, जब भी ऐप्लिकेशन Gemini मॉडल के साथ इंटरैक्ट करने के लिए Vertex API को कॉल करेगा, तो काउंटर एक बढ़ जाएगा.

जेन एआई ऐप्लिकेशन के कोड को Cloud Run पर डिप्लॉय करना

टर्मिनल विंडो में, ऐप्लिकेशन के सोर्स कोड को Cloud Run पर डिप्लॉय करने के लिए कमांड चलाएं.
```
gcloud run deploy codelab-o11y-service \
     --source="${HOME}/codelab-o11y/" \
     --region=us-central1 \
     --allow-unauthenticated
```
अगर आपको नीचे दिया गया प्रॉम्प्ट दिखता है, तो इसका मतलब है कि यह कमांड एक नया रिपॉज़िटरी बनाएगा. Enter पर क्लिक करें.
```
Deploying from source requires an Artifact Registry Docker repository to store built containers.
A repository named [cloud-run-source-deploy] in region [us-central1] will be created.

Do you want to continue (Y/n)?
```
डिप्लॉयमेंट की प्रोसेस में कुछ मिनट लग सकते हैं. डिप्लॉयमेंट की प्रोसेस पूरी होने के बाद, आपको ऐसा आउटपुट दिखेगा:
```
Service [codelab-o11y-service] revision [codelab-o11y-service-00001-t2q] has been deployed and is serving 100 percent of traffic.
Service URL: https://codelab-o11y-service-12345678901.us-central1.run.app
```
Cloud Run सेवा का दिख रहा यूआरएल, अपने ब्राउज़र के किसी अलग टैब या विंडो में कॉपी करें. इसके अलावा, सेवा का यूआरएल प्रिंट करने के लिए, टर्मिनल में यह कमांड चलाएं. इसके बाद, यूआरएल खोलने के लिए Ctrl बटन को दबाकर दिखाए गए यूआरएल पर क्लिक करें:
```
gcloud run services list \
     --format='value(URL)' \
     --filter='SERVICE:"codelab-o11y-service"'
```
यूआरएल खोलने पर, आपको 500 गड़बड़ी का कोड या यह मैसेज दिख सकता है:
```
Sorry, this is just a placeholder...
```
इसका मतलब है कि सेवाएं डिप्लॉय नहीं हुईं. कुछ देर इंतज़ार करें और पेज को रीफ़्रेश करें. आखिर में, आपको कुत्तों के बारे में मज़ेदार बातें से शुरू होने वाला टेक्स्ट दिखेगा. इसमें कुत्तों के बारे में 10 मज़ेदार बातें होंगी.

टेलीमेट्री डेटा जनरेट करने के लिए, सेवा का यूआरएल खोलें. अलग-अलग नतीजे पाने के लिए, ?animal= पैरामीटर की वैल्यू बदलते समय पेज को रीफ़्रेश करें.

ऐप्लिकेशन के ट्रैक एक्सप्लोर करना

Cloud Console में ट्रेस एक्सप्लोरर पेज खोलने के लिए, नीचे दिए गए बटन पर क्लिक करें:
हाल ही में किए गए ट्रैक में से कोई एक चुनें. आपको पांच या छह स्पैन दिखेंगे, जो नीचे दिए गए स्क्रीनशॉट की तरह दिखेंगे.
वह स्पैन ढूंढें जो इवेंट हैंडलर (fun_facts तरीके) को कॉल करता है. यह / नाम वाला आखिरी स्पैन होगा.
ट्रेस की जानकारी पैनल में, लॉग और इवेंट चुनें. आपको इस खास स्पैन से जुड़े ऐप्लिकेशन लॉग दिखेंगे. कोरिलेशन का पता लगाने के लिए, ट्रैक और स्पैन आईडी का इस्तेमाल किया जाता है. ये आईडी, ट्रैक और लॉग में मौजूद होते हैं. आपको वह ऐप्लिकेशन लॉग दिखेगा जिसने प्रॉम्प्ट और Vertex API का रिस्पॉन्स लिखा है.

काउंटर मेट्रिक के बारे में जानकारी

Cloud Console में मेट्रिक एक्सप्लोरर पेज खोलने के लिए, नीचे दिए गए बटन पर क्लिक करें:
क्वेरी बिल्डर पैनल के टूलबार में, वह बटन चुनें जिसका नाम < > MQL या < > PromQL है. बटन की जगह देखने के लिए, नीचे दी गई इमेज देखें.
पुष्टि करें कि भाषा टॉगल में PromQL चुना गया हो. भाषा टॉगल उसी टूलबार में होता है जिससे क्वेरी को फ़ॉर्मैट किया जा सकता है.

क्वेरी एडिटर में अपनी क्वेरी डालें:

sum(rate(workload_googleapis_com:model_call_counter{monitored_resource="generic_task"}[${__interval}]))

क्वेरी चलाएं पर क्लिक करें.अपने-आप चलने की सुविधा टॉगल चालू होने पर, क्वेरी चलाएं बटन नहीं दिखता.

11. (ज़रूरी नहीं) लॉग से छिपाई गई संवेदनशील जानकारी

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

आने वाली लॉग एंट्री को सेव करने के लिए, PubSub विषय बनाना
ऐसा लॉग सिंक बनाएं जो डाले गए लॉग को Pub/Sub विषय पर रीडायरेक्ट करता हो.
Dataflow पाइपलाइन बनाएं, जो PubSub विषय पर रीडायरेक्ट किए गए लॉग में बदलाव करती है. इसके लिए, यह तरीका अपनाएं:
1. Pub/Sub विषय से लॉग एंट्री पढ़ना
2. DLP inspection API का इस्तेमाल करके, संवेदनशील जानकारी के लिए एंट्री के पेलोड की जांच करना
3. डीएलपी के तहत, संवेदनशील जानकारी हटाने के किसी तरीके का इस्तेमाल करके, पेलोड में मौजूद संवेदनशील जानकारी हटाएं
4. Cloud Logging में, छिपाई गई लॉग एंट्री लिखना
पाइपलाइन डिप्लॉय करना

12. (ज़रूरी नहीं) क्लीन अप करना

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

चेतावनी: किसी प्रोजेक्ट को मिटाने पर, ये असर होते हैं:

– प्रोजेक्ट में मौजूद सारा कॉन्टेंट मिट जाता है. अगर आपने इस दस्तावेज़ में मौजूद टास्क के लिए किसी मौजूदा प्रोजेक्ट का इस्तेमाल किया है, तो उसे मिटाने पर, प्रोजेक्ट में किया गया आपका सारा काम भी मिट जाएगा.
– कस्टम प्रोजेक्ट आईडी मिट जाते हैं. ऐसा हो सकता है कि इस प्रोजेक्ट को बनाते समय, आपने कोई कस्टम प्रोजेक्ट आईडी बनाया हो. आने वाले समय में, इसका इस्तेमाल किया जा सकता है. प्रोजेक्ट आईडी का इस्तेमाल करने वाले यूआरएल, जैसे कि appspot.com यूआरएल को सुरक्षित रखने के लिए, पूरे प्रोजेक्ट को मिटाने के बजाय, प्रोजेक्ट में मौजूद चुनिंदा संसाधनों को मिटाएं.

अगर आपको अपने बनाए गए ऐप्लिकेशन को एक्सप्लोर करना है, तो प्रोजेक्ट का फिर से इस्तेमाल करने से आपका समय बच सकता है. साथ ही, प्रोजेक्ट के कोटे की सीमाओं को पार करने से भी बचा जा सकता है.

प्रोजेक्ट मिटाने के लिए, टर्मिनल में delete project कमांड चलाएं:
```
PROJECT_ID=$(gcloud config get-value project)
gcloud projects delete ${PROJECT_ID} --quiet
```
अपने Cloud प्रोजेक्ट को मिटाने पर, उस प्रोजेक्ट में इस्तेमाल किए गए सभी संसाधनों और एपीआई के लिए बिलिंग बंद हो जाती है. आपको यह मैसेज दिखेगा, जिसमें PROJECT_ID आपका प्रोजेक्ट आईडी होगा:
```
Deleted [https://cloudresourcemanager.googleapis.com/v1/projects/PROJECT_ID].

You can undo this operation for a limited period by running the command below.
    $ gcloud projects undelete PROJECT_ID

See https://cloud.google.com/resource-manager/docs/creating-managing-projects for information on shutting down projects.
```
(ज़रूरी नहीं) अगर आपको कोई गड़बड़ी मिलती है, तो लैब के दौरान इस्तेमाल किया गया प्रोजेक्ट आईडी ढूंढने के लिए, पांचवें चरण का पालन करें. इसे पहले निर्देश में दिए गए निर्देश से बदलें. उदाहरण के लिए, अगर आपका प्रोजेक्ट आईडी lab-example-project है, तो कमांड यह होगा:
```
gcloud projects delete lab-project-id-example --quiet
```

13. बधाई हो

इस लैब में, आपने एक Gen AI ऐप्लिकेशन बनाया है. यह ऐप्लिकेशन, अनुमान लगाने के लिए Gemini मॉडल का इस्तेमाल करता है. साथ ही, ऐप्लिकेशन को मॉनिटर करने और लॉग करने की ज़रूरी सुविधाओं से इंस्ट्रूमेंट किया. आपने ऐप्लिकेशन और सोर्स कोड से Cloud Run में किए गए बदलावों को डिप्लॉय किया है. इसके बाद, ऐप्लिकेशन की परफ़ॉर्मेंस को ट्रैक करने के लिए, Google Cloud के निगरानी वाले प्रॉडक्ट का इस्तेमाल करें. इससे, आपको ऐप्लिकेशन के भरोसेमंद होने का भरोसा मिलेगा.

अगर आपको आज इस्तेमाल किए गए प्रॉडक्ट को बेहतर बनाने के लिए, उपयोगकर्ता अनुभव (UX) की रिसर्च स्टडी में शामिल होना है, तो यहां रजिस्टर करें.

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

कोडलैब Gemini की मदद से काम करने वाले चैट ऐप्लिकेशन को Cloud Run पर डिप्लॉय करने का तरीका
कोडलैब Cloud Run की मदद से, Gemini फ़ंक्शन कॉलिंग का इस्तेमाल कैसे करें
वीडियो के हर सीन को प्रोसेस करने के लिए, Cloud Run Jobs Video Intelligence API का इस्तेमाल कैसे करें
ऑन-डिमांड वर्कशॉप Google Kubernetes Engine को शामिल करना
ऐप्लिकेशन लॉग का इस्तेमाल करके, काउंटर और डिस्ट्रिब्यूशन मेट्रिक को कॉन्फ़िगर करने के बारे में ज़्यादा जानें
OpenTelemetry साइडकार का इस्तेमाल करके, OTLP मेट्रिक लिखना
Google Cloud में Open Telemetry का इस्तेमाल करने के बारे में रेफ़रंस