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

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

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

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

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

  • Cloud Shell Editor की मदद से, Vertex AI का इस्तेमाल करने वाला ऐप्लिकेशन लिखना
  • अपने ऐप्लिकेशन का कोड GitHub में सेव करना
  • अपने ऐप्लिकेशन के सोर्स कोड को Cloud Run पर डिप्लॉय करने के लिए, gcloud CLI का इस्तेमाल करना
  • अपने जेन एआई ऐप्लिकेशन में मॉनिटरिंग और लॉगिंग की सुविधाएं जोड़ना
  • लॉग-आधारित मेट्रिक का इस्तेमाल करना
  • Open Telemetry SDK टूल की मदद से लॉगिंग और मॉनिटरिंग लागू करना
  • ज़िम्मेदारी से डेटा मैनेज करने वाले एआई के बारे में अहम जानकारी पाना

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

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

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

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

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

  1. Cloud Shell एडिटर पर जाएं. अगर आपको नीचे दिया गया मैसेज दिखता है, तो cloud shell को अपने क्रेडेंशियल के साथ gcloud को कॉल करने की अनुमति देने के लिए कहा जाएगा. जारी रखने के लिए, अनुमति दें पर क्लिक करें.
    Cloud Shell को अनुमति देने के लिए क्लिक करें
  2. टर्मिनल विंडो खोलें
    1. हैमबर्गर मेन्यू हैमबर्गर मेन्यू का आइकॉन पर क्लिक करें
    2. Terminal पर क्लिक करें
    3. नया टर्मिनल
      Cloud Shell एडिटर में नया टर्मिनल खोलना पर क्लिक करें
  3. टर्मिनल में, अपना प्रोजेक्ट आईडी कॉन्फ़िगर करें:
    gcloud config set project [PROJECT_ID]
    
    [PROJECT_ID] की जगह अपने प्रोजेक्ट का आईडी डालें. उदाहरण के लिए, अगर आपका प्रोजेक्ट आईडी lab-example-project है, तो कमांड यह होगा:
    gcloud config set project lab-project-id-example
    
    अगर आपको यह मैसेज दिखता है कि gcloud, GCPI API से आपके क्रेडेंशियल का अनुरोध कर रहा है, तो जारी रखने के लिए अनुमति दें पर क्लिक करें.
    Cloud Shell को अनुमति देने के लिए क्लिक करें
    कार्रवाई पूरी होने पर, आपको यह मैसेज दिखेगा:
    Updated property [core/project].
    
    अगर आपको WARNING दिखता है और आपसे Do you want to continue (Y/N)? पूछा जाता है, तो हो सकता है कि आपने प्रोजेक्ट आईडी गलत डाला हो. सही प्रोजेक्ट आईडी मिलने के बाद, N दबाएं, Enter दबाएं, और gcloud config set project कमांड को फिर से चलाने की कोशिश करें.
  4. (ज़रूरी नहीं) अगर आपको प्रोजेक्ट आईडी ढूंढने में समस्या आ रही है, तो अपने सभी प्रोजेक्ट के प्रोजेक्ट आईडी देखने के लिए, नीचे दिया गया निर्देश चलाएं. प्रोजेक्ट आईडी, बनाने के समय के हिसाब से, घटते क्रम में दिखेंगे:
    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 मॉडल का इस्तेमाल करता है. ऐप्लिकेशन कोड बनाने के लिए, यह तरीका अपनाएं.

  1. टर्मिनल में, codelab-o11y डायरेक्ट्री बनाएं:
    mkdir ~/codelab-o11y
    
  2. मौजूदा डायरेक्ट्री को codelab-o11y में बदलने के लिए:
    cd ~/codelab-o11y
    
  3. Go मॉड्यूल शुरू करना:
    go mod init codelab
    
  4. Go के लिए Vertex AI SDK इंस्टॉल करें:
    go get cloud.google.com/go/vertexai/genai
    
  5. मौजूदा प्रोजेक्ट आईडी पाने के लिए, Go के लिए मेटाडेटा लाइब्रेरी इंस्टॉल करें:
    go get cloud.google.com/go/compute/metadata
    
  6. setup.go फ़ाइल बनाएं और उसे Cloud Shell Editor में खोलें:
    cloudshell edit setup.go
    
    इसका इस्तेमाल, कोड को शुरू करने के लिए किया जाएगा. एडिटर विंडो में, setup.go नाम वाली एक नई खाली फ़ाइल दिखेगी.
  7. नीचे दिया गया कोड कॉपी करके, खोली गई 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
    }
    
  8. टर्मिनल विंडो पर वापस जाएं और Cloud Shell एडिटर में main.go फ़ाइल बनाने और खोलने के लिए, यह कमांड चलाएं:
    cloudshell edit main.go
    
    अब आपको टर्मिनल के ऊपर मौजूद एडिटर विंडो में एक खाली फ़ाइल दिखेगी. आपकी स्क्रीन कुछ इस तरह दिखेगी:
    main.go में बदलाव करने के बाद, Cloud Shell एडिटर दिखाना
  9. नीचे दिया गया कोड कॉपी करके, खोली गई 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 पर डिप्लॉय करना

  1. टर्मिनल विंडो में, ऐप्लिकेशन के सोर्स कोड को 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
    
  2. 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 में "डेटा पढ़ना" ऑडिट लॉग चालू करने होंगे.

  1. Cloud Console में ऑडिट लॉग पेज खोलने के लिए, नीचे दिए गए बटन पर क्लिक करें

  2. पक्का करें कि पेज पर वह प्रोजेक्ट हो जिसे आपने इस लैब के लिए बनाया है. चुना गया प्रोजेक्ट, पेज के सबसे ऊपर बाएं कोने में है. यह हैमबर्गर मेन्यू के ठीक सामने होता है:
    Google Cloud Console के प्रोजेक्ट का ड्रॉपडाउन
    अगर ज़रूरी हो, तो कॉम्बोबॉक्स से सही प्रोजेक्ट चुनें.
  3. डेटा ऐक्सेस ऑडिट लॉग कॉन्फ़िगरेशन टेबल में, सेवा कॉलम में Vertex AI API सेवा ढूंढें. इसके बाद, सेवा के नाम के बाईं ओर मौजूद चेकबॉक्स को चुनकर सेवा चुनें.
    Vertex AI API चुनना
  4. दाईं ओर मौजूद जानकारी वाले पैनल में, "डेटा पढ़ा गया" ऑडिट टाइप चुनें.
    डेटा पढ़ने से जुड़े लॉग देखना
  5. सेव करें पर क्लिक करें.

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

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

  1. Cloud Console में लॉग एक्सप्लोरर पेज खोलने के लिए, नीचे दिए गए बटन पर क्लिक करें:

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

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

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

  1. अपने ब्राउज़र में, ‘Cloud Shell' विंडो (या टैब) पर वापस जाएं.
  2. टर्मिनल में, setup.go को फिर से खोलें:
    cloudshell edit ~/codelab-o11y/setup.go
    
  3. कोड को उस वर्शन से बदलें जो लॉगिंग सेट अप करता है. कोड बदलने के लिए, फ़ाइल का कॉन्टेंट मिटाएं. इसके बाद, नीचे दिया गया कोड कॉपी करके एडिटर में चिपकाएं:
    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))
    }
    
  4. टर्मिनल पर वापस जाएं और main.go को फिर से खोलें:
    cloudshell edit ~/codelab-o11y/main.go
    
  5. ऐप्लिकेशन कोड को उस वर्शन से बदलें जो मॉडल के साथ इंटरैक्शन को लॉग करता है. कोड बदलने के लिए, फ़ाइल का कॉन्टेंट मिटाएं. इसके बाद, नीचे दिया गया कोड कॉपी करके एडिटर में चिपकाएं:
    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 लॉगिंग एजेंट इसे इकट्ठा करता है और Cloud Logging में असिंक्रोनस तरीके से डालता है. main() फ़ंक्शन में बदलाव किया गया है, ताकि Go स्टैंडर्ड स्ट्रक्चर्ड लॉग को सेटअप किया जा सके. इससे, स्ट्रक्चर्ड फ़ॉर्मैटिंग के दिशा-निर्देशों का पालन करने वाले JSON स्कीमा का इस्तेमाल किया जा सकेगा. इसके सभी return स्टेटमेंट को उस कोड से बदल दिया जाता है जो प्रोग्राम से बाहर निकलने से पहले गड़बड़ी के लॉग लिखता है. Vertex AI API कॉल से जवाब मिलने पर, Handler() फ़ंक्शन को स्ट्रक्चर्ड लॉग लिखने के लिए इंस्ट्रूमेंट किया जाता है. लॉग में, अनुरोध के जानवर पैरामीटर के साथ-साथ मॉडल के प्रॉम्प्ट और जवाब को कैप्चर किया जाता है.

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

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

  1. टर्मिनल विंडो में, ऐप्लिकेशन के सोर्स कोड को 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
    
  2. Cloud Run सेवा का दिख रहा यूआरएल, अपने ब्राउज़र के किसी अलग टैब या विंडो में कॉपी करें. इसके अलावा, सेवा का यूआरएल प्रिंट करने के लिए, टर्मिनल में यह कमांड चलाएं. इसके बाद, यूआरएल खोलने के लिए Ctrl बटन को दबाकर दिखाए गए यूआरएल पर क्लिक करें:
    gcloud run services list \
         --format='value(URL)' \
         --filter='SERVICE:"codelab-o11y-service"'
    
    यूआरएल खोलने पर, आपको 500 गड़बड़ी का कोड या यह मैसेज दिख सकता है:
    Sorry, this is just a placeholder...
    
    इसका मतलब है कि सेवाएं डिप्लॉय नहीं हुईं. कुछ देर इंतज़ार करें और पेज को रीफ़्रेश करें. आखिर में, आपको कुत्तों के बारे में मज़ेदार बातें से शुरू होने वाला टेक्स्ट दिखेगा. इसमें कुत्तों के बारे में 10 मज़ेदार बातें होंगी.

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

  1. Cloud Console में लॉग एक्सप्लोरर पेज खोलने के लिए, नीचे दिए गए बटन पर क्लिक करें:

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

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

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

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

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

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

  1. Cloud Console में मेट्रिक एक्सप्लोरर पेज खोलने के लिए, नीचे दिए गए बटन पर क्लिक करें:

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

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

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

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

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

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

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

  1. अपने ब्राउज़र में, ‘Cloud Shell' विंडो (या टैब) पर वापस जाएं.
  2. टर्मिनल में, setup.go को फिर से खोलें:
    cloudshell edit ~/codelab-o11y/setup.go
    
  3. कोड को उस वर्शन से बदलें जो 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)
    }
    
  4. टर्मिनल पर वापस जाएं और go.mod फ़ाइल में Go मॉड्यूल की परिभाषाओं को अपडेट करने के लिए, यह कमांड चलाएं:
    go mod tidy
    
  5. टर्मिनल पर वापस जाएं और main.go को फिर से खोलें:
    cloudshell edit ~/codelab-o11y/main.go
    
  6. मौजूदा कोड को उस वर्शन से बदलें जो एचटीटीपी ट्रैकिंग को इंस्ट्रूमेंट करता है और परफ़ॉर्मेंस मेट्रिक को लिखता है. कोड बदलने के लिए, फ़ाइल का कॉन्टेंट मिटाएं. इसके बाद, नीचे दिया गया कोड कॉपी करके एडिटर में चिपकाएं:
    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 और मॉनिटरिंग में लिखे जा सकेंगे. यह इकट्ठा किए गए ट्रेस और मेट्रिक को Cloud Run एनवायरमेंट से जुड़े मेटाडेटा से पॉप्युलेट करने के लिए, अन्य कॉन्फ़िगरेशन भी करता है. Handler() फ़ंक्शन को अपडेट किया जाता है, ताकि हर बार Vertex AI एपीआई कॉल से मान्य नतीजे मिलने पर, मेट्रिक काउंटर बढ़ सके.

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

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

  1. टर्मिनल विंडो में, ऐप्लिकेशन के सोर्स कोड को 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
    
  2. Cloud Run सेवा का दिख रहा यूआरएल, अपने ब्राउज़र के किसी अलग टैब या विंडो में कॉपी करें. इसके अलावा, सेवा का यूआरएल प्रिंट करने के लिए, टर्मिनल में यह कमांड चलाएं. इसके बाद, यूआरएल खोलने के लिए Ctrl बटन को दबाकर दिखाए गए यूआरएल पर क्लिक करें:
    gcloud run services list \
         --format='value(URL)' \
         --filter='SERVICE:"codelab-o11y-service"'
    
    यूआरएल खोलने पर, आपको 500 गड़बड़ी का कोड या यह मैसेज दिख सकता है:
    Sorry, this is just a placeholder...
    
    इसका मतलब है कि सेवाएं डिप्लॉय नहीं हुईं. कुछ देर इंतज़ार करें और पेज को रीफ़्रेश करें. आखिर में, आपको कुत्तों के बारे में मज़ेदार बातें से शुरू होने वाला टेक्स्ट दिखेगा. इसमें कुत्तों के बारे में 10 मज़ेदार बातें होंगी.

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

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

  1. Cloud Console में ट्रेस एक्सप्लोरर पेज खोलने के लिए, नीचे दिए गए बटन पर क्लिक करें:

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

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

  1. Cloud Console में मेट्रिक एक्सप्लोरर पेज खोलने के लिए, नीचे दिए गए बटन पर क्लिक करें:

  2. क्वेरी बिल्डर पैनल के टूलबार में, वह बटन चुनें जिसका नाम < > MQL या < > PromQL है. बटन की जगह देखने के लिए, नीचे दी गई इमेज देखें.
    मेट्रिक एक्सप्लोरर में एमक्यूएल बटन की जगह
  3. पुष्टि करें कि भाषा टॉगल में PromQL चुना गया हो. भाषा टॉगल उसी टूलबार में होता है जिससे क्वेरी को फ़ॉर्मैट किया जा सकता है.
  4. क्वेरी एडिटर में अपनी क्वेरी डालें:
    sum(rate(workload_googleapis_com:model_call_counter{monitored_resource="generic_task"}[${__interval}]))
    
  5. क्वेरी चलाएं पर क्लिक करें.अपने-आप चलने की सुविधा टॉगल चालू होने पर, क्वेरी चलाएं बटन नहीं दिखता.

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

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

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

12. (ज़रूरी नहीं) खाता मिटाना

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

  1. प्रोजेक्ट मिटाने के लिए, टर्मिनल में 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.
    
  2. (ज़रूरी नहीं) अगर आपको कोई गड़बड़ी मिलती है, तो लैब के दौरान इस्तेमाल किया गया प्रोजेक्ट आईडी ढूंढने के लिए, पांचवें चरण का पालन करें. इसे पहले निर्देश में दिए गए निर्देश से बदलें. उदाहरण के लिए, अगर आपका प्रोजेक्ट आईडी lab-example-project है, तो कमांड यह होगा:
    gcloud projects delete lab-project-id-example --quiet
    

13. बधाई हो

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

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

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