เทคนิคการสังเกตการณ์ที่ใช้งานได้จริงสําหรับแอปพลิเคชัน Generative AI ใน Go

1. ภาพรวม

แอปพลิเคชัน Gen AI ต้องมีการสังเกตการณ์เช่นเดียวกับแอปพลิเคชันอื่นๆ Generative AI ต้องใช้เทคนิคการสังเกตการณ์พิเศษไหม

ในแล็บนี้ คุณจะได้สร้างแอปพลิเคชัน Gen AI อย่างง่าย ทำให้ใช้งานได้กับ Cloud Run และติดตั้งเครื่องมือด้วยความสามารถในการตรวจสอบและการบันทึกที่จำเป็นโดยใช้บริการและผลิตภัณฑ์การสังเกตการณ์ของ Google Cloud

สิ่งที่คุณจะได้เรียนรู้

เขียนแอปพลิเคชันที่ใช้ Vertex AI ด้วย Cloud Shell Editor
จัดเก็บโค้ดแอปพลิเคชันใน GitHub
ใช้ gcloud CLI เพื่อทำให้ซอร์สโค้ดของแอปพลิเคชันใช้งานได้กับ Cloud Run

เพิ่มความสามารถในการตรวจสอบและการบันทึกลงในแอปพลิเคชัน Gen AI
การใช้เมตริกตามบันทึก
การติดตั้งใช้งานการบันทึกและการตรวจสอบด้วย Open Telemetry SDK
รับข้อมูลเชิงลึกเกี่ยวกับการจัดการข้อมูล AI ที่มีความรับผิดชอบ

2. ข้อกำหนดเบื้องต้น

หากยังไม่มีบัญชี Google คุณจะต้องสร้างบัญชีใหม่

3. การตั้งค่าโปรเจ็กต์

ลงชื่อเข้าใช้ Google Cloud Console ด้วยบัญชี Google
สร้างโปรเจ็กต์ใหม่หรือเลือกใช้โปรเจ็กต์ที่มีอยู่ซ้ำ จดรหัสโปรเจ็กต์ของโปรเจ็กต์ที่คุณเพิ่งสร้างหรือเลือก
เปิดใช้การเรียกเก็บเงินสำหรับโปรเจ็กต์
- การทำแล็บนี้ควรมีค่าใช้จ่ายในการเรียกเก็บเงินน้อยกว่า $5
- คุณสามารถทำตามขั้นตอนที่ส่วนท้ายของแล็บนี้เพื่อลบทรัพยากรเพื่อหลีกเลี่ยงการเรียกเก็บเงินเพิ่มเติม
- ผู้ใช้ใหม่มีสิทธิ์ใช้ช่วงทดลองใช้ฟรีมูลค่า$300 USD
ยืนยันว่าได้เปิดใช้การเรียกเก็บเงินในโปรเจ็กต์ของฉันในการเรียกเก็บเงินใน Cloud
- หากโปรเจ็กต์ใหม่แสดง Billing is disabled ในคอลัมน์ Billing account ให้ทำดังนี้
  1. คลิกจุด 3 จุดในActionsคอลัมน์
  2. คลิกเปลี่ยนการเรียกเก็บเงิน
  3. เลือกบัญชีสำหรับการเรียกเก็บเงินที่ต้องการใช้
- หากคุณเข้าร่วมกิจกรรมแบบสด บัญชีดังกล่าวอาจมีชื่อว่าบัญชีสำหรับการเรียกเก็บเงินของ Google Cloud Platform เวอร์ชันทดลองใช้งาน

4. เตรียม Cloud Shell Editor

