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

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. สร้างแอปพลิเคชัน Python ของ Gen AI

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

สร้างไดเรกทอรี codelab-o11y ในเทอร์มินัลโดยใช้คำสั่งต่อไปนี้
```
mkdir ~/codelab-o11y
```
เปลี่ยนไดเรกทอรีปัจจุบันเป็น codelab-o11y โดยทำดังนี้
```
cd ~/codelab-o11y
```

สร้าง requirements.txt โดยใช้รายการทรัพยากร Dependency ดังนี้

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

สร้างไฟล์ main.py แล้วเปิดไฟล์ใน Cloud Shell Editor โดยทำดังนี้
```
cloudshell edit main.py
```
ตอนนี้ควรมีไฟล์ว่างปรากฏในหน้าต่างโปรแกรมแก้ไขเหนือเทอร์มินัล หน้าจอของคุณจะมีลักษณะคล้ายกับภาพต่อไปนี้

คัดลอกโค้ดต่อไปนี้และวางลงในไฟล์ main.py ที่เปิดอยู่

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

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

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

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

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

logging ของ Python ไม่ทราบวิธีเขียนบันทึกลงใน Google Cloud โดยรองรับการเขียนไปยังเอาต์พุตมาตรฐาน (stderr โดยค่าเริ่มต้น) หรือไปยังไฟล์ อย่างไรก็ตาม Cloud Run มีฟีเจอร์ที่บันทึกข้อมูลที่พิมพ์ไปยังเอาต์พุตมาตรฐานและส่งไปยัง Cloud Logging โดยอัตโนมัติ ทําตามวิธีการด้านล่างเพื่อเพิ่มความสามารถในการบันทึกข้อมูลลงในแอปพลิเคชัน Gen AI ของเรา

กลับไปที่หน้าต่าง (หรือแท็บ) "Cloud Shell" ในเบราว์เซอร์
ในเทอร์มินัล ให้เปิด main.py อีกครั้งโดยทำดังนี้
```
cloudshell edit ~/codelab-o11y/main.py
```
ทำการแก้ไขโค้ดของแอปพลิเคชันดังนี้
1. ค้นหาสถานะการนำเข้าล่าสุด โดยควรเป็นบรรทัดที่ 5 ดังนี้
```
from vertexai.generative_models import GenerativeModel
```
  วางเคอร์เซอร์ในบรรทัดถัดไป (บรรทัดที่ 6) แล้ววางโค้ดบล็อกต่อไปนี้
```
import sys, json, logging
class JsonFormatter(logging.Formatter):
    def format(self, record):
        json_log_object = {
            'severity': record.levelname,
            'message': record.getMessage(),
        }
        json_log_object.update(getattr(record, 'json_fields', {}))
        return json.dumps(json_log_object)
logger = logging.getLogger(__name__)
sh = logging.StreamHandler(sys.stdout)
sh.setFormatter(JsonFormatter())
logger.addHandler(sh)
logger.setLevel(logging.DEBUG)
```
2. ค้นหารหัสที่เรียกโมเดลเพื่อสร้างเนื้อหา โดยควรเป็นบรรทัดที่ 30 ดังนี้
```
response = model.generate_content(prompt)
```
  วางเคอร์เซอร์ที่จุดเริ่มต้นของบรรทัดถัดไป (บรรทัดที่ 31) แล้ววางโค้ดบล็อกต่อไปนี้
```
    json_fields = {
         'animal': animal,
         'prompt': prompt,
         'response': response.to_dict(),
    }
    logger.debug('content is generated', extra={'json_fields': json_fields})
```
  หมายเหตุ: บล็อกโค้ดนี้มีการเยื้องเพื่อให้พอดีกับเมธอด fun_fact() หากมีข้อผิดพลาดในการเยื้อง Cloud Shell Editor จะแสดงเส้นโค้งสีแดงเพื่อทำเครื่องหมายพื้นที่ที่มีปัญหา ปรับการเยื้องด้วยตนเองตามไวยากรณ์ของ Python
