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

1. ภาพรวม

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

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

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

  • เขียนแอปพลิเคชันที่ใช้ Vertex AI ด้วย Cloud Shell Editor
  • จัดเก็บโค้ดแอปพลิเคชันใน GitHub
  • ใช้ gcloud CLI เพื่อทำให้โค้ดต้นทางของแอปพลิเคชันใช้งานได้ใน Cloud Run
  • เพิ่มความสามารถในการตรวจสอบและการบันทึกลงในแอปพลิเคชัน Gen AI
  • การใช้เมตริกตามบันทึก
  • การใช้การบันทึกและการตรวจสอบด้วย Open Telemetry SDK
  • รับข้อมูลเชิงลึกเกี่ยวกับการจัดการข้อมูล AI อย่างมีความรับผิดชอบ

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

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

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

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

4. เตรียมเครื่องมือแก้ไข Cloud Shell

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

  1. สร้างไดเรกทอรี codelab-o11y ในเทอร์มินัลโดยทำดังนี้
    mkdir ~/codelab-o11y
  2. เปลี่ยนไดเรกทอรีปัจจุบันเป็น codelab-o11y
    cd ~/codelab-o11y
  3. เริ่มต้นโมดูล Go
    go mod init codelab
  4. ติดตั้ง Vertex AI SDK สําหรับ Go
    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. กลับไปที่หน้าต่างเทอร์มินัลแล้วเรียกใช้คำสั่งต่อไปนี้เพื่อสร้างและเปิดไฟล์ main.go ใน Cloud Shell Editor
    cloudshell edit main.go
    ตอนนี้ไฟล์ว่างควรปรากฏในหน้าต่างเครื่องมือแก้ไขเหนือเทอร์มินัล หน้าจอจะมีลักษณะคล้ายกับภาพต่อไปนี้
    แสดงเครื่องมือแก้ไข Cloud Shell หลังจากเริ่มแก้ไข main.go
  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)
    }
}
    หลังจากผ่านไป 2-3 วินาที เครื่องมือแก้ไข Cloud Shell จะบันทึกโค้ดโดยอัตโนมัติ

ทำให้โค้ดของแอปพลิเคชัน Gen AI ใช้งานได้ใน 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. คัดลอก 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

  1. คลิกปุ่มด้านล่างเพื่อเปิดหน้าบันทึกการตรวจสอบในคอนโซลระบบคลาวด์

  2. ตรวจสอบว่าหน้าเว็บมีโปรเจ็กต์ที่คุณสร้างสําหรับห้องทดลองนี้ โปรเจ็กต์ที่เลือกจะแสดงที่มุมซ้ายบนของหน้าจากเมนูแฮมเบอร์เกอร์
    เมนูแบบเลื่อนลงของโปรเจ็กต์ใน Google Cloud Console
    เลือกโปรเจ็กต์ที่ถูกต้องจากช่องทําการเลือกหากจําเป็น
  3. ในตารางการกําหนดค่าบันทึกการตรวจสอบการเข้าถึงข้อมูล ในคอลัมน์บริการ ให้ค้นหาบริการ Vertex AI API แล้วเลือกบริการโดยเลือกช่องทําเครื่องหมายทางด้านซ้ายจากชื่อบริการ
    เลือก Vertex AI API
  4. ในแผงข้อมูลทางด้านขวา ให้เลือกประเภทการตรวจสอบ "การอ่านข้อมูล"
    ตรวจสอบบันทึกการอ่านข้อมูล
  5. คลิกบันทึก

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

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

  1. คลิกปุ่มด้านล่างเพื่อเปิดหน้า Logs Explorer ในคอนโซลของ Cloud

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

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

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

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

ทำให้โค้ดของแอปพลิเคชัน Gen AI ใช้งานได้ใน 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. คัดลอก 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= เพื่อดูผลลัพธ์อื่น
หากต้องการดูบันทึกของแอปพลิเคชัน ให้ทำดังนี้

  1. คลิกปุ่มด้านล่างเพื่อเปิดหน้าเครื่องมือสำรวจบันทึกในคอนโซลระบบคลาวด์

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

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

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