ไปที่ Cloud Shell Editor หากได้รับข้อความต่อไปนี้ซึ่งขอให้ให้สิทธิ์ Cloud Shell ในการเรียก gcloud ด้วยข้อมูลเข้าสู่ระบบของคุณ ให้คลิกให้สิทธิ์เพื่อดำเนินการต่อ
เปิดหน้าต่างเทอร์มินัล
1. คลิกเมนู 3 ขีด
2. คลิก Terminal
3. คลิก Terminal ใหม่
กำหนดค่ารหัสโปรเจ็กต์ในเทอร์มินัลโดยทำดังนี้
```
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 APIs

ในเทอร์มินัล ให้เปิดใช้ 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 และมีรายละเอียดข้อผิดพลาดดังที่แสดงด้านล่าง ให้ลองใช้คำสั่งอีกครั้งหลังจากผ่านไป 1-2 นาที

"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

ในขั้นตอนนี้ คุณจะเขียนโค้ดของแอปพลิเคชันแบบง่ายที่อิงตามคำขอซึ่งใช้โมเดล Gemini เพื่อแสดงข้อเท็จจริงที่น่าสนใจ 10 ข้อเกี่ยวกับสัตว์ที่คุณเลือก ทำตามขั้นตอนต่อไปนี้เพื่อสร้างรหัสแอปพลิเคชัน

สร้างไดเรกทอรี codelab-o11y ในเทอร์มินัลโดยใช้คำสั่งต่อไปนี้
```
mkdir ~/codelab-o11y
```
เปลี่ยนไดเรกทอรีปัจจุบันเป็น codelab-o11y โดยทำดังนี้
```
cd ~/codelab-o11y
```
เริ่มต้นโมดูล Go
```
go mod init codelab
```
ติดตั้ง Vertex AI SDK สำหรับ Go โดยทำดังนี้
```
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
}

กลับไปที่หน้าต่างเทอร์มินัล แล้วเรียกใช้คำสั่งต่อไปนี้เพื่อสร้างและเปิดไฟล์ main.go ใน Cloud Shell Editor
```
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)
    }
}

หลังจากผ่านไป 2-3 วินาที Cloud Shell Editor จะบันทึกโค้ดโดยอัตโนมัติ

ติดตั้งใช้งานโค้ดของแอปพลิเคชัน Gen AI ไปยัง 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
```
คัดลอก URL ของบริการ Cloud Run ที่แสดงไปยังแท็บหรือหน้าต่างแยกต่างหากในเบราว์เซอร์ หรือเรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัลเพื่อพิมพ์ URL ของบริการ แล้วคลิก URL ที่แสดงขณะกดปุ่ม Ctrl ค้างไว้เพื่อเปิด URL
```
gcloud run services list \
     --format='value(URL)' \
     --filter='SERVICE:"codelab-o11y-service"'
```
เมื่อเปิด URL คุณอาจได้รับข้อผิดพลาด 500 หรือเห็นข้อความต่อไปนี้
```
Sorry, this is just a placeholder...
```
ซึ่งหมายความว่าบริการยังติดตั้งใช้งานไม่เสร็จ รอสักครู่แล้วรีเฟรชหน้าเว็บ ที่ท้ายข้อความ คุณจะเห็นข้อความที่ขึ้นต้นด้วยเรื่องน่ารู้เกี่ยวกับสุนัขและมีเรื่องน่ารู้เกี่ยวกับสุนัข 10 เรื่อง

ลองโต้ตอบกับแอปพลิเคชันเพื่อดูข้อเท็จจริงที่น่าสนใจเกี่ยวกับสัตว์ต่างๆ โดยให้ผนวกพารามิเตอร์ animal เข้ากับ URL เช่น ?animal=[ANIMAL] โดยที่ [ANIMAL] คือชื่อสัตว์ เช่น เพิ่ม ?animal=cat เพื่อดูสาระน่ารู้ 10 ข้อเกี่ยวกับแมว หรือ ?animal=sea turtle เพื่อดูสาระน่ารู้ 10 ข้อเกี่ยวกับเต่าทะเล

7. ตรวจสอบการเรียกใช้ Vertex API

การตรวจสอบการเรียก Google API จะให้คำตอบสำหรับคำถามต่างๆ เช่น "ใครเรียก API ใด ที่ไหน และเมื่อใด" การตรวจสอบมีความสำคัญเมื่อคุณแก้ปัญหาแอปพลิเคชัน ตรวจสอบการใช้ทรัพยากร หรือทำการวิเคราะห์ทางนิติเวชของซอฟต์แวร์

บันทึกการตรวจสอบช่วยให้คุณติดตามกิจกรรมของผู้ดูแลระบบและกิจกรรมของระบบ รวมถึงบันทึกการเรียกใช้การดำเนินการ API "อ่านข้อมูล" และ "เขียนข้อมูล" หากต้องการตรวจสอบคำขอ Vertex AI เพื่อสร้างเนื้อหา คุณต้องเปิดใช้บันทึกการตรวจสอบ "การอ่านข้อมูล" ใน Cloud Console

