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

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 Editor तैयार करना

Cloud Shell Editor पर जाएं. अगर आपको यह मैसेज दिखता है, जिसमें Cloud Shell को अपने क्रेडेंशियल के साथ gcloud को कॉल करने की अनुमति देने का अनुरोध किया गया है, तो जारी रखने के लिए अनुमति दें पर क्लिक करें.
टर्मिनल विंडो खोलें
1. हैमबर्गर मेन्यू पर क्लिक करें
2. टर्मिनल पर क्लिक करें
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 Go ऐप्लिकेशन बनाना

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

टर्मिनल में, codelab-o11y डायरेक्ट्री बनाएं:
```
mkdir ~/codelab-o11y
```
मौजूदा डायरेक्ट्री को codelab-o11y में बदलें:
```
cd ~/codelab-o11y
```
Go मॉड्यूल शुरू करें:
```
go mod init codelab
```
Go के लिए Vertex AI SDK इंस्टॉल करें:
```
go get cloud.google.com/go/vertexai/genai
```
मौजूदा प्रोजेक्ट आईडी पाने के लिए, Go के लिए मेटाडेटा लाइब्रेरी इंस्टॉल करें:
```
go get cloud.google.com/go/compute/metadata
```
setup.go फ़ाइल बनाएं और उसे Cloud Shell Editor में खोलें:
```
cloudshell edit setup.go
```
इसका इस्तेमाल, इनिशियलाइज़ेशन कोड को होस्ट करने के लिए किया जाएगा. एडिटर विंडो में, setup.go नाम की एक नई फ़ाइल दिखेगी.

यहां दिए गए कोड को कॉपी करें और इसे खोली गई setup.go फ़ाइल में चिपकाएं:

package main

import (
    "context"
    "os"

    "cloud.google.com/go/compute/metadata"
)

func projectID(ctx context.Context) (string, error) {
    var projectID = os.Getenv("GOOGLE_CLOUD_PROJECT")
    if projectID == "" {
           return metadata.ProjectIDWithContext(ctx)
    }
    return projectID, nil
}

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

यहां दिए गए कोड को कॉपी करें और इसे खोली गई main.go फ़ाइल में चिपकाएं:

package main

import (
    "context"
    "fmt"
    "net/http"
    "os"

    "cloud.google.com/go/vertexai/genai"
)

var model *genai.GenerativeModel

func main() {
    ctx := context.Background()
    projectID, err := projectID(ctx)
    if err != nil {
        return
    }

    var client *genai.Client
    client, err = genai.NewClient(ctx, projectID, "us-central1")
    if err != nil {
        return
    }
    defer client.Close()
       model = client.GenerativeModel("gemini-1.5-flash-001")
       http.HandleFunc("/", Handler)
       port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }
    if err := http.ListenAndServe(":"+port, nil); err != nil {
        return
    }
}

func Handler(w http.ResponseWriter, r *http.Request) {
    animal := r.URL.Query().Get("animal")
    if animal == "" {
        animal = "dog"
    }

    prompt := fmt.Sprintf("Give me 10 fun facts about %s. Return the results as HTML without markdown backticks.", animal)
    resp, err := model.GenerateContent(r.Context(), genai.Text(prompt))
    if err != nil {
        w.WriteHeader(http.StatusTooManyRequests)
        return
    }

    if len(resp.Candidates) > 0 && len(resp.Candidates[0].Content.Parts) > 0 {
        htmlContent := resp.Candidates[0].Content.Parts[0]
        w.Header().Set("Content-Type", "text/html; charset=utf-8")
        fmt.Fprint(w, htmlContent)
    }
}