Cloud Run จะเขียนเมตริกที่มีการจัดการซึ่งสามารถใช้เพื่อตรวจสอบบริการที่ติดตั้งใช้งาน เมตริกการตรวจสอบที่ผู้ใช้จัดการช่วยให้ควบคุมข้อมูลและความถี่ในการอัปเดตเมตริกได้มากขึ้น การใช้เมตริกดังกล่าวต้องเขียนโค้ดที่รวบรวมข้อมูลและเขียนลงใน Cloud Monitoring ดูขั้นตอนถัดไป (ไม่บังคับ) เพื่อดูวิธีติดตั้งใช้งานโดยใช้ 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 คําสั่ง CLI หรือgoogle_logging_metric ทรัพยากร Terraform

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

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

  1. คลิกปุ่มด้านล่างเพื่อเปิดหน้าเครื่องมือสํารวจเมตริกในคอนโซลระบบคลาวด์

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

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

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

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

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

สถาปัตยกรรมที่แนะนําสําหรับบริการระดับผลิตภัณฑ์คือการใช้เครื่องมือรวบรวมข้อมูล OTEL เพื่อรวบรวมและส่งผ่านข้อมูลการสังเกตการณ์ทั้งหมดสําหรับบริการอย่างน้อย 1 รายการ โค้ดในขั้นตอนนี้ไม่ได้ใช้เครื่องมือรวบรวมข้อมูลเพื่อความเรียบง่าย แต่จะใช้การส่งออก 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 ในไฟล์ go.mod
    go mod tidy
  5. กลับไปที่เทอร์มินัล แล้วเปิดmain.goอีกครั้ง
    cloudshell edit ~/codelab-o11y/main.go
  6. แทนที่โค้ดปัจจุบันด้วยเวอร์ชันที่ใช้เครื่องมือวัดการติดตาม 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 โดยตรง รวมถึงทำการกําหนดค่าเพิ่มเติมเพื่อป้อนข้อมูลเทรซและเมตริกที่รวบรวมพร้อมข้อมูลเมตาที่เกี่ยวข้องกับสภาพแวดล้อม Cloud Run ระบบจะอัปเดตฟังก์ชัน Handler() เพื่อเพิ่มตัวนับเมตริกทุกครั้งที่การเรียก Vertex AI API แสดงผลลัพธ์ที่ถูกต้อง

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

ทำให้โค้ดของแอปพลิเคชัน Gen AI ใช้งานได้ใน 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. คัดลอก 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= เพื่อดูผลลัพธ์อื่น

สำรวจร่องรอยแอปพลิเคชัน

  1. คลิกปุ่มด้านล่างเพื่อเปิดหน้าเครื่องมือสํารวจการติดตามในคอนโซลระบบคลาวด์

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

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

  1. คลิกปุ่มด้านล่างเพื่อเปิดหน้าเครื่องมือสํารวจเมตริกในคอนโซลระบบคลาวด์

  2. ในแถบเครื่องมือของแผงเครื่องมือสร้างคําค้นหา ให้เลือกปุ่มที่มีชื่อเป็น < > MQL หรือ < > PromQL ดูตำแหน่งของปุ่มในรูปภาพด้านล่าง
    ตําแหน่งปุ่ม MQL ในเครื่องมือสํารวจเมตริก
  3. ตรวจสอบว่าได้เลือก PromQL ในปุ่มสลับภาษา ปุ่มสลับภาษาอยู่ในแถบเครื่องมือเดียวกับที่ให้คุณจัดรูปแบบข้อความค้นหาได้
  4. ป้อนคําค้นหาลงในเครื่องมือแก้ไขคําค้นหา
    sum(rate(workload_googleapis_com:model_call_counter{monitored_resource="generic_task"}[${__interval}]))
  5. คลิกเรียกใช้การค้นหา เมื่อเปิดใช้ปุ่มสลับเรียกใช้อัตโนมัติ ปุ่มเรียกใช้การค้นหาจะไม่แสดง

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

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

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

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

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

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

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

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

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

ตัวเลือกในการเรียนต่อมีดังนี้