คลิกปุ่มด้านล่างเพื่อเปิดหน้าบันทึกการตรวจสอบใน Cloud Console
ตรวจสอบว่าหน้าเว็บมีโปรเจ็กต์ที่คุณสร้างขึ้นสำหรับแล็บนี้เลือกอยู่ โปรเจ็กต์ที่เลือกจะแสดงที่มุมซ้ายบนของหน้าเว็บทางด้านขวาของเมนูแฮมเบอร์เกอร์

หากจำเป็น ให้เลือกโปรเจ็กต์ที่ถูกต้องจากช่องคำสั่งแบบเลื่อนลง
ในตารางการกำหนดค่าบันทึกการตรวจสอบการเข้าถึงข้อมูล ในคอลัมน์บริการ ให้ค้นหาบริการ Vertex AI API แล้วเลือกบริการโดยเลือกช่องทําเครื่องหมายที่อยู่ทางด้านซ้ายของชื่อบริการ
ในแผงข้อมูลทางด้านขวา ให้เลือกประเภทการตรวจสอบ "อ่านข้อมูล"
คลิกบันทึก

หากต้องการสร้างบันทึกการตรวจสอบ ให้เปิด URL ของบริการ รีเฟรชหน้าเว็บขณะเปลี่ยนค่าของพารามิเตอร์ ?animal= เพื่อดูผลลัพธ์ที่แตกต่างกัน

สำรวจบันทึกการตรวจสอบ

คลิกปุ่มด้านล่างเพื่อเปิดหน้า Logs Explorer ในคอนโซลระบบคลาวด์
วางตัวกรองต่อไปนี้ลงในแผงคำค้นหา
```
LOG_ID("cloudaudit.googleapis.com%2Fdata_access") AND
protoPayload.serviceName="aiplatform.googleapis.com"
```
แผงคำค้นหาคือเครื่องมือแก้ไขที่อยู่ใกล้ด้านบนของหน้า Logs Explorer
คลิกเรียกใช้การค้นหา
เลือกรายการบันทึกการตรวจสอบรายการใดรายการหนึ่ง แล้วขยายช่องเพื่อตรวจสอบข้อมูลที่บันทึกไว้ในบันทึก
คุณดูรายละเอียดเกี่ยวกับการเรียก Vertex API ได้ รวมถึงเมธอดและโมเดลที่ใช้ นอกจากนี้ คุณยังดูตัวตนของผู้เรียกใช้และสิทธิ์ที่อนุญาตให้โทรได้ด้วย

8. บันทึกการโต้ตอบกับ Gen AI

คุณไม่พบพารามิเตอร์คำขอ API หรือข้อมูลการตอบกลับในบันทึกการตรวจสอบ อย่างไรก็ตาม ข้อมูลนี้อาจมีความสำคัญต่อการแก้ปัญหาแอปพลิเคชันและการวิเคราะห์เวิร์กโฟลว์ ในขั้นตอนนี้ เราจะเติมเต็มช่องว่างนี้ด้วยการเพิ่มการบันทึกแอปพลิเคชัน การบันทึกใช้แพ็กเกจ 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 ซึ่ง Agent การบันทึกของ Cloud Run จะรวบรวมและส่งไปยัง Cloud Logging แบบไม่พร้อมกัน ฟังก์ชัน main() ได้รับการแก้ไขเพื่อตั้งค่าบันทึกที่มีโครงสร้างมาตรฐานของ Go ให้ใช้สคีมา JSON ตามหลักเกณฑ์การจัดรูปแบบที่มีโครงสร้าง return ทั้งหมดจะถูกแทนที่ด้วยโค้ดที่เขียนบันทึกข้อผิดพลาดก่อนที่จะออก ระบบจะวัด Handler() ฟังก์ชันเพื่อเขียนบันทึกที่มีโครงสร้างเมื่อได้รับการตอบกลับจากการเรียกใช้ Vertex AI API บันทึกจะบันทึกพารามิเตอร์สัตว์ของคำขอ รวมถึงพรอมต์และคำตอบของโมเดล

หลังจากผ่านไป 2-3 วินาที Cloud Shell Editor จะบันทึกการเปลี่ยนแปลงโดยอัตโนมัติ

ติดตั้งใช้งานโค้ดของแอปพลิเคชัน Gen AI ไปยัง 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
```
คัดลอก URL ของบริการ Cloud Run ที่แสดงไปยังแท็บหรือหน้าต่างแยกต่างหากในเบราว์เซอร์ หรือเรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัลเพื่อพิมพ์ URL ของบริการ แล้วคลิก URL ที่แสดงขณะกดปุ่ม Ctrl ค้างไว้เพื่อเปิด URL
```
gcloud run services list \
     --format='value(URL)' \
     --filter='SERVICE:"codelab-o11y-service"'