कुछ सेकंड बाद, 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 API कॉल का ऑडिट करना

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"
```
क्वेरी पैन, Logs Explorer पेज पर सबसे ऊपर मौजूद एक एडिटर होता है:
क्वेरी चलाएं पर क्लिक करें.
ऑडिट लॉग की किसी एक एंट्री को चुनता है और फ़ील्ड को बड़ा करता है, ताकि लॉग में कैप्चर की गई जानकारी की जांच की जा सके.
Vertex API कॉल के बारे में जानकारी देखी जा सकती है. इसमें इस्तेमाल किया गया तरीका और मॉडल शामिल है. इसके अलावा, आपको यह भी पता चल सकता है कि कॉल किसने किया और कॉल करने के लिए किन अनुमतियों का इस्तेमाल किया गया.

8. जेन एआई के साथ हुई बातचीत को लॉग करना

आपको ऑडिट लॉग में, एपीआई अनुरोध के पैरामीटर या जवाब का डेटा नहीं मिलता. हालांकि, ऐप्लिकेशन और वर्कफ़्लो के विश्लेषण से जुड़ी समस्याओं को हल करने के लिए, यह जानकारी अहम हो सकती है. इस चरण में, हम ऐप्लिकेशन लॉगिंग की सुविधा जोड़कर इस कमी को पूरा करते हैं. लॉगिंग के लिए, स्ट्रक्चर्ड लॉग लिखने के लिए स्टैंडर्ड Go log/slog पैकेज का इस्तेमाल किया जाता है. log/slog पैकेज को Google Cloud में लॉग लिखने का तरीका नहीं पता है. यह स्टैंडर्ड आउटपुट में लिखने की सुविधा देता है. हालांकि, Cloud Run में ऐसी सुविधाएं होती हैं जो स्टैंडर्ड आउटपुट में प्रिंट की गई जानकारी को कैप्चर करती हैं और उसे Cloud Logging में अपने-आप भेज देती हैं. स्ट्रक्चर्ड लॉग को सही तरीके से कैप्चर करने के लिए, प्रिंट किए गए लॉग को उसी के हिसाब से फ़ॉर्मैट किया जाना चाहिए. हमारे Go ऐप्लिकेशन में स्ट्रक्चर्ड लॉगिंग की सुविधाएं जोड़ने के लिए, यहां दिए गए निर्देशों का पालन करें.

अपने ब्राउज़र में ‘Cloud Shell' विंडो (या टैब) पर वापस जाएं.
टर्मिनल में, setup.go को फिर से खोलें:
```
cloudshell edit ~/codelab-o11y/setup.go
```

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

package main

import (
	"context"
	"os"
	"log/slog"
	"cloud.google.com/go/compute/metadata"
)

func projectID(ctx context.Context) (string, error) {
    var projectID = os.Getenv("GOOGLE_CLOUD_PROJECT")
    if projectID == "" {
           return metadata.ProjectIDWithContext(ctx)
    }
    return projectID, nil
}

func setupLogging() {
    opts := &slog.HandlerOptions{
        Level: slog.LevelDebug,
        ReplaceAttr: func(group []string, a slog.Attr) slog.Attr {
            switch a.Key {
            case slog.LevelKey:
                a.Key = "severity"
                if level := a.Value.Any().(slog.Level); level == slog.LevelWarn {
                    a.Value = slog.StringValue("WARNING")
                }
            case slog.MessageKey:
                a.Key = "message"
            case slog.TimeKey:
                a.Key = "timestamp"
            }
            return a
        },
    }
    jsonHandler := slog.NewJSONHandler(os.Stdout, opts)
    slog.SetDefault(slog.New(jsonHandler))
}

टर्मिनल पर वापस जाएं और main.go को फिर से खोलें:
```
cloudshell edit ~/codelab-o11y/main.go
```

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

package main

import (
    "context"
    "fmt"
    "net/http"
    "os"

    "encoding/json"
    "log/slog"

    "cloud.google.com/go/vertexai/genai"
)

var model *genai.GenerativeModel

func main() {
    ctx := context.Background()
    projectID, err := projectID(ctx)
    if err != nil {
        return
    }

    setupLogging()

    var client *genai.Client
    client, err = genai.NewClient(ctx, projectID, "us-central1")
    if err != nil {
        slog.ErrorContext(ctx, "Failed to marshal response to JSON", slog.Any("error", err))
        os.Exit(1)
    }
    defer client.Close()
    model = client.GenerativeModel("gemini-1.5-flash-001")
    http.HandleFunc("/", Handler)
    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }
    if err := http.ListenAndServe(":"+port, nil); err != nil {
        slog.ErrorContext(ctx, "Failed to start the server", slog.Any("error", err))
        os.Exit(1)
    }
}

func Handler(w http.ResponseWriter, r *http.Request) {
    animal := r.URL.Query().Get("animal")
    if animal == "" {
        animal = "dog"
    }

    prompt := fmt.Sprintf("Give me 10 fun facts about %s. Return the results as HTML without markdown backticks.", animal)
    resp, err := model.GenerateContent(r.Context(), genai.Text(prompt))
    if err != nil {
        w.WriteHeader(http.StatusTooManyRequests)
        return
    }

    jsonBytes, err := json.Marshal(resp)
    if err != nil {
        slog.Error("Failed to marshal response to JSON", slog.Any("error", err))
    } else {
        slog.DebugContext(r.Context(), "content is generated", slog.String("animal", animal),
            slog.String("prompt", prompt), slog.String("response", string(jsonBytes)))
    }

    if len(resp.Candidates) > 0 && len(resp.Candidates[0].Content.Parts) > 0 {
        htmlContent := resp.Candidates[0].Content.Parts[0]
        w.Header().Set("Content-Type", "text/html; charset=utf-8")
        fmt.Fprint(w, htmlContent)
    }
}

लॉगिंग को stdout पर लॉग प्रिंट करने के लिए कॉन्फ़िगर किया जाता है. यहां Cloud Run logging agent, लॉग इकट्ठा करता है और उन्हें Cloud Logging में एसिंक्रोनस तरीके से भेजता है. main() फ़ंक्शन में बदलाव किया गया है, ताकि Go स्टैंडर्ड स्ट्रक्चर्ड लॉग को सेट अप किया जा सके. इससे JSON स्कीमा का इस्तेमाल किया जा सकेगा. यह स्कीमा, स्ट्रक्चर्ड फ़ॉर्मैटिंग के दिशा-निर्देशों का पालन करता है. इसके सभी return स्टेटमेंट को ऐसे कोड से बदल दिया जाता है जो बंद होने से पहले गड़बड़ी के लॉग लिखता है. Vertex AI API कॉल से जवाब मिलने पर, स्ट्रक्चर्ड लॉग लिखने के लिए Handler() फ़ंक्शन का इस्तेमाल किया जाता है. इस लॉग में, अनुरोध के एनिमल पैरामीटर के साथ-साथ मॉडल के प्रॉम्प्ट और जवाब को कैप्चर किया जाता है.

कुछ सेकंड बाद, 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, मैनेज की गई मेट्रिक लिखता है. इनका इस्तेमाल, डिप्लॉय की गई सेवाओं को मॉनिटर करने के लिए किया जा सकता है. उपयोगकर्ता की ओर से मैनेज की जाने वाली मॉनिटरिंग मेट्रिक की मदद से, डेटा और मेट्रिक अपडेट की फ़्रीक्वेंसी को बेहतर तरीके से कंट्रोल किया जा सकता है. इस तरह की मेट्रिक को लागू करने के लिए, एक ऐसा कोड लिखना होता है जो डेटा इकट्ठा करता है और उसे Cloud Monitoring में लिखता है. 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 का इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, Cloud Monitoring में PromQL लेख पढ़ें.
क्वेरी चलाएं पर क्लिक करें. आपको इस स्क्रीनशॉट की तरह एक लाइन चार्ट दिखेगा:

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

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

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

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

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

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

अपने ब्राउज़र में ‘Cloud Shell' विंडो (या टैब) पर वापस जाएं.
टर्मिनल में, setup.go को फिर से खोलें:
```
cloudshell edit ~/codelab-o11y/setup.go
```

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

package main

import (
    "context"
    "errors"
    "fmt"
    "net/http"
    "os"

    "log/slog"

    "go.opentelemetry.io/contrib/detectors/gcp"
    "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
    "go.opentelemetry.io/contrib/propagators/autoprop"
    "go.opentelemetry.io/otel"
    sdkmetric "go.opentelemetry.io/otel/sdk/metric"
    "go.opentelemetry.io/otel/sdk/resource"
    sdktrace "go.opentelemetry.io/otel/sdk/trace"
    semconv "go.opentelemetry.io/otel/semconv/v1.27.0"
    "go.opentelemetry.io/otel/trace"

    cloudmetric "github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/metric"
    cloudtrace "github.com/GoogleCloudPlatform/opentelemetry-operations-go/exporter/trace"

    "cloud.google.com/go/compute/metadata"
)

var (
    projID string
)

func projectID(ctx context.Context) (string, error) {
    var projectID = os.Getenv("GOOGLE_CLOUD_PROJECT")
    if projectID == "" {
        return metadata.ProjectIDWithContext(ctx)
    }
    return projectID, nil
}

func setupLogging() {
    opts := &slog.HandlerOptions{
        Level: slog.LevelDebug,
        ReplaceAttr: func(group []string, a slog.Attr) slog.Attr {
            switch a.Key {
            case slog.LevelKey:
                a.Key = "severity"
                if level := a.Value.Any().(slog.Level); level == slog.LevelWarn {
                    a.Value = slog.StringValue("WARNING")
                }
            case slog.MessageKey:
                a.Key = "message"
            case slog.TimeKey:
                a.Key = "timestamp"
            }
            return a
        },
    }
    jsonHandler := slog.NewJSONHandler(os.Stdout, opts)
    instrumentedHandler := handlerWithSpanContext(jsonHandler)
    slog.SetDefault(slog.New(instrumentedHandler))
}

type spanContextLogHandler struct {
    slog.Handler
}

func handlerWithSpanContext(handler slog.Handler) *spanContextLogHandler {
    return &spanContextLogHandler{Handler: handler}
}

func (t *spanContextLogHandler) Handle(ctx context.Context, record slog.Record) error {
    if s := trace.SpanContextFromContext(ctx); s.IsValid() {
        trace := fmt.Sprintf("projects/%s/traces/%s", projID, s.TraceID())
        record.AddAttrs(
            slog.Any("logging.googleapis.com/trace", trace),
        )
        record.AddAttrs(
            slog.Any("logging.googleapis.com/spanId", s.SpanID()),
        )
        record.AddAttrs(
            slog.Bool("logging.googleapis.com/trace_sampled", s.TraceFlags().IsSampled()),
        )
    }
    return t.Handler.Handle(ctx, record)
}

func setupTelemetry(ctx context.Context) (shutdown func(context.Context) error, err error) {
    var shutdownFuncs []func(context.Context) error
    shutdown = func(ctx context.Context) error {
        var err error
        for _, fn := range shutdownFuncs {
            err = errors.Join(err, fn(ctx))
        }
        shutdownFuncs = nil
        return err
    }

    projID, err = projectID(ctx)
    if err != nil {
        err = errors.Join(err, shutdown(ctx))
        return
    }

    res, err2 := resource.New(
        ctx,
        resource.WithDetectors(gcp.NewDetector()),
        resource.WithTelemetrySDK(),
        resource.WithAttributes(semconv.ServiceNameKey.String(os.Getenv("K_SERVICE"))),
    )
    if err2 != nil {
        err = errors.Join(err2, shutdown(ctx))
        return
    }

    otel.SetTextMapPropagator(autoprop.NewTextMapPropagator())

    texporter, err2 := cloudtrace.New(cloudtrace.WithProjectID(projID))
    if err2 != nil {
        err = errors.Join(err2, shutdown(ctx))
        return
    }
    tp := sdktrace.NewTracerProvider(
        sdktrace.WithSampler(sdktrace.AlwaysSample()),
        sdktrace.WithResource(res),
        sdktrace.WithBatcher(texporter))
    shutdownFuncs = append(shutdownFuncs, tp.Shutdown)
    otel.SetTracerProvider(tp)

    mexporter, err2 := cloudmetric.New(cloudmetric.WithProjectID(projID))
    if err2 != nil {
        err = errors.Join(err2, shutdown(ctx))
        return
    }
    mp := sdkmetric.NewMeterProvider(
        sdkmetric.WithReader(sdkmetric.NewPeriodicReader(mexporter)),
        sdkmetric.WithResource(res),
    )
    shutdownFuncs = append(shutdownFuncs, mp.Shutdown)
    otel.SetMeterProvider(mp)

    return shutdown, nil
}

func registerHttpHandler(route string, handleFn http.HandlerFunc) {
    instrumentedHandler := otelhttp.NewHandler(otelhttp.WithRouteTag(route, handleFn), route)
    http.Handle(route, instrumentedHandler)
}

टर्मिनल पर वापस जाएं और go.mod फ़ाइल में Go मॉड्यूल की परिभाषाओं को अपडेट करने के लिए, यह कमांड चलाएं:
```
go mod tidy
```
टर्मिनल पर वापस जाएं और main.go को फिर से खोलें:
```
cloudshell edit ~/codelab-o11y/main.go
```

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

package main

import (
    "context"
    "errors"
    "fmt"
    "net/http"
    "os"

    "encoding/json"
    "log/slog"

    "cloud.google.com/go/vertexai/genai"

    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/metric"
)

var model *genai.GenerativeModel
var counter metric.Int64Counter

const scopeName = "genai-o11y/go/workshop/example"

func main() {
    ctx := context.Background()
    projectID, err := projectID(ctx)
    if err != nil {
        return
    }

    setupLogging()
    shutdown, err := setupTelemetry(ctx)
    if err != nil {
        slog.ErrorContext(ctx, "error setting up OpenTelemetry", slog.Any("error", err))
        os.Exit(1)
    }
    meter := otel.Meter(scopeName)
    counter, err = meter.Int64Counter("model_call_counter")
    if err != nil {
        slog.ErrorContext(ctx, "error setting up OpenTelemetry", slog.Any("error", err))
        os.Exit(1)
    }

    var client *genai.Client
    client, err = genai.NewClient(ctx, projectID, "us-central1")
    if err != nil {
        slog.ErrorContext(ctx, "Failed to marshal response to JSON", slog.Any("error", err))
        os.Exit(1)
    }
    defer client.Close()
    model = client.GenerativeModel("gemini-1.5-flash-001")

    registerHttpHandler("/", Handler)

    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    if err = errors.Join(http.ListenAndServe(":"+port, nil), shutdown(ctx)); err != nil {
        slog.ErrorContext(ctx, "Failed to start the server", slog.Any("error", err))
        os.Exit(1)
    }
}

func Handler(w http.ResponseWriter, r *http.Request) {
    animal := r.URL.Query().Get("animal")
    if animal == "" {
        animal = "dog"
    }

    prompt := fmt.Sprintf("Give me 10 fun facts about %s. Return the results as HTML without markdown backticks.", animal)
    resp, err := model.GenerateContent(r.Context(), genai.Text(prompt))
    if err != nil {
        w.WriteHeader(http.StatusTooManyRequests)
        return
    }
    jsonBytes, err := json.Marshal(resp)
    if err != nil {
        slog.ErrorContext(r.Context(), "Failed to marshal response to JSON", slog.Any("error", err))
    } else {
        slog.DebugContext(r.Context(), "content is generated", slog.String("animal", animal),
            slog.String("prompt", prompt), slog.String("response", string(jsonBytes)))
    }
    if len(resp.Candidates) > 0 && len(resp.Candidates[0].Content.Parts) > 0 {
        clabels := []attribute.KeyValue{attribute.Key("animal").String(animal)}
        counter.Add(r.Context(), 1, metric.WithAttributes(clabels...))
        htmlContent := resp.Candidates[0].Content.Parts[0]
        w.Header().Set("Content-Type", "text/html; charset=utf-8")
        fmt.Fprint(w, htmlContent)
    }
}

अब ऐप्लिकेशन, OpenTelemetry SDK का इस्तेमाल करता है. इससे कोड को ट्रेस करने और मेट्रिक के तौर पर, कोड के सही तरीके से लागू होने की संख्या को गिनने में मदद मिलती है. main() तरीके में बदलाव किया गया है, ताकि ट्रेस और मेट्रिक के लिए OpenTelemetry एक्सपोर्टर सेट अप किए जा सकें. इससे Google Cloud Tracing और Monitoring में सीधे तौर पर डेटा लिखा जा सकेगा. यह इकट्ठा किए गए ट्रेस और मेट्रिक में, Cloud Run एनवायरमेंट से जुड़ा मेटाडेटा भरने के लिए अतिरिक्त कॉन्फ़िगरेशन भी करता है. Handler() फ़ंक्शन को अपडेट किया गया है, ताकि Vertex AI API कॉल से मान्य नतीजे मिलने पर, मेट्रिक काउंटर को हर बार बढ़ाया जा सके.

कुछ सेकंड बाद, 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 में Trace explorer पेज खोलने के लिए, नीचे दिए गए बटन पर क्लिक करें:
सबसे हाल के ट्रेस में से किसी एक को चुनें. आपको पांच या छह स्पैन दिखेंगे. ये स्पैन, नीचे दिए गए स्क्रीनशॉट में दिखाए गए स्पैन की तरह दिखेंगे.
उस स्पैन को ढूंढें जो इवेंट हैंडलर (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 विषय बनाएं
एक लॉग सिंक बनाएं, जो PubSub विषय पर भेजे गए लॉग को रीडायरेक्ट करता हो.
PubSub विषय पर रीडायरेक्ट किए गए लॉग में बदलाव करने के लिए, Dataflow पाइपलाइन बनाएं. इसके लिए, यह तरीका अपनाएं:
1. PubSub विषय से लॉग एंट्री पढ़ना
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. बधाई हो

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

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

यहां सीखने के कुछ विकल्प दिए गए हैं:

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

Go का इस्तेमाल करके, OpenTelemetry ट्रेस और मेट्रिक जनरेट करना