การเปลี่ยนแปลงเหล่านี้จะกำหนดค่าการบันทึกมาตรฐานของ Python ให้ใช้ตัวจัดรูปแบบที่กำหนดเองเพื่อสร้าง JSON ที่แปลงเป็นสตริงซึ่งเป็นไปตามหลักเกณฑ์การจัดรูปแบบที่มีโครงสร้าง ระบบจะกำหนดค่าการบันทึกเพื่อพิมพ์บันทึกลงใน stdout ซึ่ง Agent การบันทึกของ Cloud Run จะรวบรวมและส่งไปยัง Cloud Logging แบบไม่พร้อมกัน โดยบันทึกจะบันทึกพารามิเตอร์สัตว์ของคำขอ รวมถึงพรอมต์และการตอบกลับของโมเดล หลังจากผ่านไป 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" ในเบราว์เซอร์

ในเทอร์มินัล ให้อัปเดต requirements.txt ด้วยรายการทรัพยากร Dependency เพิ่มเติมดังนี้

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

สร้างไฟล์ใหม่ setup_opentelemetry.py โดยทำดังนี้
```
cloudshell edit ~/codelab-o11y/setup_opentelemetry.py
```
ตอนนี้ควรมีไฟล์ว่างปรากฏในหน้าต่างโปรแกรมแก้ไขเหนือเทอร์มินัล

คัดลอกโค้ดต่อไปนี้และวางลงในไฟล์ setup_opentelemetry.py ที่เปิดอยู่

import os

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

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

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

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

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

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

ตรวจสอบโค้ดแอปพลิเคชันด้วยความสามารถในการติดตามและตรวจสอบโดยใช้ OTel

ในเทอร์มินัล ให้เปิด main.py อีกครั้งโดยทำดังนี้
```
cloudshell edit ~/codelab-o11y/main.py
```
แก้ไขโค้ดของแอปพลิเคชันดังนี้
1. ก่อนบรรทัด import os (บรรทัดที่ 1) ให้แทรกโค้ดต่อไปนี้ (โปรดสังเกตบรรทัดว่างที่ส่วนท้าย)
```
from setup_opentelemetry import google_trace_id_format
from opentelemetry import metrics, trace
from opentelemetry.instrumentation.requests import RequestsInstrumentor
from opentelemetry.instrumentation.flask import FlaskInstrumentor
```
2. หลังจากประกาศเมธอด format() (บรรทัดที่ 9) ให้แทรกโค้ดต่อไปนี้ (ดูการเยื้อง)
```
        span = trace.get_current_span()
```
3. หลังจากบรรทัดที่ 13 (มี "message": record.getMessage()) ให้แทรกโค้ดต่อไปนี้ (โปรดดูการเยื้อง)
```
            "logging.googleapis.com/trace": google_trace_id_format(span.get_span_context().trace_id),
            "logging.googleapis.com/spanId": trace.format_span_id(span.get_span_context().span_id),
```
  แอตทริบิวต์เพิ่มเติม 2 รายการนี้ช่วยเชื่อมโยงบันทึกของแอปพลิเคชันและช่วงการติดตาม OTel
4. หลังจากบรรทัด app = Flask(__name__) (บรรทัดที่ 31) ให้แทรกโค้ดต่อไปนี้
```
FlaskInstrumentor().instrument_app(app)
RequestsInstrumentor().instrument()
```
  บรรทัดเหล่านี้จะใช้เครื่องมือกับคำขอขาเข้าและขาออกทั้งหมดของแอปพลิเคชัน Flask ด้วยการติดตาม
5. หลังจากโค้ดที่เพิ่มใหม่ (หลังบรรทัดที่ 33) ให้เพิ่มโค้ดต่อไปนี้
```
meter = metrics.get_meter(__name__)
requests_counter = meter.create_counter(
    name="model_call_counter",
    description="number of model invocations",
    unit="1"
)
```
  บรรทัดเหล่านี้จะสร้างเมตริกใหม่ประเภทตัวนับที่มีชื่อ model_call_counter และลงทะเบียนเพื่อส่งออก
6. หลังจากการเรียกใช้ logger.debug() (บรรทัดที่ 49) ให้แทรกโค้ดต่อไปนี้
```
    requests_counter.add(1, {'animal': animal})
```
  การเปลี่ยนแปลงนี้จะเพิ่มตัวนับขึ้น 1 ทุกครั้งที่แอปพลิเคชันเรียกใช้ Vertex API เพื่อโต้ตอบกับโมเดล Gemini ได้สำเร็จ

ติดตั้งใช้งานโค้ดของแอปพลิเคชัน 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