```
เมื่อเปิด URL คุณอาจได้รับข้อผิดพลาด 500 หรือเห็นข้อความต่อไปนี้
```
Sorry, this is just a placeholder...
```
ซึ่งหมายความว่าบริการยังติดตั้งใช้งานไม่เสร็จ รอสักครู่แล้วรีเฟรชหน้าเว็บ ที่ท้ายข้อความ คุณจะเห็นข้อความที่ขึ้นต้นด้วยเรื่องน่ารู้เกี่ยวกับสุนัขและมีเรื่องน่ารู้เกี่ยวกับสุนัข 10 เรื่อง

หากต้องการสร้างบันทึกของแอปพลิเคชัน ให้เปิด URL ของบริการ รีเฟรชหน้าเว็บขณะเปลี่ยนค่าของพารามิเตอร์ ?animal= เพื่อดูผลลัพธ์ที่แตกต่างกัน
หากต้องการดูบันทึกของแอปพลิเคชัน ให้ทำดังนี้

คลิกปุ่มด้านล่างเพื่อเปิดหน้า Logs Explorer ใน Cloud Console
วางตัวกรองต่อไปนี้ลงในแผงคำค้นหา (#2 ในอินเทอร์เฟซของเครื่องมือสำรวจบันทึก)
```
LOG_ID("run.googleapis.com%2Fstdout") AND
severity=DEBUG
```
คลิกเรียกใช้การค้นหา

ผลลัพธ์ของคำค้นหาจะแสดงบันทึกพร้อมพรอมต์และการตอบกลับของ Vertex AI รวมถึงคะแนนความปลอดภัย

9. นับการโต้ตอบกับ Gen AI

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 คำสั่ง CLI หรือใช้google_logging_metric แหล่งข้อมูล Terraform

หากต้องการสร้างข้อมูลเมตริก ให้เปิด URL ของบริการ รีเฟรชหน้าที่เปิดอยู่หลายๆ ครั้งเพื่อเรียกใช้โมเดลหลายครั้ง เช่นเดียวกับก่อนหน้านี้ ให้ลองใช้สัตว์ที่แตกต่างกันในพารามิเตอร์

ป้อนการค้นหา PromQL เพื่อค้นหาข้อมูลเมตริกตามบันทึก หากต้องการป้อนการค้นหา PromQL ให้ทำดังนี้

คลิกปุ่มด้านล่างเพื่อเปิดหน้าเครื่องมือสำรวจเมตริกใน Cloud Console
ในแถบเครื่องมือของแผงเครื่องมือสร้างคำค้นหา ให้เลือกปุ่มที่มีชื่อเป็น < > MQL หรือ < > PromQL ดูตำแหน่งของปุ่มได้ที่รูปภาพด้านล่าง
ตรวจสอบว่าได้เลือก PromQL ในปุ่มเปิด/ปิดภาษา ปุ่มสลับภาษาจะอยู่ในแถบเครื่องมือเดียวกันกับที่ให้คุณจัดรูปแบบคำค้นหา
ป้อนคำค้นหาลงในตัวแก้ไขคำค้นหา
```
sum(rate(logging_googleapis_com:user_model_interaction_count{monitored_resource="cloud_run_revision"}[${__interval}]))
```
ดูข้อมูลเพิ่มเติมเกี่ยวกับการใช้ PromQL ได้ที่ PromQL ใน Cloud Monitoring
คลิกเรียกใช้การค้นหา คุณจะเห็นแผนภูมิเส้นที่คล้ายกับภาพหน้าจอนี้

โปรดทราบว่าเมื่อเปิดใช้ปุ่มเปิด/ปิดเรียกใช้โดยอัตโนมัติ ระบบจะไม่แสดงปุ่มเรียกใช้คําค้นหา

10. (ไม่บังคับ) ใช้ Open Telemetry เพื่อการตรวจสอบและการติดตาม

ดังที่ได้กล่าวไว้ในขั้นตอนก่อนหน้า คุณสามารถใช้เมตริกโดยใช้ OpenTelemetry (Otel) SDK ได้ การใช้ OTel ในสถาปัตยกรรม Microservice เป็นแนวทางปฏิบัติที่แนะนํา ขั้นตอนนี้จะอธิบายสิ่งต่อไปนี้

การเริ่มต้นคอมโพเนนต์ OTel เพื่อรองรับการติดตามและการตรวจสอบแอปพลิเคชัน
การป้อนข้อมูลการกำหนดค่า OTel ด้วยข้อมูลเมตาของทรัพยากรสภาพแวดล้อม Cloud Run
การวัดคุมแอปพลิเคชัน Flask ด้วยความสามารถในการติดตามอัตโนมัติ
การใช้เมตริกตัวนับเพื่อตรวจสอบจำนวนการเรียกโมเดลที่สำเร็จ
เชื่อมโยงการติดตามกับบันทึกของแอปพลิเคชัน

สถาปัตยกรรมที่แนะนำสำหรับบริการระดับผลิตภัณฑ์คือการใช้ OTel Collector เพื่อรวบรวมและนำเข้าข้อมูลการตรวจสอบทั้งหมดสำหรับบริการอย่างน้อย 1 รายการ โค้ดในขั้นตอนนี้ไม่ได้ใช้ตัวรวบรวมเพื่อความเรียบง่าย แต่จะใช้การส่งออก 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 ในไฟล์ go.mod
```
go mod tidy
```
กลับไปที่เทอร์มินัล แล้วเปิด main.go อีกครั้ง
```
cloudshell edit ~/codelab-o11y/main.go
```

แทนที่โค้ดปัจจุบันด้วยเวอร์ชันที่ใช้การติดตาม HTTP และเขียนเมตริกประสิทธิภาพ หากต้องการแทนที่โค้ด ให้ลบเนื้อหาของไฟล์ จากนั้นคัดลอกโค้ดด้านล่างแล้ววางลงในโปรแกรมแก้ไข

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 Trace และ Monitoring โดยตรง นอกจากนี้ยังทำการกำหนดค่าเพิ่มเติมเพื่อป้อนข้อมูลการติดตามและเมตริกที่รวบรวมด้วยข้อมูลเมตาที่เกี่ยวข้องกับสภาพแวดล้อม Cloud Run ระบบจะอัปเดตฟังก์ชัน Handler() เพื่อเพิ่มตัวนับเมตริกทุกครั้งที่การเรียก Vertex AI API แสดงผลลัพธ์ที่ถูกต้อง

หลังจากผ่านไป 2-3 วินาที Cloud Shell Editor จะบันทึกการเปลี่ยนแปลงโดยอัตโนมัติ

ติดตั้งใช้งานโค้ดของแอปพลิเคชัน Gen AI ไปยัง 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
```
คัดลอก URL ของบริการ Cloud Run ที่แสดงไปยังแท็บหรือหน้าต่างแยกต่างหากในเบราว์เซอร์ หรือเรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัลเพื่อพิมพ์ URL ของบริการ แล้วคลิก URL ที่แสดงขณะกดปุ่ม Ctrl ค้างไว้เพื่อเปิด URL
```
gcloud run services list \
     --format='value(URL)' \
     --filter='SERVICE:"codelab-o11y-service"'
```
เมื่อเปิด URL คุณอาจได้รับข้อผิดพลาด 500 หรือเห็นข้อความต่อไปนี้
```
Sorry, this is just a placeholder...
```
ซึ่งหมายความว่าบริการยังติดตั้งใช้งานไม่เสร็จ รอสักครู่แล้วรีเฟรชหน้าเว็บ ที่ท้ายข้อความ คุณจะเห็นข้อความที่ขึ้นต้นด้วยเรื่องน่ารู้เกี่ยวกับสุนัขและมีเรื่องน่ารู้เกี่ยวกับสุนัข 10 เรื่อง

