1. บทนำ
Codelab นี้เป็นพิมพ์เขียวทางเทคนิคสำหรับผู้ปฏิบัติงานด้านข้อมูล โดยจะอธิบายแนวทางการกำกับดูแลข้อมูลแบบ "เน้นโค้ดเป็นอันดับแรก" ซึ่งแสดงให้เห็นวิธีฝังการจัดการคุณภาพและข้อมูลเมตาที่แข็งแกร่งลงในวงจรการพัฒนาโดยตรง แคตตาล็อกความรู้เป็นแกนหลักของเทคโนโลยี Data Fabric อัจฉริยะ ซึ่งช่วยให้องค์กรสามารถจัดการ ตรวจสอบ และควบคุมข้อมูลจากส่วนกลางทั่วทั้งระบบ ตั้งแต่ที่เก็บข้อมูลขนาดใหญ่ไปจนถึงคลังข้อมูล
Codelab นี้แสดงวิธีใช้ประโยชน์จากแคตตาล็อกความรู้ BigQuery และ Antigravity CLI เพื่อทำให้ข้อมูลที่ซับซ้อนแบนราบ สร้างโปรไฟล์ข้อมูลโดยใช้โปรแกรม สร้างคำแนะนำกฎคุณภาพของข้อมูลอัจฉริยะ และติดตั้งใช้งานการสแกนคุณภาพอัตโนมัติ เป้าหมายหลักคือการก้าวข้ามกระบวนการที่ต้องทำด้วยตนเองและขับเคลื่อนด้วย UI ซึ่งมีแนวโน้มที่จะเกิดข้อผิดพลาดและปรับขนาดได้ยาก และแทนที่ด้วยการสร้างเฟรมเวิร์ก "นโยบายเป็นโค้ด" ที่แข็งแกร่งและควบคุมเวอร์ชันได้
สิ่งที่คุณจะได้เรียนรู้
- วิธีแปลงข้อมูล BigQuery ที่ซ้อนกันให้เป็นรูปแบบแบนโดยใช้มุมมองที่เป็นรูปธรรมเพื่อเปิดใช้การจัดทำโปรไฟล์ที่ครอบคลุม
- วิธีเรียกใช้และจัดการการสแกนโปรไฟล์แคตตาล็อกความรู้โดยอัตโนมัติโดยใช้ไลบรารีของไคลเอ็นต์ Python สำหรับแคตตาล็อกความรู้
- วิธีส่งออกข้อมูลโปรไฟล์และจัดโครงสร้างเป็นอินพุตสำหรับโมเดล Generative AI
- วิธีออกแบบพรอมต์สำหรับ Antigravity CLI เพื่อวิเคราะห์ข้อมูลโปรไฟล์และสร้างไฟล์กฎ YAML ที่เป็นไปตามข้อกำหนดของแคตตาล็อกความรู้
- ความสำคัญของกระบวนการแบบอินเทอร์แอกทีฟที่มีการกำกับดูแลโดยมนุษย์ (HITL) ในการตรวจสอบการกำหนดค่าที่ AI สร้างขึ้น
- วิธีใช้กฎที่สร้างขึ้นเป็นการสแกนคุณภาพของข้อมูลอัตโนมัติ
สิ่งที่คุณต้องมี
- บัญชี Google Cloud และโปรเจ็กต์ Google Cloud
- เว็บเบราว์เซอร์ เช่น Chrome
แนวคิดหลัก: เสาหลักของคุณภาพข้อมูลแคตตาล็อกความรู้
การทําความเข้าใจองค์ประกอบหลักของแคตตาล็อกความรู้เป็นสิ่งจําเป็นในการสร้างกลยุทธ์คุณภาพของข้อมูลที่มีประสิทธิภาพ
- การสแกนโปรไฟล์ข้อมูล: งานแคตตาล็อกความรู้ที่วิเคราะห์ข้อมูลและสร้างข้อมูลเมตาทางสถิติ รวมถึงเปอร์เซ็นต์ค่า Null จำนวนค่าที่ไม่ซ้ำกัน และการกระจายค่า ซึ่งถือเป็นระยะ "การค้นพบ" แบบเป็นโปรแกรมของเรา
- กฎคุณภาพของข้อมูล: ข้อความประกาศที่กําหนดเงื่อนไขที่ข้อมูลต้องเป็นไปตาม (เช่น
NonNullExpectation,SetExpectation,RangeExpectation) - Generative AI สำหรับคำแนะนำกฎ: ใช้โมเดลภาษาขนาดใหญ่ (เช่น Gemini) เพื่อวิเคราะห์โปรไฟล์ข้อมูลและแนะนำกฎคุณภาพของข้อมูลที่เกี่ยวข้อง ซึ่งจะช่วยเร่งกระบวนการกำหนดกรอบคุณภาพพื้นฐาน
- การสแกนคุณภาพของข้อมูล: งานในแคตตาล็อกความรู้ที่ตรวจสอบข้อมูลกับชุดกฎที่กำหนดไว้ล่วงหน้าหรือกฎที่กำหนดเอง
- การกำกับดูแลแบบเป็นโปรแกรม: ธีมหลักของการจัดการการควบคุมการกำกับดูแล (เช่น กฎคุณภาพ) เป็นโค้ด (เช่น ในไฟล์ YAML และสคริปต์ Python) ซึ่งจะช่วยให้สามารถทำงานอัตโนมัติ จัดเวอร์ชัน และผสานรวมเข้ากับไปป์ไลน์ CI/CD
- Human-in-the-Loop (HITL): จุดควบคุมที่สำคัญของการผสานรวมความเชี่ยวชาญและการกำกับดูแลของมนุษย์เข้ากับเวิร์กโฟลว์อัตโนมัติ สำหรับการกำหนดค่าที่ AI สร้างขึ้น HITL มีความสำคัญอย่างยิ่งในการตรวจสอบความถูกต้อง ความเกี่ยวข้องทางธุรกิจ และความปลอดภัยของคำแนะนำก่อนการใช้งาน
2. การตั้งค่าและข้อกำหนด
เริ่มต้น Cloud Shell
แม้ว่าคุณจะใช้งาน Google Cloud จากระยะไกลในแล็ปท็อปได้ แต่ใน Codelab นี้คุณจะใช้ Google Cloud Shell ซึ่งเป็นสภาพแวดล้อมบรรทัดคำสั่งที่ทำงานในระบบคลาวด์
จาก คอนโซล Google Cloud ให้คลิกไอคอน Cloud Shell ในแถบเครื่องมือด้านขวาบน
การจัดสรรและเชื่อมต่อกับสภาพแวดล้อมจะใช้เวลาเพียงไม่กี่นาที เมื่อเสร็จแล้ว คุณควรเห็นข้อความคล้ายกับตัวอย่างต่อไปนี้
เครื่องเสมือนนี้มาพร้อมเครื่องมือพัฒนาซอฟต์แวร์ทั้งหมดที่คุณต้องการ โดยมีไดเรกทอรีหลักแบบถาวรขนาด 5 GB และทำงานบน Google Cloud ซึ่งช่วยเพิ่มประสิทธิภาพเครือข่ายและการตรวจสอบสิทธิ์ได้อย่างมาก คุณสามารถทำงานทั้งหมดใน Codelab นี้ได้ภายในเบราว์เซอร์ คุณไม่จำเป็นต้องติดตั้งอะไร
เปิดใช้ API ที่จำเป็นและกำหนดค่าสภาพแวดล้อม
ใน Cloud Shell ให้ตรวจสอบว่าได้ตั้งค่ารหัสโปรเจ็กต์แล้ว
export PROJECT_ID=$(gcloud config get-value project)
gcloud config set project $PROJECT_ID
export LOCATION="us-central1"
export BQ_LOCATION="us"
export DATASET_ID="kc_dq_codelab"
export TABLE_ID="ga4_transactions"
gcloud services enable dataplex.googleapis.com \
bigquery.googleapis.com \
serviceusage.googleapis.com \
aiplatform.googleapis.com
ในตัวอย่างนี้ เราใช้ us (หลายภูมิภาค) เป็นตำแหน่ง เนื่องจากข้อมูลตัวอย่างสาธารณะที่เราจะใช้ก็อยู่ใน us (หลายภูมิภาค) ด้วย BigQuery กำหนดให้ข้อมูลต้นทางและตารางปลายทางสำหรับการค้นหาต้องอยู่ในตำแหน่งเดียวกัน
สร้างชุดข้อมูล BigQuery เฉพาะ
สร้างชุดข้อมูล BigQuery ใหม่เพื่อจัดเก็บข้อมูลตัวอย่างและผลลัพธ์
bq --location=us mk --dataset $PROJECT_ID:$DATASET_ID
เตรียมข้อมูลตัวอย่าง
สำหรับ Codelab นี้ คุณจะใช้ชุดข้อมูลสาธารณะที่มีข้อมูลอีคอมเมิร์ซที่ถูกปรับให้ยากต่อการอ่าน (Obfuscate) จาก Google Merchandise Store เนื่องจากชุดข้อมูลสาธารณะเป็นแบบอ่านอย่างเดียว คุณจึงต้องสร้างสำเนาที่แก้ไขได้ในชุดข้อมูลของคุณเอง คำสั่ง bq ต่อไปนี้จะสร้างตารางใหม่ ga4_transactions ในชุดข้อมูล kc_dq_codelab โดยจะคัดลอกข้อมูลจากวันเดียว (2021-01-31) เพื่อให้การสแกนทำงานได้อย่างรวดเร็ว
bq query \
--use_legacy_sql=false \
--destination_table=$PROJECT_ID:$DATASET_ID.$TABLE_ID \
--replace=true \
'SELECT * FROM `bigquery-public-data.ga4_obfuscated_sample_ecommerce.events_20210131`'
ตั้งค่าไดเรกทอรีตัวอย่าง
หากต้องการเริ่มต้นใช้งาน คุณจะต้องโคลนที่เก็บ GitHub ที่มีโครงสร้างโฟลเดอร์และไฟล์สนับสนุนที่จำเป็นสำหรับ Codelab นี้
# Perform a shallow clone to get only the latest repository structure without the full history
git clone --depth 1 --filter=blob:none --sparse https://github.com/GoogleCloudPlatform/devrel-demos.git
cd devrel-demos
# Specify and download only the folder we need for this lab
git sparse-checkout set data-analytics/programmatic-dq
cd data-analytics/programmatic-dq
ตอนนี้ไดเรกทอรีนี้เป็นพื้นที่ทำงานที่ใช้งานอยู่ของคุณ ระบบจะสร้างไฟล์ต่อๆ ไปที่นี่
3. การค้นพบข้อมูลอัตโนมัติด้วยการจัดทำโปรไฟล์ Knowledge Catalog
การสร้างโปรไฟล์ข้อมูลแคตตาล็อกความรู้เป็นเครื่องมือที่มีประสิทธิภาพในการค้นหาข้อมูลทางสถิติเกี่ยวกับข้อมูลโดยอัตโนมัติ เช่น เปอร์เซ็นต์ค่า Null ความไม่ซ้ำกัน และการกระจายค่า กระบวนการนี้มีความสําคัญอย่างยิ่งต่อการทําความเข้าใจโครงสร้างและคุณภาพของข้อมูล อย่างไรก็ตาม ข้อจำกัดที่ทราบกันดีของการจัดทำโปรไฟล์แคตตาล็อกความรู้คือความสามารถในการตรวจสอบฟิลด์ที่ซ้อนกันหรือฟิลด์ที่ซ้ำกัน (เช่น ประเภท RECORD หรือ ARRAY) ภายในตารางได้ไม่เต็มที่ โดยจะระบุได้ว่าคอลัมน์เป็นประเภทที่ซับซ้อน แต่ไม่สามารถสร้างโปรไฟล์ฟิลด์แต่ละรายการภายในโครงสร้างที่ซ้อนกันนั้นได้
เราจึงจะแปลงข้อมูลเป็นมุมมองที่สร้างขึ้นโดยเฉพาะเพื่อแก้ปัญหานี้ กลยุทธ์นี้จะทำให้ทุกฟิลด์เป็นคอลัมน์ระดับบนสุด ซึ่งช่วยให้แคตตาล็อกความรู้สามารถสร้างโปรไฟล์แต่ละฟิลด์แยกกันได้
ทำความเข้าใจสคีมาที่ซ้อนกัน
ก่อนอื่น มาดูสคีมาของตารางแหล่งข้อมูลกัน ชุดข้อมูล Google Analytics 4 (GA4) มีคอลัมน์ที่ซ้อนกันและคอลัมน์ที่ซ้ำกันหลายคอลัมน์ หากต้องการดึงข้อมูลสคีมาทั้งหมดแบบเป็นโปรแกรม รวมถึงโครงสร้างที่ซ้อนกันทั้งหมด คุณสามารถใช้คำสั่ง bq show และบันทึกเอาต์พุตเป็นไฟล์ JSON ได้
bq show --schema --format=json $PROJECT_ID:$DATASET_ID.$TABLE_ID > bq_schema.json
การตรวจสอบไฟล์ bq_schema.json จะแสดงโครงสร้างที่ซับซ้อน เช่น อุปกรณ์ ภูมิศาสตร์ อีคอมเมิร์ซ และรายการบันทึกที่ซ้ำกัน โครงสร้างเหล่านี้ต้องทำให้แบนราบเพื่อให้การสร้างโปรไฟล์มีประสิทธิภาพ
การทำให้ข้อมูลแบนราบด้วยมุมมองที่เป็นรูปธรรม
การสร้างมุมมองที่แสดงข้อมูลจริง (MV) เป็นโซลูชันที่มีประสิทธิภาพและใช้งานได้จริงมากที่สุดสำหรับความท้าทายด้านข้อมูลที่ซ้อนกันนี้ MV ช่วยให้ได้เปรียบอย่างมากในด้านประสิทธิภาพของคําค้นหาและต้นทุน ในขณะเดียวกันก็มีโครงสร้างที่เรียบง่ายและคล้ายกับโครงสร้างเชิงสัมพันธ์สําหรับนักวิเคราะห์และเครื่องมือสร้างโปรไฟล์ด้วยการคํานวณผลลัพธ์ที่เรียบง่ายล่วงหน้า
ความคิดแรกที่ผุดขึ้นมาในหัวอาจเป็นการรวมทุกอย่างไว้ในมุมมองเดียวขนาดใหญ่ อย่างไรก็ตาม วิธีการที่ใช้งานง่ายนี้ซ่อนกับดักอันตรายที่อาจทำให้ข้อมูลเสียหายอย่างรุนแรง มาดูเหตุผลที่การกระทำนี้เป็นความผิดพลาดร้ายแรงกัน
mv_ga4_user_session_flat.sql
CREATE OR REPLACE MATERIALIZED VIEW `$PROJECT_ID.$DATASET_ID.mv_ga4_user_session_flat`
OPTIONS (
enable_refresh = true,
refresh_interval_minutes = 30
) AS
SELECT
event_date, event_timestamp, event_name, user_pseudo_id, user_id, stream_id, platform,
device.category AS device_category,
device.operating_system AS device_os,
device.operating_system_version AS device_os_version,
device.language AS device_language,
device.web_info.browser AS device_browser,
geo.continent AS geo_continent,
geo.country AS geo_country,
geo.region AS geo_region,
geo.city AS geo_city,
traffic_source.name AS traffic_source_name,
traffic_source.medium AS traffic_source_medium,
traffic_source.source AS traffic_source_source
FROM
`$PROJECT_ID.$DATASET_ID.ga4_transactions`;
mv_ga4_ecommerce_transactions.sql
CREATE OR REPLACE MATERIALIZED VIEW `$PROJECT_ID.$DATASET_ID.mv_ga4_ecommerce_transactions`
OPTIONS (
enable_refresh = true,
refresh_interval_minutes = 30
) AS
SELECT
event_date, event_timestamp, user_pseudo_id, ecommerce.transaction_id,
ecommerce.total_item_quantity,
ecommerce.purchase_revenue_in_usd,
ecommerce.purchase_revenue,
ecommerce.refund_value_in_usd,
ecommerce.refund_value,
ecommerce.shipping_value_in_usd,
ecommerce.shipping_value,
ecommerce.tax_value_in_usd,
ecommerce.tax_value,
ecommerce.unique_items
FROM
`$PROJECT_ID.$DATASET_ID.ga4_transactions`
WHERE
ecommerce.transaction_id IS NOT NULL;
mv_ga4_ecommerce_items.sql
CREATE OR REPLACE MATERIALIZED VIEW `$PROJECT_ID.$DATASET_ID.mv_ga4_ecommerce_items`
OPTIONS (
enable_refresh = true,
refresh_interval_minutes = 30
) AS
SELECT
event_date, event_timestamp, event_name, user_pseudo_id, ecommerce.transaction_id,
item.item_id,
item.item_name,
item.item_brand,
item.item_variant,
item.item_category,
item.item_category2,
item.item_category3,
item.item_category4,
item.item_category5,
item.price_in_usd,
item.price,
item.quantity,
item.item_revenue_in_usd,
item.item_revenue,
item.coupon,
item.affiliation,
item.item_list_name,
item.promotion_name
FROM
`$PROJECT_ID.$DATASET_ID.ga4_transactions`,
UNNEST(items) AS item
WHERE
ecommerce.transaction_id IS NOT NULL;
ตอนนี้ให้เรียกใช้เทมเพลตเหล่านี้โดยใช้เครื่องมือบรรทัดคำสั่ง bq คำสั่ง envsubst จะอ่านแต่ละไฟล์ แทนที่ตัวแปร เช่น $PROJECT_ID และ $DATASET_ID ด้วยค่าจากสภาพแวดล้อมของ Shell และส่งต่อ SQL ที่ถูกต้องสุดท้ายไปยังคำสั่ง bq query
envsubst < mv_ga4_user_session_flat.sql | bq query --use_legacy_sql=false
envsubst < mv_ga4_ecommerce_transactions.sql | bq query --use_legacy_sql=false
envsubst < mv_ga4_ecommerce_items.sql | bq query --use_legacy_sql=false
เรียกใช้การสแกนโปรไฟล์ผ่านไคลเอ็นต์ Python
ตอนนี้เรามีมุมมองที่ปรับให้แบนราบและสร้างโปรไฟล์ได้แล้ว เราจึงสามารถสร้างและเรียกใช้การสแกนโปรไฟล์ข้อมูลแคตตาล็อกความรู้สำหรับแต่ละมุมมองได้โดยอัตโนมัติ สคริปต์ Python ต่อไปนี้ใช้ไลบรารีของไคลเอ็นต์ google-cloud-dataplex เพื่อทำให้กระบวนการนี้เป็นแบบอัตโนมัติ
ก่อนเรียกใช้สคริปต์ แนวทางปฏิบัติแนะนำที่สำคัญคือการสร้างสภาพแวดล้อม Python ที่แยกต่างหากภายในไดเรกทอรีโปรเจ็กต์ ซึ่งจะช่วยให้มั่นใจได้ว่าการจัดการทรัพยากร Dependency ของโปรเจ็กต์จะแยกกัน เพื่อป้องกันความขัดแย้งกับแพ็กเกจอื่นๆ ในสภาพแวดล้อมของ Shell ใน Cloud Shell
# Create the virtual environment
python3 -m venv dq_venv
# Activate the environment
source dq_venv/bin/activate
ตอนนี้ให้ติดตั้งไลบรารีของไคลเอ็นต์แคตตาล็อกความรู้ภายในสภาพแวดล้อมที่เพิ่งเปิดใช้งาน
# Install the Knowledge Catalog client library
pip install google-cloud-dataplex
เมื่อตั้งค่าสภาพแวดล้อมและติดตั้งไลบรารีแล้ว คุณก็พร้อมที่จะสร้างสคริปต์การจัดการเป็นกลุ่ม
คลิก "เปิดตัวแก้ไข" ในแถบเครื่องมือ Cloud Shell สร้างไฟล์ใหม่ชื่อ 1_run_scan.py แล้ววางโค้ด Python ต่อไปนี้ลงในไฟล์ หากโคลนที่เก็บ GitHub ไฟล์นี้จะอยู่ในโฟลเดอร์ของคุณอยู่แล้ว
สคริปต์นี้จะสร้างการสแกนสำหรับมุมมองที่เป็นรูปธรรมแต่ละรายการ (หากยังไม่มี) เรียกใช้การสแกน แล้วสำรวจจนกว่างานการสแกนทั้งหมดจะเสร็จสมบูรณ์
import os
import sys
import time
from google.cloud import dataplex_v1
from google.api_core.exceptions import AlreadyExists
def create_and_run_scan(
client: dataplex_v1.DataScanServiceClient,
project_id: str,
location: str,
data_scan_id: str,
target_resource: str,
) -> dataplex_v1.DataScanJob | None:
"""
Creates and runs a single data profile scan.
Returns the executed Job object without waiting for completion.
"""
parent = client.data_scan_path(project_id, location, data_scan_id).rsplit('/', 2)[0]
scan_path = client.data_scan_path(project_id, location, data_scan_id)
# 1. Create Data Scan (skips if it already exists)
try:
data_scan = dataplex_v1.DataScan()
data_scan.data.resource = target_resource
data_scan.data_profile_spec = dataplex_v1.DataProfileSpec()
print(f"[INFO] Creating data scan '{data_scan_id}'...")
client.create_data_scan(
parent=parent,
data_scan=data_scan,
data_scan_id=data_scan_id
).result() # Wait for creation to complete
print(f"[SUCCESS] Data scan '{data_scan_id}' created.")
except AlreadyExists:
print(f"[INFO] Data scan '{data_scan_id}' already exists. Skipping creation.")
except Exception as e:
print(f"[ERROR] Error creating data scan '{data_scan_id}': {e}")
return None
# 2. Run Data Scan
try:
print(f"[INFO] Running data scan '{data_scan_id}'...")
run_response = client.run_data_scan(name=scan_path)
print(f"[SUCCESS] Job started for '{data_scan_id}'. Job ID: {run_response.job.name.split('/')[-1]}")
return run_response.job
except Exception as e:
print(f"[ERROR] Error running data scan '{data_scan_id}': {e}")
return None
def main():
"""Main execution function"""
# --- Load configuration from environment variables ---
PROJECT_ID = os.environ.get("PROJECT_ID")
LOCATION = os.environ.get("LOCATION")
DATASET_ID = os.environ.get("DATASET_ID")
if not all([PROJECT_ID, LOCATION, DATASET_ID]):
print("[ERROR] One or more required environment variables are not set.")
print("Please ensure PROJECT_ID, LOCATION, and DATASET_ID are exported in your shell.")
sys.exit(1)
print(f"[INFO] Using Project: {PROJECT_ID}, Location: {LOCATION}, Dataset: {DATASET_ID}")
# List of Materialized Views to profile
TARGET_VIEWS = [
"mv_ga4_user_session_flat",
"mv_ga4_ecommerce_transactions",
"mv_ga4_ecommerce_items"
]
# ----------------------------------------------------
client = dataplex_v1.DataScanServiceClient()
running_jobs = []
# 1. Create and run jobs for all target views
print("\n--- Starting Data Profiling Job Creation and Execution ---")
for view_name in TARGET_VIEWS:
data_scan_id = f"profile-scan-{view_name.replace('_', '-')}"
target_resource = f"//bigquery.googleapis.com/projects/{PROJECT_ID}/datasets/{DATASET_ID}/tables/{view_name}"
job = create_and_run_scan(client, PROJECT_ID, LOCATION, data_scan_id, target_resource)
if job:
running_jobs.append(job)
print("-------------------------------------------------------\n")
if not running_jobs:
print("[ERROR] No jobs were started. Exiting.")
return
# 2. Poll for all jobs to complete
print("--- Monitoring job completion status (checking every 30 seconds) ---")
completed_jobs = {}
while running_jobs:
jobs_to_poll_next = []
print(f"\n[STATUS] Checking status for {len(running_jobs)} running jobs...")
for job in running_jobs:
job_id_short = job.name.split('/')[-1][:13]
try:
updated_job = client.get_data_scan_job(name=job.name)
state = updated_job.state
if state in (dataplex_v1.DataScanJob.State.RUNNING, dataplex_v1.DataScanJob.State.PENDING, dataplex_v1.DataScanJob.State.CANCELING):
print(f" - Job {job_id_short}... Status: {state.name}")
jobs_to_poll_next.append(updated_job)
else:
print(f" - Job {job_id_short}... Status: {state.name} (Complete)")
completed_jobs[job.name] = updated_job
except Exception as e:
print(f"[ERROR] Could not check status for job {job_id_short}: {e}")
running_jobs = jobs_to_poll_next
if running_jobs:
time.sleep(30)
# 3. Print final results
print("\n--------------------------------------------------")
print("[SUCCESS] All data profiling jobs have completed.")
print("\nFinal Job Status Summary:")
for job_name, job in completed_jobs.items():
job_id_short = job_name.split('/')[-1][:13]
print(f" - Job {job_id_short}: {job.state.name}")
if job.state == dataplex_v1.DataScanJob.State.FAILED:
print(f" - Failure Message: {job.message}")
print("\nNext step: Analyze the profile results and generate quality rules.")
if __name__ == "__main__":
main()
ตอนนี้ให้เรียกใช้สคริปต์จากเทอร์มินัล Cloud Shell
python 1_run_scan.py
ตอนนี้สคริปต์จะจัดระเบียบการสร้างโปรไฟล์ของมุมมองที่สร้างขึ้น 3 รายการ ซึ่งจะให้ข้อมูลอัปเดตสถานะแบบเรียลไทม์ เมื่อเสร็จสมบูรณ์แล้ว คุณจะมีโปรไฟล์สถิติที่สมบูรณ์และเครื่องอ่านได้สำหรับแต่ละมุมมอง ซึ่งพร้อมสำหรับขั้นตอนถัดไปของเวิร์กโฟลว์ นั่นคือการสร้างกฎคุณภาพของข้อมูลที่ทำงานด้วยระบบ AI
คุณดูการสแกนโปรไฟล์ที่เสร็จสมบูรณ์ได้ในคอนโซล Google Cloud
- ในเมนูการนำทาง ให้ไปที่แคตตาล็อกความรู้และการจัดทำโปรไฟล์และคุณภาพของข้อมูลในส่วนควบคุม
- คุณควรเห็นการสแกนโปรไฟล์ 3 รายการพร้อมสถานะงานล่าสุด คุณคลิกการสแกนเพื่อดูผลลัพธ์โดยละเอียดได้
จากโปรไฟล์ BigQuery ไปจนถึงอินพุตที่พร้อมใช้งาน AI
การสแกนโปรไฟล์แคตตาล็อกความรู้ทำงานสำเร็จแล้ว แม้ว่าผลลัพธ์จะพร้อมใช้งานใน Knowledge Catalog API แต่หากต้องการใช้เป็นอินพุตสำหรับโมเดล Generative AI เราจะต้องแยกผลลัพธ์เหล่านั้นลงในไฟล์ที่มีโครงสร้างในเครื่อง
สคริปต์ Python ต่อไปนี้ 2_dq_profile_save.py จะค้นหางานสแกนโปรไฟล์ที่สำเร็จล่าสุดสำหรับมุมมอง mv_ga4_user_session_flat โดยอัตโนมัติ จากนั้นจะดึงผลลัพธ์โปรไฟล์แบบละเอียดที่สมบูรณ์และบันทึกเป็นไฟล์ JSON ในเครื่องชื่อ dq_profile_results.json ไฟล์นี้จะเป็นอินพุตโดยตรงสำหรับการวิเคราะห์ AI ในขั้นตอนถัดไป
ในโปรแกรมแก้ไข Cloud Shell ให้สร้างไฟล์ใหม่ชื่อ 2_dq_profile_save.py แล้ววางโค้ดต่อไปนี้ลงไป เช่นเดียวกับขั้นตอนก่อนหน้า คุณสามารถข้ามการสร้างไฟล์ได้หากโคลนที่เก็บ
import os
import sys
import json
from google.cloud import dataplex_v1
from google.api_core.exceptions import NotFound
from google.protobuf.json_format import MessageToDict
# --- Configuration ---
# The Materialized View to analyze is fixed for this step.
TARGET_VIEW = "mv_ga4_user_session_flat"
OUTPUT_FILENAME = "dq_profile_results.json"
def save_to_json_file(content: dict, filename: str):
"""Saves the given dictionary content to a JSON file."""
try:
with open(filename, "w", encoding="utf-8") as f:
# Use indent=2 for a readable, "pretty-printed" JSON file.
json.dump(content, f, indent=2, ensure_ascii=False)
print(f"\n[SUCCESS] Profile results were saved to '{filename}'.")
except (IOError, TypeError) as e:
print(f"[ERROR] An error occurred while saving the file: {e}")
def get_latest_successful_job(
client: dataplex_v1.DataScanServiceClient,
project_id: str,
location: str,
data_scan_id: str
) -> dataplex_v1.DataScanJob | None:
"""Finds and returns the most recently succeeded job for a given data scan."""
scan_path = client.data_scan_path(project_id, location, data_scan_id)
print(f"\n[INFO] Looking for the latest successful job for scan '{data_scan_id}'...")
try:
# List all jobs for the specified scan, which are ordered most-recent first.
jobs_pager = client.list_data_scan_jobs(parent=scan_path)
# Iterate through jobs to find the first one that succeeded.
for job in jobs_pager:
if job.state == dataplex_v1.DataScanJob.State.SUCCEEDED:
return job
# If no successful job is found after checking all pages.
return None
except NotFound:
print(f"[WARN] No scan history found for '{data_scan_id}'.")
return None
def main():
"""Main execution function."""
# --- Load configuration from environment variables ---
PROJECT_ID = os.environ.get("PROJECT_ID")
LOCATION = os.environ.get("LOCATION")
if not all([PROJECT_ID, LOCATION]):
print("[ERROR] Required environment variables PROJECT_ID or LOCATION are not set.")
sys.exit(1)
print(f"[INFO] Using Project: {PROJECT_ID}, Location: {LOCATION}")
print(f"--- Starting Profile Retrieval for: {TARGET_VIEW} ---")
# Construct the data_scan_id based on the target view name.
data_scan_id = f"profile-scan-{TARGET_VIEW.replace('_', '-')}"
# 1. Initialize client and get the latest successful job.
client = dataplex_v1.DataScanServiceClient()
latest_job = get_latest_successful_job(client, PROJECT_ID, LOCATION, data_scan_id)
if not latest_job:
print(f"\n[ERROR] No successful job record was found for '{data_scan_id}'.")
print("Please ensure the '1_run_scan.py' script has completed successfully.")
return
job_id_short = latest_job.name.split('/')[-1]
print(f"[SUCCESS] Found the latest successful job: '{job_id_short}'.")
# 2. Fetch the full, detailed profile result for the job.
print(f"[INFO] Retrieving detailed profile results for job '{job_id_short}'...")
try:
request = dataplex_v1.GetDataScanJobRequest(
name=latest_job.name,
view=dataplex_v1.GetDataScanJobRequest.DataScanJobView.FULL,
)
job_with_full_results = client.get_data_scan_job(request=request)
except Exception as e:
print(f"[ERROR] Failed to retrieve detailed job results: {e}")
return
# 3. Convert the profile result to a dictionary and save it to a JSON file.
if job_with_full_results.data_profile_result:
profile_dict = MessageToDict(job_with_full_results.data_profile_result._pb)
save_to_json_file(profile_dict, OUTPUT_FILENAME)
else:
print("[WARN] The job completed, but no data profile result was found within it.")
print("\n[INFO] Script finished successfully.")
if __name__ == "__main__":
main()
ตอนนี้ให้เรียกใช้สคริปต์จากเทอร์มินัลด้วยคำสั่งนี้
python 2_dq_profile_save.py
เมื่อเสร็จสมบูรณ์แล้ว คุณจะมีไฟล์ใหม่ชื่อ dq_profile_results.json ในไดเรกทอรี ไฟล์นี้มีข้อมูลเมตาสถิติที่สมบูรณ์และละเอียด ซึ่งเราจะใช้เพื่อสร้างกฎคุณภาพของข้อมูล หากต้องการตรวจสอบเนื้อหาของ dq_profile_results.json ให้เรียกใช้คำสั่งต่อไปนี้
cat dq_profile_results.json
4. การสร้างกฎคุณภาพของข้อมูลด้วย Antigravity CLI
ตอนนี้คุณใช้ Antigravity CLI (agy) เพื่ออ่านผลการสแกนโปรไฟล์ในเครื่องได้แล้ว การเขียนข้อกําหนดด้านคุณภาพของข้อมูลสําหรับชุดข้อมูลที่ซับซ้อนด้วยตนเองนั้นใช้เวลานานและมีโอกาสเกิดข้อผิดพลาดได้ง่าย การใช้ AI Agent ของ Generative AI ภายในเทอร์มินัลจะช่วยเร่งเวิร์กโฟลว์นี้ด้วยการร่างการกำหนดค่าแบบประกาศเริ่มต้นในไม่กี่วินาที ซึ่งช่วยให้ทีมข้อมูลเปลี่ยนจากการร่างไวยากรณ์ด้วยตนเองไปเป็นการกำกับดูแลแบบ Human-in-the-Loop (HITL) ระดับสูงที่สอดคล้องกับธุรกิจ
หากต้องการเริ่มใช้ Antigravity CLI ให้เรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล
agy
ตอนนี้คุณก็พร้อมที่จะสร้างกฎคุณภาพแล้ว เนื่องจาก CLI อ่านไฟล์ในไดเรกทอรีปัจจุบันได้ จึงใช้ข้อมูลการสแกนโปรไฟล์ใหม่ได้โดยตรง
แจ้งให้ Agent สร้างแผน
ก่อนอื่น เราจะขอให้ Agent ของ Antigravity วิเคราะห์โปรไฟล์ทางสถิติและเสนอแผนการดำเนินการ เราสั่งให้ยังไม่ต้องเขียนไฟล์ YAML ซึ่งจะมุ่งเน้นไปที่การวิเคราะห์และการให้เหตุผล
ในเซสชัน Antigravity CLI แบบอินเทอร์แอกทีฟ ให้ป้อนพรอมต์ที่มีโครงสร้างต่อไปนี้
# Context
You are preparing a data quality rule configuration plan for Google Cloud Knowledge Catalog based on data profile statistics.
# Input
- File Path: `./dq_profile_results.json` (contains metrics like null percentage, distinct counts, and distributions)
# Task
Analyze the input statistics and propose a step-by-step plan for establishing automated data quality rules.
*Do not write any YAML code in this step.* Focus only on analytical planning.
# Rule Mapping Strategy
For candidate columns, match the statistical metrics to the most appropriate expectations:
- `nonNullExpectation`: Propose for columns with 0% null values in the profile.
- `setExpectation`: Propose for columns with a highly limited, stable set of categorical values.
- `rangeExpectation`: Propose for numeric columns with consistent and predictable value boundaries.
# Guidelines
- Provide a metric-based justification for each proposed rule (e.g., "Recommend `nonNullExpectation` for column 'user_pseudo_id' because its null percentage is 0%").
- Flag volatile metrics such as hardcoded row counts that could cause false-positive alerts in production.
# Output Format
Provide your analysis and proposed rules as a structured, step-by-step markdown plan with clear headings.
Agent จะวิเคราะห์ไฟล์ JSON และควรแสดงแผนที่มีโครงสร้างคล้ายกับตัวอย่างต่อไปนี้
Automated Data Quality Rule Configuration Plan
Google Cloud Knowledge Catalog (Dataplex Data Quality)
──────
## Executive Summary
This analytical planning document outlines a step-by-step strategy for configuring automated data quality (DQ) rules in Google Cloud Knowledge Catalog (formerly Dataplex Data Quality) based on profiling statistics.
The dataset contains 26,489 rows representing GA4 event logs. Based on statistical metrics (null ratios, distinct value distributions, and data types), candidate columns are mapped to appropriate expectation rules.
──────
## 1. Data Profile Overview & Statistical Highlights
Column Name │ Data Type │ Null Ratio │ Distinct Count │ Key Value Range / Categories
─────────────────┼───────────┼────────────────┼────────────────┼──────────────────────────────────────────────────
event_date │ STRING │ 0.0% (0) │ 1 (3.78e-05) │ "20210131" (100%)
event_timestamp │ INTEGER │ 0.0% (0) │ ~16,539 (0.62) │ Min: 1612051200657906, Max: 1612137595412363
event_name │ STRING │ 0.0% (0) │ 16 (0.0006) │ page_view (35.8%), user_engagement (18.9%), etc.
user_pseudo_id │ STRING │ 0.0% (0) │ ~2,545 (0.09) │ 18–21 characters string identifiers
user_id │ STRING │ 100.0% (1.0) │ 0 (0.0) │ Entirely NULL
device_category │ STRING │ 0.0% (0) │ 3 (0.0001) │ desktop (57.5%), mobile (40.1%), tablet (2.4%)
... │ ... │ ... │ ... │ ...
──────
## 2. Rule Mapping Strategy & Analytical Justifications
### Step 1: Nullability Rules (nonNullExpectation)
Propose nonNullExpectation for mandatory columns where the data profile demonstrates 0% null values.
• user_pseudo_id, event_timestamp, event_name, event_date, stream_id, platform, device_category (Metric Justification: nullRatio is 0.0%)
│ [!NOTE] Exclusions:
│ • user_id: Has a nullRatio of 100.0% (unauthenticated traffic).
│ • device_language: Has a nullRatio of 37.53%.
──────
### Step 2: Categorical Value Set Validation (setExpectation)
Propose setExpectation for columns with a highly limited, stable set of categorical domain values.
• device_category: Distinct count is exactly 3. Allowed set: ['desktop', 'mobile', 'tablet']
• platform: Distinct count is 1. Allowed set expanded to: ['WEB', 'ANDROID', 'IOS'] to avoid over-fitting.
• geo_continent: Distinct count is 6. Allowed set: ['Americas', 'Asia', 'Europe', 'Africa', 'Oceania', 'Antarctica', '(not set)']
──────
### Step 3: Numeric & Timestamp Boundary Validation (rangeExpectation)
Propose rangeExpectation for numeric columns with consistent and predictable value boundaries.
• event_timestamp: rangeExpectation requiring event_timestamp > 0 (avoid dynamic microsecond range hardcoding)
• stream_id: rangeExpectation requiring positive integer stream IDs (stream_id > 0)
──────
## 3. Risk Warning: Volatile Metrics & Production False Positives
│ [!WARNING] Volatile Metrics Flagged for Risk Mitigation:
1. Hardcoded Total Row Count (rowCount = 26,489) -> Daily event volume fluctuates. Use dynamic volume thresholds.
2. Hardcoded Partition Date (event_date = '20210131') -> Breaks on future runs. Validate against YYYYMMDD regex patterns.
3. Exact Timestamp Range Bounds -> Enforcing these microsecond limits on incoming live pipelines will reject all future data.
4. Single-Value Domain Restrictions -> Single profile sample might lack active streams. Set sets according to enterprise schema.
──────
## Summary Table of Proposed Rules
Target Column │ Rule Type │ Metric-Based Justification │ Operational Considerations
─────────────────┼────────────────────┼────────────────────────────┼──────────────────────────────────────────────────
user_pseudo_id │ nonNullExpectation │ Null Ratio: 0.0% │ Core identifier, strictly required
event_timestamp │ nonNullExpectation │ Null Ratio: 0.0% │ Temporal key, strictly required
event_timestamp │ rangeExpectation │ Min: > 0 (Microseconds) │ Avoid hardcoding epoch min/max
event_name │ nonNullExpectation │ Null Ratio: 0.0% │ Required event taxonomy key
event_name │ setExpectation │ Categorical distribution │ Map to standard GA4 event taxonomy
device_category │ nonNullExpectation │ Null Ratio: 0.0% │ Required form-factor dimension
device_category │ setExpectation │ Distinct Count: 3 values │ ['desktop', 'mobile', 'tablet']
... │ ... │ ... │ ...
สร้างกฎคุณภาพของข้อมูล
นี่เป็นขั้นตอนที่สำคัญที่สุดในเวิร์กโฟลว์ทั้งหมด นั่นคือการตรวจสอบโดยมีมนุษย์เป็นผู้ควบคุม (HITL) แผนที่ Agent สร้างขึ้นจะอิงตามรูปแบบทางสถิติในข้อมูลเท่านั้น โดยไม่มีความเข้าใจในบริบททางธุรกิจ การเปลี่ยนแปลงข้อมูลในอนาคต หรือความตั้งใจที่เฉพาะเจาะจงเบื้องหลังข้อมูลของคุณ บทบาทของคุณในฐานะผู้เชี่ยวชาญที่เป็นมนุษย์คือการตรวจสอบ แก้ไข และอนุมัติแผนนี้ก่อนที่จะเปลี่ยนเป็นโค้ด
ตรวจสอบแผนที่ตัวแทนให้มาอย่างละเอียด
- ฟังแล้วเข้าท่าหรือเปล่า
- สอดคล้องกับความรู้ด้านธุรกิจของคุณหรือไม่
- มีกฎที่ดูสมเหตุสมผลในเชิงสถิติแต่ใช้จริงไม่ได้ไหม
เอาต์พุตที่คุณได้รับจากเอเจนต์อาจแตกต่างกันไป เป้าหมายของคุณคือการปรับแต่ง เช่น สมมติว่าแพ็กเกจแนะนำกฎ rowCount เนื่องจากตารางมีจำนวนแถวคงที่ในข้อมูลตัวอย่าง ในฐานะผู้เชี่ยวชาญที่เป็นมนุษย์ คุณอาจทราบว่าตารางนี้มีแนวโน้มที่จะมีขนาดใหญ่ขึ้นทุกวัน ซึ่งทำให้กฎจำนวนแถวที่เข้มงวดไม่สามารถใช้งานได้จริงและอาจทำให้เกิดการแจ้งเตือนที่ผิดพลาด นี่คือตัวอย่างที่สมบูรณ์แบบของการใช้บริบททางธุรกิจที่ AI ไม่มี
ตอนนี้คุณจะแสดงความคิดเห็นต่อเอเจนต์และให้คำสั่งสุดท้ายเพื่อสร้างโค้ด คุณต้องปรับพรอมต์ต่อไปนี้ตามแผนที่คุณได้รับจริงและการแก้ไขที่ต้องการทำ
พรอมต์ด้านล่างคือเทมเพลต บรรทัดแรกคือที่ที่คุณจะระบุการแก้ไขที่เฉพาะเจาะจง หากแผนที่ตัวแทนให้คุณนั้นสมบูรณ์แบบและไม่จำเป็นต้องเปลี่ยนแปลง คุณก็ลบบรรทัดนั้นได้เลย
ในเซสชัน Antigravity เดียวกัน ให้ป้อนพรอมต์ต่อไปนี้ในเวอร์ชันที่ปรับแล้ว
# Feedback & Approvals
[YOUR CORRECTIONS AND APPROVAL GO HERE. Examples:
- "The plan looks good. Please proceed."
- "The rowCount rule is not necessary, as the table size changes daily. The rest of the plan is approved. Please proceed."
- "For the setExpectation on the geo_continent column, please also include 'Antarctica'."]
# Objective
Based on the approved analysis plan and the provided feedback, generate the final `dq_rules.yaml` file conforming to the standard `DataQualityRule` schema.
# Instructions
1. **Rule Justifications**: For every generated rule, add a YAML comment (`#`) on the line directly above it, briefly explaining the justification established in the plan.
2. **Schema Alignment**: Ensure the structure strictly adheres to the required Knowledge Catalog data quality scan specification. Refer to the `sample_rule.yaml` file in the current directory and the `DataQualityRule` class definition in the local virtual environment path (`./dq_venv/.../google/cloud/dataplex_v1/types/data_quality.py`) as the schema authority.
3. **Data-Driven Values**: Derive all rule parameters, such as thresholds or expected values, directly from the statistical metrics in `dq_profile_results.json`.
# Constraints
- **Output Purity**: Return ONLY the raw, valid, and properly formatted YAML code block.
- Do not include conversational preambles, introductory sentences, explanations, or markdown blocks around the YAML.
ตอนนี้ Agent จะสร้างเนื้อหา YAML ตามคำสั่งที่แม่นยำและผ่านการตรวจสอบจากมนุษย์ของคุณ เมื่อเสร็จสิ้น คุณจะเห็นไฟล์ใหม่ชื่อ dq_rules.yaml ในไดเรกทอรีการทำงาน
สร้างและเรียกใช้การสแกนคุณภาพของข้อมูล
ตอนนี้คุณมีไฟล์ dq_rules.yaml ที่เอเจนต์สร้างขึ้นและมนุษย์ตรวจสอบแล้ว คุณจึงมั่นใจได้ว่าจะนำไปใช้งานได้
ออกจาก Antigravity CLI โดยพิมพ์ /quit หรือกด Ctrl+C 2 ครั้ง
คำสั่ง gcloud ต่อไปนี้จะสร้างทรัพยากรการสแกนข้อมูลแคตตาล็อกความรู้ใหม่ แต่จะยังไม่เรียกใช้การสแกน เพียงแค่ลงทะเบียนคำจำกัดความและการกำหนดค่าของการสแกน (ไฟล์ YAML) กับแคตตาล็อกความรู้
เรียกใช้คำสั่งนี้ในเทอร์มินัล
export DQ_SCAN="dq-scan"
gcloud dataplex datascans create data-quality $DQ_SCAN \
--project=$PROJECT_ID \
--location=$LOCATION \
--data-quality-spec-file=dq_rules.yaml \
--data-source-resource="//bigquery.googleapis.com/projects/$PROJECT_ID/datasets/$DATASET_ID/tables/mv_ga4_user_session_flat"
เมื่อกำหนดการสแกนแล้ว คุณก็ทริกเกอร์งานเพื่อเรียกใช้ได้
gcloud dataplex datascans run $DQ_SCAN --location=$LOCATION --project=$PROJECT_ID
คำสั่งนี้จะแสดงรหัสงาน คุณสามารถตรวจสอบสถานะของงานนี้ได้ในส่วนแคตตาล็อกความรู้ของคอนโซล Google Cloud เมื่อเสร็จสมบูรณ์แล้ว ระบบจะเขียนผลลัพธ์ไปยังตาราง BigQuery เพื่อการวิเคราะห์
5. บทบาทสำคัญของ Human-In-The-Loop (HITL)
แม้ว่าการใช้ Agent ของ Antigravity เพื่อเร่งการสร้างกฎจะมีประสิทธิภาพอย่างยิ่ง แต่สิ่งสำคัญคือต้องถือว่า AI เป็นผู้ช่วยอัจฉริยะที่มีทักษะสูง ไม่ใช่ผู้ช่วยอัจฉริยะที่ทำงานเองโดยไม่มีคนควบคุม กระบวนการ Human-in-the-Loop (HITL) ไม่ใช่คำแนะนำที่ไม่บังคับ แต่เป็นขั้นตอนพื้นฐานที่ต่อรองไม่ได้ในเวิร์กโฟลว์การกำกับดูแลข้อมูล การติดตั้งใช้งานอาร์ติแฟกต์ที่ AI สร้างขึ้นโดยไม่มีการกำกับดูแลจากเจ้าหน้าที่อย่างเข้มงวดเป็นสูตรที่ทำให้เกิดความล้มเหลว
ให้คิดว่า dq_rules.yaml ที่ AI สร้างขึ้นเป็น Pull Request ที่ส่งโดยนักพัฒนา AI ที่รวดเร็วมากแต่ไม่มีประสบการณ์ ซึ่งต้องได้รับการตรวจสอบอย่างละเอียดจากผู้เชี่ยวชาญที่เป็นบุคคลอาวุโสอย่างคุณก่อนจึงจะผสานรวมเข้ากับ "Branch หลัก" ของนโยบายการกำกับดูแลและทำให้ใช้งานได้ การตรวจสอบนี้มีความสำคัญต่อการลดจุดอ่อนที่มีอยู่ในโมเดลภาษาขนาดใหญ่
รายละเอียดว่าทำไมการตรวจสอบจากเจ้าหน้าที่จึงมีความสำคัญและสิ่งที่คุณต้องพิจารณาโดยเฉพาะมีดังนี้
1. การตรวจสอบตามบริบท: AI ขาดความตระหนักด้านธุรกิจ
- จุดอ่อนของ LLM: LLM เชี่ยวชาญด้านรูปแบบและสถิติ แต่ไม่เข้าใจบริบททางธุรกิจของคุณเลย ตัวอย่างเช่น หากคอลัมน์
new_campaign_idมีอัตราส่วนค่า Null 98% LLM อาจไม่สนใจคอลัมน์นี้ด้วยเหตุผลทางสถิติ - บทบาทสำคัญของมนุษย์: คุณซึ่งเป็นผู้เชี่ยวชาญที่เป็นมนุษย์ทราบว่าเราเพิ่งเพิ่มฟิลด์
new_campaign_idเมื่อวานนี้สำหรับการเปิดตัวผลิตภัณฑ์ครั้งใหญ่ในสัปดาห์หน้า คุณทราบดีว่าตอนนี้อัตราส่วนค่า Null ควรจะสูง แต่คาดว่าจะลดลงอย่างมาก นอกจากนี้ คุณยังทราบว่าเมื่อป้อนข้อมูลแล้ว ข้อมูลดังกล่าวจะต้องเป็นไปตามรูปแบบที่เฉพาะเจาะจง AI ไม่สามารถอนุมานความรู้ทางธุรกิจภายนอกนี้ได้ บทบาทของคุณคือการใช้บริบททางธุรกิจนี้กับคำแนะนำทางสถิติของ AI โดยการลบล้างหรือเพิ่มคำแนะนำตามความจำเป็น
2. ความถูกต้องและความแม่นยำ: ป้องกันอาการหลอนและข้อผิดพลาดเล็กๆ น้อยๆ
- จุดอ่อนของ LLM: LLM อาจ "ผิดอย่างมั่นใจ" โมเดลอาจ "หลอน" หรือสร้างโค้ดที่ไม่ถูกต้องอย่างแนบเนียน เช่น อาจสร้างไฟล์ YAML ที่มีกฎซึ่งตั้งชื่ออย่างถูกต้องแต่มีพารามิเตอร์ที่ไม่ถูกต้อง หรืออาจสะกดประเภทกฎผิด (เช่น
setExpectationsแทนที่จะเป็นsetExpectationที่ถูกต้อง) ข้อผิดพลาดเล็กๆ น้อยๆ เหล่านี้จะทำให้การติดตั้งใช้งานล้มเหลว แต่ก็อาจสังเกตได้ยาก - บทบาทสำคัญของมนุษย์: หน้าที่ของคุณคือการทำหน้าที่เป็น Linter และโปรแกรมตรวจสอบสคีมาขั้นสูงสุด คุณต้องตรวจสอบ YAML ที่สร้างขึ้นอย่างละเอียดเทียบกับ
DataQualityRuleข้อกำหนดของแคตตาล็อกความรู้อย่างเป็นทางการ คุณไม่ได้เพียงแค่ตรวจสอบว่า "ดูถูกต้อง" แต่คุณกำลังตรวจสอบความถูกต้องของไวยากรณ์และความหมายเพื่อให้แน่ใจว่าสอดคล้องกับ API เป้าหมาย 100% ด้วยเหตุนี้ Codelab จึงแจ้งให้ตัวแทนอ้างอิงไฟล์สคีมาเพื่อลดโอกาสเกิดข้อผิดพลาด แต่การยืนยันขั้นสุดท้ายจะขึ้นอยู่กับคุณ
3. ความปลอดภัยและการลดความเสี่ยง: การป้องกันผลกระทบที่อาจเกิดขึ้น
- จุดอ่อนของ LLM: กฎคุณภาพของข้อมูลที่มีข้อบกพร่องซึ่งนำไปใช้ในการผลิตอาจส่งผลร้ายแรง หาก AI แนะนำ
rangeExpectationสำหรับจำนวนธุรกรรมทางการเงินที่กว้างเกินไป ก็อาจตรวจหากิจกรรมที่เป็นการฉ้อโกงไม่สำเร็จ ในทางกลับกัน หากแนะนำกฎที่เข้มงวดเกินไปโดยอิงตามตัวอย่างข้อมูลขนาดเล็ก ก็อาจทำให้ทีมที่พร้อมรับสายได้รับแจ้งเตือนที่ผิดพลาดหลายพันรายการ ซึ่งนำไปสู่ความเหนื่อยล้าจากการแจ้งเตือนและทำให้พลาดปัญหาที่แท้จริง - บทบาทสำคัญของมนุษย์: คุณคือวิศวกรด้านความปลอดภัย คุณต้องประเมินผลกระทบที่อาจเกิดขึ้นในภายหลังของทุกกฎที่ AI แนะนำ ให้ถามตัวเองว่า "จะเกิดอะไรขึ้นหากกฎนี้ใช้ไม่ได้ การแจ้งเตือนดำเนินการได้หรือไม่ ความเสี่ยงหากกฎนี้ผ่านอย่างไม่ถูกต้องคืออะไร" การประเมินความเสี่ยงนี้เป็นความสามารถเฉพาะของมนุษย์ที่เปรียบเทียบต้นทุนของความล้มเหลวกับประโยชน์ของการตรวจสอบ
4. การกำกับดูแลเป็นกระบวนการต่อเนื่อง: การรวมความรู้ที่มองไปข้างหน้า
- จุดอ่อนของ LLM: ความรู้ของ AI อิงตามสแนปชอตแบบคงที่ของข้อมูล ซึ่งผลลัพธ์โปรไฟล์มาจากจุดเวลาที่เฉพาะเจาะจง โดยไม่มีความรู้เกี่ยวกับเหตุการณ์ในอนาคต
- บทบาทสำคัญของมนุษย์: กลยุทธ์การกำกับดูแลต้องมองไปข้างหน้า คุณทราบว่าระบบจะกำหนดเวลาการย้ายข้อมูลแหล่งข้อมูลในเดือนหน้า ซึ่งจะเปลี่ยน stream_id คุณทราบว่ามีการเพิ่มประเทศใหม่ลงในรายการ
geo_countryกระบวนการ HITL คือที่ที่คุณป้อนความรู้เกี่ยวกับสถานะในอนาคตนี้ อัปเดตหรือปิดใช้กฎชั่วคราวเพื่อป้องกันการหยุดทำงานระหว่างการพัฒนาทางธุรกิจหรือทางเทคนิคที่วางแผนไว้ คุณภาพของข้อมูลไม่ใช่การตั้งค่าแบบครั้งเดียว แต่เป็นกระบวนการที่ต้องพัฒนาอย่างต่อเนื่อง และมีเพียงมนุษย์เท่านั้นที่สามารถเป็นแนวทางในการพัฒนานี้ได้
กล่าวโดยสรุปคือ HITL เป็นกลไกการประกันคุณภาพและความปลอดภัยที่จำเป็น ซึ่งเปลี่ยนการกำกับดูแลที่ขับเคลื่อนด้วย AI จากแนวคิดใหม่แต่มีความเสี่ยงให้กลายเป็นแนวทางปฏิบัติที่มีความรับผิดชอบ ปรับขนาดได้ และระดับองค์กร ซึ่งจะช่วยให้มั่นใจได้ว่านโยบายสุดท้ายที่นำไปใช้ไม่ได้เร่งด้วย AI เพียงอย่างเดียว แต่ยังได้รับการตรวจสอบจากเจ้าหน้าที่ด้วย โดยเป็นการผสมผสานความเร็วของเครื่องจักรเข้ากับสติปัญญาและบริบทของผู้เชี่ยวชาญที่เป็นมนุษย์
อย่างไรก็ตาม การเน้นการกำกับดูแลโดยมนุษย์นี้ไม่ได้ลดคุณค่าของ AI ในทางตรงกันข้าม Generative AI มีบทบาทสำคัญในการเร่งกระบวนการ HITL เอง
หากไม่มี AI วิศวกรข้อมูลจะต้องทำสิ่งต่อไปนี้
- เขียนการค้นหา SQL ที่ซับซ้อนด้วยตนเองเพื่อสร้างโปรไฟล์ข้อมูล (เช่น
COUNT DISTINCT,AVG,MIN,MAXสำหรับทุกคอลัมน์) - วิเคราะห์สเปรดชีตผลลัพธ์อย่างละเอียด
- เขียนไฟล์กฎ YAML ทุกบรรทัดตั้งแต่ต้น ซึ่งเป็นงานที่น่าเบื่อและมีโอกาสเกิดข้อผิดพลาดได้ง่าย
AI จะทำให้ขั้นตอนที่ต้องใช้ความพยายามและเสียเวลาเหล่านี้เป็นไปโดยอัตโนมัติ โดยจะทำหน้าที่เป็นนักวิเคราะห์ที่ทำงานอย่างไม่เหน็ดเหนื่อย ซึ่งจะประมวลผลโปรไฟล์ทางสถิติได้ทันที และจัดทำ "ฉบับร่างแรก" ของนโยบายที่จัดโครงสร้างอย่างดีและสมบูรณ์ 80%
ซึ่งจะเปลี่ยนลักษณะงานของมนุษย์โดยพื้นฐาน ผู้เชี่ยวชาญที่เป็นมนุษย์สามารถมุ่งเน้นไปที่งานที่มีมูลค่าสูงสุดได้ทันที แทนที่จะใช้เวลาหลายชั่วโมงในการประมวลผลข้อมูลด้วยตนเองและการเขียนโค้ดแบบสำเร็จรูป
- การใช้บริบททางธุรกิจที่สำคัญ
- ตรวจสอบความถูกต้องของตรรกะของ AI
- การตัดสินใจเชิงกลยุทธ์เกี่ยวกับกฎที่สำคัญอย่างแท้จริง
ในการเป็นพาร์ทเนอร์ครั้งนี้ AI จะจัดการ "อะไร" (รูปแบบทางสถิติคืออะไร) เพื่อให้มนุษย์มีเวลาไปโฟกัสที่ "ทำไม" (ทำไมรูปแบบนี้จึงสำคัญต่อธุรกิจของเรา) และ "แล้วไง" (แล้วนโยบายของเราควรเป็นอย่างไร) ดังนั้น AI จึงไม่ได้มาแทนที่ลูป แต่จะช่วยให้แต่ละรอบในลูปเร็วขึ้น ชาญฉลาดขึ้น และมีประสิทธิภาพมากขึ้น
6. การทำความสะอาดสภาพแวดล้อม
หากต้องการหลีกเลี่ยงการเรียกเก็บเงินในอนาคตกับบัญชี Google Cloud สำหรับทรัพยากรที่ใช้ใน Codelab นี้ คุณควรลบโปรเจ็กต์ที่มีทรัพยากร อย่างไรก็ตาม หากต้องการเก็บโปรเจ็กต์ไว้ คุณสามารถลบทรัพยากรแต่ละรายการที่สร้างขึ้นได้
ลบการสแกน Knowledge Catalog
ก่อนอื่น ให้ลบโปรไฟล์และการสแกนคุณภาพที่คุณสร้างขึ้น คำสั่งเหล่านี้ใช้ชื่อเฉพาะของการสแกนที่สร้างขึ้นใน Codelab นี้เพื่อป้องกันการลบทรัพยากรที่สำคัญโดยไม่ตั้งใจ
# Delete the Data Quality Scan
gcloud dataplex datascans delete dq-scan \
--location=us-central1 \
--project=$PROJECT_ID --quiet
# Delete the Data Profile Scans
gcloud dataplex datascans delete profile-scan-mv-ga4-user-session-flat \
--location=us-central1 \
--project=$PROJECT_ID --quiet
gcloud dataplex datascans delete profile-scan-mv-ga4-ecommerce-transactions \
--location=us-central1 \
--project=$PROJECT_ID --quiet
gcloud dataplex datascans delete profile-scan-mv-ga4-ecommerce-items \
--location=us-central1 \
--project=$PROJECT_ID --quiet
ลบชุดข้อมูล BigQuery
จากนั้นให้ลบชุดข้อมูล BigQuery คำสั่งนี้จะยกเลิกไม่ได้ และใช้แฟล็ก -f (บังคับ) เพื่อนำชุดข้อมูลและตารางทั้งหมดออกโดยไม่ต้องยืนยัน
# Manually type this command to confirm you are deleting the correct dataset
bq rm -r -f --dataset $PROJECT_ID:kc_dq_codelab
7. ยินดีด้วย
คุณทำ Codelab เสร็จเรียบร้อยแล้ว
คุณได้สร้างเวิร์กโฟลว์การกำกับดูแลข้อมูลแบบเป็นโปรแกรมตั้งแต่ต้นจนจบแล้ว คุณเริ่มต้นด้วยการใช้มุมมองที่เป็นรูปธรรมเพื่อทำให้ข้อมูล BigQuery ที่ซับซ้อนแบนราบ ซึ่งทำให้เหมาะแก่การวิเคราะห์ จากนั้นคุณจึงเรียกใช้การสแกนโปรไฟล์แคตตาล็อกความรู้โดยอัตโนมัติเพื่อสร้างข้อมูลเมตาเชิงสถิติ ที่สำคัญที่สุดคือ คุณใช้ประโยชน์จาก Antigravity CLI เพื่อวิเคราะห์เอาต์พุตโปรไฟล์และสร้างอาร์ติแฟกต์ "นโยบายเป็นโค้ด" (dq_rules.yaml) อย่างชาญฉลาด จากนั้นคุณใช้ CLI เพื่อติดตั้งใช้งานการกำหนดค่านี้เป็นการสแกนคุณภาพของข้อมูลอัตโนมัติ ซึ่งเป็นการปิดลูปในกลยุทธ์การกำกับดูแลที่ทันสมัยและปรับขนาดได้
ตอนนี้คุณพร้อมที่จะใช้รูปแบบพื้นฐานในการสร้างระบบคุณภาพข้อมูลที่เชื่อถือได้ เร่งด้วย AI และได้รับการตรวจสอบจากมนุษย์ใน Google Cloud แล้ว
ขั้นตอนต่อไปคืออะไร
- ผสานรวมกับ CI/CD: นำไฟล์
dq_rules.yamlไปคอมมิตในที่เก็บ Git สร้างไปป์ไลน์ CI/CD (เช่น ใช้ Cloud Build หรือ GitHub Actions) ที่จะติดตั้งใช้งานการสแกนแคตตาล็อกความรู้โดยอัตโนมัติทุกครั้งที่มีการอัปเดตไฟล์กฎ - สำรวจกฎ SQL ที่กำหนดเอง: ก้าวข้ามประเภทกฎมาตรฐาน แคตตาล็อกความรู้รองรับกฎ SQL ที่กำหนดเองเพื่อบังคับใช้ตรรกะที่ซับซ้อนยิ่งขึ้นและเฉพาะเจาะจงธุรกิจ ซึ่งไม่สามารถแสดงออกด้วยการตรวจสอบที่กำหนดไว้ล่วงหน้า นี่คือฟีเจอร์สำหรับปรับการตรวจสอบตามข้อกำหนดเฉพาะของคุณ
- เพิ่มประสิทธิภาพการสแกนเพื่อประสิทธิภาพและต้นทุน: สำหรับตารางขนาดใหญ่มาก คุณสามารถปรับปรุงประสิทธิภาพและลดต้นทุนได้โดยไม่ต้องสแกนทั้งชุดข้อมูลเสมอไป ลองใช้ตัวกรองเพื่อจำกัดการสแกนให้แคบลงตามกรอบเวลาหรือกลุ่มข้อมูลที่เฉพาะเจาะจง หรือกำหนดค่าการสแกนแบบสุ่มตัวอย่างเพื่อตรวจสอบเปอร์เซ็นต์ที่เป็นตัวแทนของข้อมูล
- แสดงผลลัพธ์ด้วยภาพ: ระบบจะเขียนเอาต์พุตของการสแกนคุณภาพของข้อมูลในแคตตาล็อกความรู้ทุกครั้งไปยังตาราง BigQuery เชื่อมต่อตารางนี้กับ Looker Studio เพื่อสร้างแดชบอร์ดที่ติดตามคะแนนคุณภาพของข้อมูลเมื่อเวลาผ่านไป โดยรวมตามมิติข้อมูลที่คุณกําหนด (เช่น ความสมบูรณ์ ความถูกต้อง) ซึ่งจะช่วยให้การตรวจสอบเป็นไปอย่างเชิงรุกและผู้มีส่วนเกี่ยวข้องทุกฝ่ายมองเห็นได้
- แชร์แนวทางปฏิบัติแนะนำ: สนับสนุนการแชร์ความรู้ภายในองค์กรเพื่อใช้ประโยชน์จากประสบการณ์ร่วมกันและปรับปรุงกลยุทธ์คุณภาพของข้อมูล การส่งเสริมวัฒนธรรมความน่าเชื่อถือของข้อมูลเป็นกุญแจสำคัญในการใช้ความพยายามด้านการกํากับดูแลให้เกิดประโยชน์สูงสุด
- อ่านเอกสารประกอบ