หากต้องการสร้างข้อมูลการวัดและส่งข้อมูล ให้เปิด URL ของบริการ รีเฟรชหน้าเว็บขณะเปลี่ยนค่าของพารามิเตอร์ ?animal= เพื่อดูผลลัพธ์ที่แตกต่างกัน

สำรวจการติดตามแอปพลิเคชัน

คลิกปุ่มด้านล่างเพื่อเปิดหน้า Trace Explorer ใน Cloud Console
เลือกการติดตามล่าสุดรายการใดรายการหนึ่ง คุณควรเห็น 5 หรือ 6 ช่วงที่มีลักษณะเหมือนในภาพหน้าจอด้านล่าง
ค้นหาระยะเวลาที่ติดตามการเรียกไปยังตัวแฮนเดิลเหตุการณ์ (เมธอด fun_facts) ซึ่งจะเป็นช่วงสุดท้ายที่มีชื่อว่า /
ในแผงรายละเอียดการติดตาม ให้เลือกบันทึกและเหตุการณ์ คุณจะเห็นบันทึกของแอปพลิเคชันที่สัมพันธ์กับช่วงเวลานี้ ระบบจะตรวจหาความสัมพันธ์โดยใช้รหัสการติดตามและรหัสช่วงในการติดตามและในบันทึก คุณควรเห็นบันทึกของแอปพลิเคชันที่เขียนพรอมต์และคำตอบของ Vertex API

สำรวจเมตริกตัวนับ

คลิกปุ่มด้านล่างเพื่อเปิดหน้าเครื่องมือสำรวจเมตริกใน Cloud Console
ในแถบเครื่องมือของแผงเครื่องมือสร้างคำค้นหา ให้เลือกปุ่มที่มีชื่อเป็น < > MQL หรือ < > PromQL ดูตำแหน่งของปุ่มได้ที่รูปภาพด้านล่าง
ตรวจสอบว่าได้เลือก PromQL ในปุ่มเปิด/ปิดภาษา ปุ่มสลับภาษาจะอยู่ในแถบเครื่องมือเดียวกันกับที่ให้คุณจัดรูปแบบคำค้นหา

ป้อนคำค้นหาลงในตัวแก้ไขคำค้นหา

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

คลิกเรียกใช้การค้นหา เมื่อเปิดใช้ปุ่มเปิด/ปิดเรียกใช้อัตโนมัติ ระบบจะไม่แสดงปุ่มเรียกใช้การค้นหา

11. (ไม่บังคับ) ข้อมูลที่ละเอียดอ่อนที่ผ่านการปกปิดจากบันทึก

ในขั้นตอนที่ 10 เราได้บันทึกข้อมูลเกี่ยวกับการโต้ตอบของแอปพลิเคชันกับโมเดล Gemini ข้อมูลนี้ประกอบด้วยชื่อสัตว์ พรอมต์จริง และคำตอบของโมเดล แม้ว่าการจัดเก็บข้อมูลนี้ในบันทึกจะปลอดภัย แต่ก็ไม่จำเป็นต้องเป็นเช่นนั้นในอีกหลายๆ สถานการณ์ พรอมต์อาจมีข้อมูลส่วนบุคคลหรือข้อมูลที่ละเอียดอ่อนอื่นๆ ที่ผู้ใช้ไม่ต้องการให้จัดเก็บ หากต้องการแก้ไขปัญหานี้ คุณสามารถปกปิดข้อมูลที่ละเอียดอ่อนที่เขียนไปยัง Cloud Logging ได้ เราขอแนะนำให้ใช้โซลูชันต่อไปนี้เพื่อลดการแก้ไขโค้ด

สร้างหัวข้อ PubSub เพื่อจัดเก็บรายการบันทึกที่เข้ามา
สร้างซิงก์บันทึกที่เปลี่ยนเส้นทางบันทึกที่ส่งไปยังหัวข้อ PubSub
สร้างไปป์ไลน์ Dataflow ที่แก้ไขบันทึกที่เปลี่ยนเส้นทางไปยังหัวข้อ PubSub โดยทำตามขั้นตอนต่อไปนี้
1. อ่านรายการบันทึกจากหัวข้อ PubSub
2. ตรวจสอบเพย์โหลดของรายการเพื่อหาข้อมูลที่ละเอียดอ่อนโดยใช้ DLP Inspection API
3. ปกปิดข้อมูลที่ละเอียดอ่อนในเพย์โหลดโดยใช้วิธีการปกปิดข้อมูลของ DLP วิธีใดวิธีหนึ่ง
4. เขียนรายการบันทึกที่ปิดบังไปยัง Cloud Logging
ทำให้ไปป์ไลน์ใช้งานได้

12. (ไม่บังคับ) ล้างข้อมูล

ขอแนะนำให้ล้างข้อมูลหลังจากทำแล็บเสร็จแล้วเพื่อหลีกเลี่ยงความเสี่ยงในการเรียกเก็บเงินสำหรับทรัพยากรและ API ที่ใช้ในโค้ดแล็บ วิธีที่ง่ายที่สุดในการยกเลิกการเรียกเก็บเงินคือการลบโปรเจ็กต์ที่คุณสร้างขึ้นสำหรับโค้ดแล็บ

ข้อควรระวัง: การลบโปรเจ็กต์จะส่งผลดังนี้

– ระบบจะลบทุกอย่างในโปรเจ็กต์ หากใช้โปรเจ็กต์ที่มีอยู่สำหรับงานในเอกสารนี้ เมื่อลบโปรเจ็กต์ ระบบจะลบงานอื่นๆ ที่คุณทำในโปรเจ็กต์ด้วย
– รหัสโปรเจ็กต์ที่กำหนดเองจะหายไป เมื่อสร้างโปรเจ็กต์นี้ คุณอาจสร้างรหัสโปรเจ็กต์ที่กำหนดเองซึ่งต้องการใช้ในอนาคต หากต้องการเก็บ URL ที่ใช้รหัสโปรเจ็กต์ เช่น URL ของ appspot.com ให้ลบทรัพยากรที่เลือกภายในโปรเจ็กต์แทนการลบทั้งโปรเจ็กต์

หากคุณวางแผนที่จะสำรวจแอปพลิเคชันที่สร้างขึ้น การนำโปรเจ็กต์กลับมาใช้ใหม่จะช่วยประหยัดเวลาและช่วยให้คุณไม่เกินขีดจำกัดโควต้าโปรเจ็กต์

หากต้องการลบโปรเจ็กต์ ให้เรียกใช้คำสั่งลบโปรเจ็กต์ในเทอร์มินัล
```
PROJECT_ID=$(gcloud config get-value project)
gcloud projects delete ${PROJECT_ID} --quiet
```
การลบโปรเจ็กต์ Cloud จะหยุดการเรียกเก็บเงินสำหรับทรัพยากรและ API ทั้งหมดที่ใช้ภายในโปรเจ็กต์นั้น คุณควรเห็นข้อความนี้โดยที่ 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.
```
(ไม่บังคับ) หากได้รับข้อผิดพลาด ให้ดูขั้นตอนที่ 5 เพื่อค้นหารหัสโปรเจ็กต์ที่คุณใช้ในระหว่างแล็บ แทนที่ด้วยคำสั่งในวิธีการแรก เช่น หากรหัสโปรเจ็กต์คือ lab-example-project คำสั่งจะเป็นดังนี้
```
gcloud projects delete lab-project-id-example --quiet
```

13. ขอแสดงความยินดี

ในแล็บนี้ คุณได้สร้างแอปพลิเคชัน Gen AI ที่ใช้โมเดล Gemini เพื่อทำการคาดการณ์ และติดตั้งเครื่องมือในแอปพลิเคชันด้วยความสามารถในการตรวจสอบและการบันทึกที่จำเป็น คุณได้ติดตั้งใช้งานแอปพลิเคชันและการเปลี่ยนแปลงจากซอร์สโค้ดไปยัง Cloud Run จากนั้นใช้ผลิตภัณฑ์ Google Cloud Observability เพื่อติดตามประสิทธิภาพของแอปพลิเคชัน เพื่อให้มั่นใจในความน่าเชื่อถือของแอปพลิเคชัน

หากสนใจเข้าร่วมการศึกษาวิจัยประสบการณ์ของผู้ใช้ (UX) เพื่อปรับปรุงผลิตภัณฑ์ที่คุณใช้ในวันนี้ โปรดลงทะเบียนที่นี่

ตัวเลือกบางส่วนสำหรับการเรียนรู้ต่อมีดังนี้

Codelab วิธีติดตั้งใช้งานแชทแอปที่ทำงานด้วย Gemini บน Cloud Run
Codelab วิธีใช้การเรียกใช้ฟังก์ชันของ Gemini กับ Cloud Run
วิธีใช้ Cloud Run Jobs Video Intelligence API เพื่อประมวลผลฉากวิดีโอทีละฉาก
เวิร์กช็อปแบบออนดีมานด์ Google Kubernetes Engine Onboard
ดูข้อมูลเพิ่มเติมเกี่ยวกับการกำหนดค่าเมตริกตัวนับและการกระจายโดยใช้บันทึกของแอปพลิเคชัน
เขียนเมตริก OTLP โดยใช้ OpenTelemetry Sidecar
ข้อมูลอ้างอิงสำหรับการใช้ Open Telemetry ใน Google Cloud

สร้างการติดตามและเมตริก OpenTelemetry ด้วย Go