คุณภาพของข้อมูลแบบเป็นโปรแกรมด้วย Dataplex และ Generative AI

1. บทนำ

Codelab นี้เป็นพิมพ์เขียวทางเทคนิคสำหรับผู้ปฏิบัติงานด้านข้อมูล โดยจะอธิบายแนวทาง "เน้นโค้ดเป็นอันดับแรก" ในการกำกับดูแลข้อมูล ซึ่งแสดงให้เห็นวิธีฝังการจัดการคุณภาพและข้อมูลเมตาที่มีประสิทธิภาพลงในวงจรการพัฒนาโดยตรง โดยพื้นฐานแล้ว Dataplex Universal Catalog ทำหน้าที่เป็น Data Fabric อัจฉริยะ ซึ่งช่วยให้องค์กรสามารถจัดการ ตรวจสอบ และควบคุมข้อมูลจากส่วนกลางได้ทั่วทั้งระบบ ตั้งแต่ที่เก็บข้อมูลขนาดใหญ่ไปจนถึงคลังข้อมูล

โค้ดแล็บแสดงวิธีใช้ประโยชน์จาก Dataplex, BigQuery และ Gemini CLI เพื่อทำให้ข้อมูลที่ซับซ้อนแบนราบ สร้างโปรไฟล์ข้อมูลโดยอัตโนมัติ สร้างคำแนะนำกฎคุณภาพของข้อมูลอัจฉริยะ และติดตั้งใช้งานการสแกนคุณภาพอัตโนมัติ เป้าหมายหลักคือการก้าวข้ามกระบวนการที่ต้องทำด้วยตนเองและขับเคลื่อนด้วย UI ซึ่งมีแนวโน้มที่จะเกิดข้อผิดพลาดและปรับขนาดได้ยาก และแทนที่ด้วยการสร้างเฟรมเวิร์ก "นโยบายเป็นโค้ด" ที่มีประสิทธิภาพ ควบคุมเวอร์ชันได้

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

• ความเข้าใจพื้นฐานเกี่ยวกับ Google Cloud Console
• ทักษะพื้นฐานในอินเทอร์เฟซบรรทัดคำสั่งและ Google Cloud Shell

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

• วิธีแปลงข้อมูล BigQuery ที่ซ้อนกันให้เป็นรูปแบบแบนโดยใช้มุมมองที่สร้างขึ้นเพื่อเปิดใช้การจัดทำโปรไฟล์ที่ครอบคลุม
• วิธีเรียกใช้และจัดการการสแกนโปรไฟล์ Dataplex โดยอัตโนมัติโดยใช้ไลบรารีของไคลเอ็นต์ Python ของ Dataplex
• วิธีส่งออกข้อมูลโปรไฟล์และจัดโครงสร้างเป็นอินพุตสำหรับโมเดล Generative AI
• วิธีออกแบบพรอมต์สำหรับ Gemini CLI เพื่อวิเคราะห์ข้อมูลโปรไฟล์และสร้างไฟล์กฎ YAML ที่เป็นไปตามข้อกำหนดของ Dataplex
• ความสำคัญของกระบวนการแบบอินเทอร์แอกทีฟที่มีมนุษย์เป็นผู้ตรวจสอบ (HITL) ในการตรวจสอบการกำหนดค่าที่ AI สร้างขึ้น
• วิธีใช้กฎที่สร้างขึ้นเป็นการสแกนคุณภาพของข้อมูลอัตโนมัติ

สิ่งที่คุณต้องมี

• บัญชี Google Cloud และโปรเจ็กต์ Google Cloud
• เว็บเบราว์เซอร์ เช่น Chrome

แนวคิดหลัก: เสาหลักด้านคุณภาพของข้อมูล Dataplex

การทําความเข้าใจองค์ประกอบหลักของ Dataplex เป็นสิ่งสําคัญในการสร้างกลยุทธ์คุณภาพของข้อมูลที่มีประสิทธิภาพ

• การสแกนโปรไฟล์ข้อมูล: งาน Dataplex ที่วิเคราะห์ข้อมูลและสร้างข้อมูลเมตาทางสถิติ รวมถึงเปอร์เซ็นต์ค่า Null จำนวนค่าที่ไม่ซ้ำกัน และการกระจายค่า ซึ่งถือเป็นระยะ "การค้นพบ" แบบเป็นโปรแกรมของเรา
• กฎคุณภาพของข้อมูล: ข้อความประกาศที่กำหนดเงื่อนไขที่ข้อมูลต้องเป็นไปตาม (เช่น NonNullExpectation, SetExpectation, RangeExpectation)
• Generative AI สำหรับคำแนะนำกฎ: ใช้โมเดลภาษาขนาดใหญ่ (เช่น Gemini) เพื่อวิเคราะห์โปรไฟล์ข้อมูลและแนะนำกฎคุณภาพของข้อมูลที่เกี่ยวข้อง ซึ่งจะช่วยเร่งกระบวนการกำหนดกรอบคุณภาพพื้นฐาน
• การสแกนคุณภาพของข้อมูล: งาน Dataplex ที่ตรวจสอบข้อมูลกับชุดกฎที่กำหนดไว้ล่วงหน้าหรือกฎที่กำหนดเอง
• การกำกับดูแลแบบเป็นโปรแกรม: ธีมหลักของการจัดการการควบคุมการกำกับดูแล (เช่น กฎคุณภาพ) เป็นโค้ด (เช่น ในไฟล์ YAML และสคริปต์ Python) ซึ่งช่วยให้สามารถทำงานอัตโนมัติ จัดเวอร์ชัน และผสานรวมเข้ากับไปป์ไลน์ CI/CD ได้
• การมีมนุษย์เข้ามาเกี่ยวข้อง (HITL): จุดควบคุมที่สำคัญในการผสานรวมความเชี่ยวชาญและการกำกับดูแลของมนุษย์เข้ากับเวิร์กโฟลว์อัตโนมัติ สําหรับการกําหนดค่าที่ AI สร้างขึ้น HITL มีความสําคัญอย่างยิ่งในการตรวจสอบความถูกต้อง ความเกี่ยวข้องทางธุรกิจ และความปลอดภัยของคําแนะนําก่อนการใช้งาน

2. การตั้งค่าและข้อกำหนด

เริ่มต้น Cloud Shell

แม้ว่าคุณจะใช้งาน Google Cloud จากระยะไกลจากแล็ปท็อปได้ แต่ใน Codelab นี้คุณจะใช้ Google Cloud Shell ซึ่งเป็นสภาพแวดล้อมบรรทัดคำสั่งที่ทำงานในระบบคลาวด์

จาก Google Cloud Console ให้คลิกไอคอน Cloud Shell ในแถบเครื่องมือด้านขวาบน

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

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

เปิดใช้ 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="dataplex_dq_codelab"
export TABLE_ID="ga4_transactions"

gcloud services enable dataplex.googleapis.com \
                       bigquery.googleapis.com \
                       serviceusage.googleapis.com

ในตัวอย่างนี้ เราใช้ us (หลายภูมิภาค) เป็นตำแหน่ง เนื่องจากข้อมูลตัวอย่างสาธารณะที่เราจะใช้ก็อยู่ใน us (หลายภูมิภาค) ด้วย BigQuery กำหนดให้ข้อมูลต้นทางและตารางปลายทางสำหรับการค้นหาต้องอยู่ในตำแหน่งเดียวกัน

สร้างชุดข้อมูล BigQuery เฉพาะ

สร้างชุดข้อมูล BigQuery ใหม่เพื่อจัดเก็บข้อมูลตัวอย่างและผลลัพธ์

bq --location=us mk --dataset $PROJECT_ID:$DATASET_ID

เตรียมข้อมูลตัวอย่าง

สําหรับโค้ดแล็บนี้ คุณจะใช้ชุดข้อมูลสาธารณะที่มีข้อมูลอีคอมเมิร์ซที่ถูกทําให้สับสนจาก Google Merchandise Store เนื่องจากชุดข้อมูลสาธารณะเป็นแบบอ่านอย่างเดียว คุณจึงต้องสร้างสำเนาที่แก้ไขได้ในชุดข้อมูลของคุณเอง คำสั่ง bq ต่อไปนี้จะสร้างตารางใหม่ ga4_transactions ในชุดข้อมูล dataplex_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 ที่มีโครงสร้างโฟลเดอร์และไฟล์สนับสนุนที่จำเป็นสำหรับโค้ดแล็บนี้

git clone https://github.com/GoogleCloudPlatform/devrel-demos
cd devrel-demos/data-analytics/programmatic-dq

ตอนนี้ไดเรกทอรีนี้เป็นพื้นที่ทำงานที่ใช้งานอยู่ของคุณ ระบบจะสร้างไฟล์ต่อๆ ไปที่นี่

3. การค้นหาข้อมูลอัตโนมัติด้วยการจัดทำโปรไฟล์ Dataplex

การสร้างโปรไฟล์ข้อมูล Dataplex เป็นเครื่องมือที่มีประสิทธิภาพในการค้นหาข้อมูลทางสถิติเกี่ยวกับข้อมูลของคุณโดยอัตโนมัติ เช่น เปอร์เซ็นต์ค่า Null ความไม่ซ้ำกัน และการกระจายค่า กระบวนการนี้มีความสําคัญอย่างยิ่งต่อการทําความเข้าใจโครงสร้างและคุณภาพของข้อมูล อย่างไรก็ตาม ข้อจำกัดที่ทราบของการจัดทำโปรไฟล์ Dataplex คือไม่สามารถตรวจสอบฟิลด์ที่ซ้อนกันหรือฟิลด์ที่ซ้ำกันได้อย่างเต็มที่ (เช่น RECORD หรือประเภท ARRAY) ภายในตาราง โดยจะระบุได้ว่าคอลัมน์เป็นประเภทที่ซับซ้อน แต่ไม่สามารถสร้างโปรไฟล์ฟิลด์แต่ละรายการภายในโครงสร้างที่ซ้อนกันนั้นได้

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

ทำความเข้าใจสคีมาที่ซ้อนกัน

ก่อนอื่น มาดูสคีมาของตารางแหล่งข้อมูลกัน ชุดข้อมูล Google Analytics 4 (GA4) มีคอลัมน์ที่ซ้อนกันและคอลัมน์ที่ซ้ำกันหลายคอลัมน์ หากต้องการดึงข้อมูลสคีมาทั้งหมดแบบเป็นโปรแกรม รวมถึงโครงสร้างที่ซ้อนกันทั้งหมด คุณสามารถใช้คำสั่ง bq show และบันทึกเอาต์พุตเป็นไฟล์ JSON ได้

bq show --schema --format=json $PROJECT_ID:$DATASET_ID.$TABLE_ID > bq_schema.json

💡 เคล็ดลับ: คุณยังสำรวจสคีมาที่ซ้อนกันนี้แบบภาพได้ใน Google Cloud Console ไปที่ BigQuery ค้นหาdataplex_dq_codelabชุดข้อมูล เลือกga4_transactionsตาราง แล้วคลิกแท็บสคีมา

การตรวจสอบไฟล์ bq_schema.json จะแสดงโครงสร้างที่ซับซ้อน เช่น อุปกรณ์ ภูมิศาสตร์ อีคอมเมิร์ซ และรายการบันทึกที่ซ้ำกัน โครงสร้างเหล่านี้ต้องทำให้แบนราบเพื่อให้การจัดโปรไฟล์มีประสิทธิภาพ

การแปลงข้อมูลเป็นรูปแบบแบนด้วยมุมมองที่เป็นรูปธรรม

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

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

💡 กับดักของผลคูณคาร์ทีเซียน: เหตุผลที่มุมมองแบบแบนราบเพียงมุมมองเดียวไม่สำเร็จ

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

เช่น เหตุการณ์เดียวที่มีสินค้า 3 รายการและพารามิเตอร์ 5 รายการจะขยายเป็น 15 แถว ซึ่งจะทําให้เมตริกระดับเหตุการณ์ (เช่น รายได้) คูณด้วย 15 และทําให้จํานวนเหตุการณ์ไม่มีประโยชน์ ความหมายของแต่ละแถวจะหายไป

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

ให้คิดว่าเป็นการ "ปรับค่าใหม่" ในตาราง GA4 ที่ไม่ได้ปรับค่าให้เป็นปกติเพื่อวัตถุประสงค์ในการวิเคราะห์ที่แตกต่างกัน เช่นเดียวกับที่คุณจะมีตาราง orders และ order_items แยกกันในฐานข้อมูลแบบเดิม

ดังนั้น สำหรับ Codelab นี้ เราจะใช้กลยุทธ์นี้โดยการสร้างมุมมองที่สร้างขึ้นจริงที่แตกต่างกัน 3 รายการ ดังนี้

• มุมมองเซสชัน: 1 แถวต่อเหตุการณ์
• มุมมองธุรกรรม: 1 แถวต่อธุรกรรม
• มุมมองรายการ: 1 แถวต่อ 1 รายการ

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

1. 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`;

2. 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;

3. 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 ด้วยค่าจากสภาพแวดล้อมเชลล์ และส่ง 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

ตอนนี้เรามีมุมมองที่ปรับให้แบนราบและสร้างโปรไฟล์ได้แล้ว เราจึงสร้างและเรียกใช้การสแกนโปรไฟล์ข้อมูล Dataplex สำหรับแต่ละมุมมองได้โดยอัตโนมัติ สคริปต์ Python ต่อไปนี้ใช้ไลบรารีของไคลเอ็นต์ google-cloud-dataplex เพื่อทำให้กระบวนการนี้เป็นแบบอัตโนมัติ

ก่อนเรียกใช้สคริปต์ แนวทางปฏิบัติแนะนำที่สำคัญคือการสร้างสภาพแวดล้อม Python ที่แยกต่างหากภายในไดเรกทอรีโปรเจ็กต์ ซึ่งจะช่วยให้มั่นใจได้ว่าการจัดการทรัพยากร Dependency ของโปรเจ็กต์จะแยกกัน เพื่อป้องกันไม่ให้เกิดความขัดแย้งกับแพ็กเกจอื่นๆ ในสภาพแวดล้อม Cloud Shell

# Create the virtual environment
python3 -m venv dq_venv

# Activate the environment
source dq_venv/bin/activate

ตอนนี้ให้ติดตั้งไลบรารีของไคลเอ็นต์ Dataplex ภายในสภาพแวดล้อมที่เพิ่งเปิดใช้งาน

# Install the Dataplex client library
pip install google-cloud-dataplex

เมื่อตั้งค่าสภาพแวดล้อมและติดตั้งไลบรารีแล้ว คุณก็พร้อมที่จะสร้างสคริปต์การจัดระเบียบ

คลิก "เปิดตัวแก้ไข" ในแถบเครื่องมือ Cloud Shell สร้างไฟล์ใหม่ชื่อ 1_run_dataplex_scans.py แล้ววางโค้ด Python ต่อไปนี้ลงในไฟล์ หากโคลนที่เก็บ GitHub ไฟล์นี้จะอยู่ในโฟลเดอร์ของคุณอยู่แล้ว

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

⚠️ ตรวจสอบสภาพแวดล้อม

เซสชัน Cloud Shell อาจหมดเวลา ก่อนเรียกใช้สคริปต์ ให้ตรวจสอบว่าได้ตั้งค่าตัวแปรสภาพแวดล้อมอย่างถูกต้องแล้วโดยเรียกใช้ echo $PROJECT_ID หากแสดงบรรทัดว่าง โปรดเรียกใช้คำสั่งส่งออกอีกครั้งจากส่วน "การตั้งค่าและข้อกำหนด"

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_dataplex_scans.py

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

คุณดูการสแกนโปรไฟล์ที่เสร็จสมบูรณ์ได้ใน Google Cloud Console

1. ในเมนูการนำทาง ให้ไปที่ Dataplex Universal Catalog และโปรไฟล์ในส่วน Govern

2. คุณควรเห็นการสแกนโปรไฟล์ทั้ง 3 รายการพร้อมสถานะงานล่าสุด คุณคลิกการสแกนเพื่อดูผลลัพธ์โดยละเอียดได้

จากโปรไฟล์ BigQuery ไปยังอินพุตที่พร้อมใช้งาน AI

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

⚠️ ตรวจสอบสภาพแวดล้อม

เซสชัน Cloud Shell อาจหมดเวลา ก่อนเรียกใช้สคริปต์ ให้ตรวจสอบว่าได้ตั้งค่าตัวแปรสภาพแวดล้อมอย่างถูกต้องแล้วโดยเรียกใช้ echo $PROJECT_ID หากแสดงบรรทัดว่าง โปรดเรียกใช้คำสั่งส่งออกอีกครั้งจากส่วน "การตั้งค่าและข้อกำหนด"

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 Dataplex 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 'run_dataplex_scans.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. การสร้างกฎคุณภาพของข้อมูลด้วย Gemini CLI

ติดตั้งและกำหนดค่า Gemini CLI

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

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

ก่อนอื่น ให้ตรวจสอบว่าคุณมีข้อกำหนดเบื้องต้นที่จำเป็น นั่นคือต้องติดตั้ง Node.js เวอร์ชัน 20 ขึ้นไปในสภาพแวดล้อม Cloud Shell คุณตรวจสอบเวอร์ชันได้โดยเรียกใช้ node -v

การติดตั้ง

คุณใช้ Gemini CLI ได้ 2 วิธี ได้แก่ การติดตั้งชั่วคราวหรือการติดตั้งแบบถาวรมากขึ้น เราจะพูดถึงทั้ง 2 วิธีที่นี่

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

ในเทอร์มินัล Cloud Shell ให้เรียกใช้คำสั่งต่อไปนี้

npx https://github.com/google-gemini/gemini-cli

คำสั่งนี้จะดาวน์โหลดและเรียกใช้แพ็กเกจ CLI ชั่วคราว

สำหรับโปรเจ็กต์จริงใดๆ แนวทางปฏิบัติแนะนำคือการติดตั้ง CLI ในเครื่องลงในไดเรกทอรีโปรเจ็กต์ แนวทางนี้มีข้อดีที่สำคัญหลายประการ ดังนี้

• การแยกการอ้างอิง: ช่วยให้มั่นใจว่าโปรเจ็กต์ของคุณมี CLI เวอร์ชันของตัวเอง ซึ่งจะป้องกันไม่ให้เวอร์ชันขัดแย้งกับโปรเจ็กต์อื่นๆ
• ความสามารถในการทำซ้ำ: ทุกคนที่โคลนโปรเจ็กต์จะติดตั้งการอ้างอิงที่เหมือนกันทุกประการได้ ทำให้การตั้งค่าเชื่อถือได้และพกพาได้
• การปรับแนวทางปฏิบัติแนะนำ: เป็นไปตามรูปแบบมาตรฐานสำหรับการจัดการการขึ้นต่อกันของโปรเจ็กต์ Node.js ซึ่งหลีกเลี่ยงข้อผิดพลาดของการติดตั้งส่วนกลาง (-g)

หากต้องการติดตั้ง CLI ในเครื่อง ให้เรียกใช้คำสั่งต่อไปนี้จากโฟลเดอร์โปรเจ็กต์ (programmatic-dq)

npm install @google/gemini-cli

ซึ่งจะสร้างโฟลเดอร์ node_modules ภายใน programmatic-dq หากต้องการเรียกใช้เวอร์ชันที่คุณเพิ่งติดตั้ง ให้ใช้คำสั่ง npx

npx gemini

การตั้งค่าครั้งแรก

ไม่ว่าจะเลือกใช้วิธีใดก็ตาม เมื่อเปิดใช้ CLI เป็นครั้งแรก ระบบจะแนะนำขั้นตอนการตั้งค่าแบบครั้งเดียว

ระบบจะแจ้งให้คุณเลือกธีมสี แล้วจึงให้สิทธิ์ วิธีที่ง่ายที่สุดคือการลงชื่อเข้าใช้ด้วยบัญชี Google เมื่อได้รับข้อความแจ้ง รุ่นฟรีที่ให้มาเพียงพอสำหรับ Codelab นี้

เมื่อติดตั้งและกำหนดค่า CLI แล้ว คุณก็พร้อมที่จะสร้างกฎแล้ว CLI รู้จักไฟล์ในไดเรกทอรีปัจจุบัน ซึ่งเป็นสิ่งสำคัญสำหรับขั้นตอนถัดไป

สร้างกฎคุณภาพของข้อมูล

แม้ว่าคุณจะขอให้ LLM สร้างไฟล์การกำหนดค่าในคราวเดียวได้ แต่ลักษณะที่ไม่แน่นอนของโมเดล Generative หมายความว่าเอาต์พุตอาจไม่เป็นไปตามสคีมาที่เข้มงวดซึ่งเครื่องมืออย่าง gcloud กำหนดไว้เสมอไป วิธีที่น่าเชื่อถือกว่าคือกระบวนการแบบอินเทอร์แอกทีฟหลายขั้นตอน ซึ่งคุณให้ AI ทำหน้าที่เป็นนักวิเคราะห์เพื่อเสนอแผนก่อน จากนั้นคุณ (ผู้เชี่ยวชาญที่เป็นมนุษย์) จะตรวจสอบและอนุมัติแผนดังกล่าว แล้ว AI จึงจะสร้างโค้ดสุดท้ายตามวิธีการที่คุณอนุมัติ

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

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

ในเซสชัน Gemini CLI แบบอินเทอร์แอกทีฟ ให้วางพรอมต์ต่อไปนี้

💡 เคล็ดลับการใช้พรอมต์: สังเกตการใช้ ./dq_profile_results.json การระบุเส้นทางด้วย ./ เป็นการบอก CLI อย่างชัดเจนให้ค้นหาไฟล์ในไดเรกทอรีการทำงานปัจจุบัน ซึ่งจะทำให้พรอมต์มีความแข็งแกร่งมากขึ้นและช่วยป้องกันข้อผิดพลาดหากเปิดใช้ CLI จากตำแหน่งที่ไม่ถูกต้องโดยไม่ตั้งใจ

You are an expert Google Cloud Dataplex engineer. 
Your first task is to create a plan. I have a file in the current directory named ./dq_profile_results.json. 
Based on the statistical data within that file, propose a step-by-step plan to create a Dataplex data quality rules file. 
Your plan should identify which specific columns are good candidates for rules like nonNullExpectation, setExpectation, or rangeExpectation, and explain why based on the metrics (e.g., "Plan to create a nonNullExpectation for column X because its null percentage is 0%"). 
Do not write the YAML file yet. Just provide the plan.

Gemini จะวิเคราะห์ไฟล์ JSON และควรแสดงแผนที่มีโครงสร้างคล้ายกับตัวอย่างต่อไปนี้

Plan to create Dataplex data quality rules

1. Create a row count rule:
  - Analysis: The profile shows a total of 26,489 rows.
  - Proposed Rule: I will implement a rowCount rule to ensure the table's row count remains within a healthy range (e.g., 20,000 to 30,000). This is a fundamental check to guard against major data loading failures or unexpected deletions.
2. Implement non-null expectation rules:
  - Analysis: The profiling results show that many columns have no null values. For example, event_date, event_timestamp, event_name, user_pseudo_id, stream_id, and platform all appear to be fully populated.
  - Proposed Rules: I will create nonNullExpectation rules for columns where the nullRatio is 0 or not present, indicating they are always expected to contain a value:
    - event_date
    - event_timestamp
    - event_name
    - user_pseudo_id
    - stream_id
    - platform
    - device_category
    - device_os
3. Implement set expectation rules:
  - Analysis: Several columns contain a small, finite set of values, making them ideal for set validation.
  - Proposed Rules: I will create setExpectation rules for these columns:
    - platform: It only contains the value "WEB".
    - device_category: It contains only "desktop", "mobile", and "tablet".
    - geo_continent: It has a well-defined list of continents.
traffic_source_medium: It has a small list of valid mediums like "organic", "(none)", and "referral".
4. Implement range expectation rules:
  - Analysis: The profile provides minimum and maximum values for numeric and string length fields.
  - Proposed Rules: I will create rangeExpectation rules for the following:
    - event_timestamp: The profile shows a clear min and max. I will use these values to create a range check.
    - event_date (String Length): The profile indicates that the minLength and maxLength are both 8, which is perfect for enforcing a YYYYMMDD format.

นี่เป็นขั้นตอนที่สำคัญที่สุดในเวิร์กโฟลว์ทั้งหมด นั่นคือการตรวจสอบโดยมีมนุษย์เป็นผู้ควบคุม (HITL) แผนที่ Gemini สร้างขึ้นจะอิงตามรูปแบบทางสถิติในข้อมูลเท่านั้น โดยไม่มีความเข้าใจในบริบททางธุรกิจ การเปลี่ยนแปลงข้อมูลในอนาคต หรือความตั้งใจที่เฉพาะเจาะจงเบื้องหลังข้อมูลของคุณ บทบาทของคุณในฐานะผู้เชี่ยวชาญที่เป็นมนุษย์คือการตรวจสอบ แก้ไข และอนุมัติแผนนี้ก่อนที่จะเปลี่ยนเป็นโค้ด

โปรดตรวจสอบแผนที่ Gemini ให้มาอย่างละเอียด

• ฟังแล้วเข้าท่าหรือเปล่า
• สอดคล้องกับความรู้ทางธุรกิจของคุณหรือไม่
• มีกฎที่ดูดีในเชิงสถิติแต่ใช้จริงไม่ได้ไหม

เอาต์พุตที่คุณได้รับจาก Gemini อาจแตกต่างกันไป เป้าหมายของคุณคือการปรับแต่ง

เช่น สมมติว่าแพ็กเกจแนะนำกฎ rowCount เนื่องจากตารางมีจำนวนแถวคงที่ในข้อมูลตัวอย่าง ในฐานะผู้เชี่ยวชาญที่เป็นมนุษย์ คุณอาจทราบว่าตารางนี้มีแนวโน้มที่จะมีขนาดใหญ่ขึ้นทุกวัน ซึ่งทำให้กฎการนับแถวที่เข้มงวดไม่สามารถใช้งานได้จริงและอาจทำให้เกิดการแจ้งเตือนที่ผิดพลาด นี่คือตัวอย่างที่ยอดเยี่ยมของการใช้บริบททางธุรกิจที่ AI ไม่มี

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

พรอมต์ด้านล่างคือเทมเพลต บรรทัดแรกคือจุดที่คุณจะระบุการแก้ไขที่เฉพาะเจาะจง หากแผนที่ Gemini ให้มานั้นสมบูรณ์แบบและไม่ต้องเปลี่ยนแปลง คุณก็ลบบรรทัดนั้นได้เลย

ในเซสชัน Gemini เดียวกัน ให้วางพรอมต์ต่อไปนี้ในเวอร์ชันที่ปรับแล้ว

[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'."]

Once you have incorporated my feedback, please generate the `dq_rules.yaml` file.

You must adhere to the following strict requirements:

- Schema Compliance: The YAML structure must strictly conform to the DataQualityRule specification. For a definitive source of truth, you must 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.

- Data-Driven Values: All rule parameters, such as thresholds or expected values, must be derived directly from the statistical metrics in dq_profile_results.json.

- Rule Justification: For each rule, add a comment (#) on the line above explaining the justification, as you outlined in your plan.

- Output Purity: The final output must only be the raw YAML code block, perfectly formatted and ready for immediate deployment.

ตอนนี้ Gemini จะสร้างเนื้อหา YAML โดยอิงตามคำสั่งที่แม่นยำและผ่านการตรวจสอบจากมนุษย์ของคุณ เมื่อเสร็จสิ้น คุณจะเห็นไฟล์ใหม่ชื่อ dq_rules.yaml ในไดเรกทอรีการทำงาน

สร้างและเรียกใช้การสแกนคุณภาพของข้อมูล

ตอนนี้คุณมีไฟล์ dq_rules.yaml ที่ AI สร้างขึ้นและมนุษย์ตรวจสอบแล้ว คุณจึงมั่นใจได้ที่จะนําไปใช้งาน

ออกจาก Gemini CLI โดยพิมพ์ /quit หรือกด Ctrl+C 2 ครั้ง

คำสั่ง gcloud ต่อไปนี้จะสร้างทรัพยากรการสแกนข้อมูล Dataplex ใหม่ แต่ยังไม่ได้เรียกใช้การสแกน เพียงแค่ลงทะเบียนคำจำกัดความและการกำหนดค่าของการสแกน (ไฟล์ YAML ของเรา) กับ Dataplex

เรียกใช้คำสั่งนี้ในเทอร์มินัล

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

คำสั่งนี้จะแสดงรหัสงาน คุณตรวจสอบสถานะของงานนี้ได้ในส่วน Dataplex ของคอนโซล Google Cloud เมื่อเสร็จสมบูรณ์แล้ว ระบบจะเขียนผลลัพธ์ไปยังตาราง BigQuery เพื่อการวิเคราะห์

5. บทบาทสำคัญของ Human-In-The-Loop (HITL)

แม้ว่าการใช้ Gemini เพื่อเร่งการสร้างกฎจะมีประสิทธิภาพอย่างยิ่ง แต่สิ่งสำคัญคือต้องถือว่า AI เป็นผู้ช่วยนักบินที่มีทักษะสูง ไม่ใช่ผู้ช่วยนักบินที่ทำงานโดยอัตโนมัติอย่างเต็มรูปแบบ กระบวนการที่มีคนคอยตรวจสอบ (HITL) ไม่ใช่คำแนะนำที่ไม่บังคับ แต่เป็นขั้นตอนพื้นฐานที่ต่อรองไม่ได้ในเวิร์กโฟลว์การกำกับดูแลข้อมูลที่แข็งแกร่งและเชื่อถือได้ การติดตั้งใช้งานอาร์ติแฟกต์ที่ AI สร้างขึ้นโดยไม่มีการกำกับดูแลอย่างเข้มงวดจากเจ้าหน้าที่เป็นสูตรที่ทำให้เกิดความล้มเหลว

ลองนึกถึง dq_rules.yaml ที่ AI สร้างขึ้นว่าเป็นคำขอให้ผสานรวมโค้ดที่นักพัฒนา AI ที่รวดเร็วมากแต่ไม่มีประสบการณ์ส่งมา ซึ่งต้องได้รับการตรวจสอบอย่างละเอียดจากผู้เชี่ยวชาญที่เป็นมนุษย์อาวุโสอย่างคุณก่อนจึงจะผสานรวมเข้ากับ "สาขาหลัก" ของนโยบายการกำกับดูแลและนำไปใช้งานได้ การตรวจสอบนี้มีความสำคัญต่อการลดจุดอ่อนที่มีอยู่ในโมเดลภาษาขนาดใหญ่

รายละเอียดว่าทำไมการตรวจสอบจากเจ้าหน้าที่จึงมีความสำคัญและสิ่งที่คุณต้องพิจารณาโดยเฉพาะมีดังนี้

1. การตรวจสอบตามบริบท: AI ขาดความตระหนักด้านธุรกิจ

• จุดอ่อนของ LLM: LLM เชี่ยวชาญด้านรูปแบบและสถิติ แต่ไม่เข้าใจบริบททางธุรกิจของคุณเลย ตัวอย่างเช่น หากคอลัมน์ new_campaign_id มีอัตราส่วนค่า Null 98% LLM อาจไม่สนใจคอลัมน์นี้ด้วยเหตุผลทางสถิติ
• บทบาทสำคัญของมนุษย์: คุณซึ่งเป็นผู้เชี่ยวชาญที่เป็นมนุษย์ทราบว่าเราเพิ่งเพิ่มฟิลด์ new_campaign_id เมื่อวานนี้สำหรับการเปิดตัวผลิตภัณฑ์ที่สำคัญในสัปดาห์หน้า คุณทราบว่าตอนนี้อัตราส่วนค่า Null ควรจะสูง แต่คาดว่าจะลดลงอย่างมาก นอกจากนี้ คุณยังทราบว่าเมื่อป้อนข้อมูลแล้ว ข้อมูลดังกล่าวจะต้องเป็นไปตามรูปแบบที่เฉพาะเจาะจง AI ไม่สามารถอนุมานความรู้ทางธุรกิจภายนอกนี้ได้ บทบาทของคุณคือการใช้บริบททางธุรกิจนี้กับคำแนะนำทางสถิติของ AI โดยการลบล้างหรือเพิ่มคำแนะนำตามความจำเป็น

2. ความถูกต้องและความแม่นยำ: ป้องกันอาการหลอนและข้อผิดพลาดเล็กๆ น้อยๆ

• จุดอ่อนของ LLM: LLM อาจ "ผิดอย่างมั่นใจ" โมเดลอาจ "หลอน" หรือสร้างโค้ดที่ไม่ถูกต้องอย่างแนบเนียน เช่น อาจสร้างไฟล์ YAML ที่มีกฎซึ่งตั้งชื่ออย่างถูกต้องแต่มีพารามิเตอร์ที่ไม่ถูกต้อง หรืออาจสะกดประเภทกฎผิด (เช่น setExpectations แทนที่จะเป็น setExpectation ที่ถูกต้อง ข้อผิดพลาดเล็กๆ น้อยๆ เหล่านี้จะทำให้การติดตั้งใช้งานล้มเหลว แต่ก็อาจสังเกตได้ยาก
• บทบาทสำคัญของเจ้าหน้าที่: หน้าที่ของคุณคือการทำหน้าที่เป็นตัวตรวจสอบรูปแบบและตัวตรวจสอบสคีมาขั้นสูงสุด คุณต้องตรวจสอบ YAML ที่สร้างขึ้นอย่างละเอียดเทียบกับDataQualityRuleข้อกำหนดอย่างเป็นทางการของ Dataplex คุณไม่ได้เพียงแค่ตรวจสอบว่า "ดูถูกต้อง" แต่คุณกำลังตรวจสอบความถูกต้องของไวยากรณ์และความหมายเพื่อให้แน่ใจว่าสอดคล้องกับ API เป้าหมาย 100% ด้วยเหตุนี้ Codelab จึงแจ้งให้ Gemini อ้างอิงไฟล์สคีมาเพื่อลดโอกาสที่จะเกิดข้อผิดพลาด แต่การยืนยันขั้นสุดท้ายจะขึ้นอยู่กับคุณ

3. ความปลอดภัยและการลดความเสี่ยง: การป้องกันผลกระทบที่อาจเกิดขึ้น

• จุดอ่อนของ LLM: กฎคุณภาพของข้อมูลที่มีข้อบกพร่องซึ่งนำไปใช้ในการผลิตอาจส่งผลร้ายแรง หาก AI แนะนำ rangeExpectation สำหรับจำนวนธุรกรรมทางการเงินที่กว้างเกินไป ก็อาจตรวจหากิจกรรมที่เป็นการฉ้อโกงไม่สำเร็จ ในทางกลับกัน หากแนะนำกฎที่เข้มงวดเกินไปโดยอิงตามตัวอย่างข้อมูลขนาดเล็ก ก็อาจทำให้ทีมที่พร้อมรับสายได้รับแจ้งเตือนที่ผิดพลาดหลายพันรายการ ซึ่งนำไปสู่ความเหนื่อยล้าจากการแจ้งเตือนและทำให้พลาดปัญหาที่แท้จริง
• บทบาทสำคัญของมนุษย์: คุณคือวิศวกรด้านความปลอดภัย คุณต้องประเมินผลกระทบที่อาจเกิดขึ้นในภายหลังของทุกกฎที่ AI แนะนำ ให้ถามตัวเองว่า "จะเกิดอะไรขึ้นหากกฎนี้ใช้ไม่ได้ การแจ้งเตือนดำเนินการได้หรือไม่ ความเสี่ยงหากกฎนี้ผ่านอย่างไม่ถูกต้องคืออะไร" การประเมินความเสี่ยงนี้เป็นความสามารถเฉพาะของมนุษย์ที่พิจารณาต้นทุนของความล้มเหลวเทียบกับประโยชน์ของการตรวจสอบ

4. การกำกับดูแลในฐานะกระบวนการต่อเนื่อง: การนำความรู้ที่มองไปข้างหน้ามาใช้

• จุดอ่อนของ LLM: ความรู้ของ AI อิงตามภาพรวมแบบคงที่ของข้อมูล ซึ่งผลลัพธ์ของโปรไฟล์มาจากจุดเวลาที่เฉพาะเจาะจง และไม่มีความรู้เกี่ยวกับเหตุการณ์ในอนาคต
• บทบาทสำคัญของมนุษย์: กลยุทธ์การกำกับดูแลต้องมองไปข้างหน้า คุณทราบว่าระบบจะกำหนดเวลาการย้ายข้อมูลแหล่งข้อมูลในเดือนหน้า ซึ่งจะเปลี่ยน stream_id คุณทราบว่ามีการเพิ่มประเทศใหม่ลงในรายการ geo_country กระบวนการ HITL คือที่ที่คุณป้อนความรู้เกี่ยวกับสถานะในอนาคตนี้ อัปเดตหรือปิดใช้กฎชั่วคราวเพื่อป้องกันการหยุดทำงานระหว่างการพัฒนาทางธุรกิจหรือทางเทคนิคที่วางแผนไว้ คุณภาพของข้อมูลไม่ใช่การตั้งค่าแบบครั้งเดียว แต่เป็นกระบวนการที่ต้องพัฒนาอย่างต่อเนื่อง และมีเพียงมนุษย์เท่านั้นที่สามารถชี้นำการพัฒนานี้ได้

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

อย่างไรก็ตาม การเน้นการกำกับดูแลโดยมนุษย์นี้ไม่ได้ลดคุณค่าของ AI ในทางตรงกันข้าม Generative AI มีบทบาทสำคัญในการเร่งกระบวนการ HITL เอง

หากไม่มี AI วิศวกรข้อมูลจะต้องทำสิ่งต่อไปนี้

1. เขียนการค้นหา SQL ที่ซับซ้อนด้วยตนเองเพื่อสร้างโปรไฟล์ข้อมูล (เช่น COUNT DISTINCT, AVG, MIN, MAX สำหรับทุกคอลัมน์)
2. วิเคราะห์สเปรดชีตผลลัพธ์อย่างละเอียด
3. เขียนไฟล์กฎ YAML ทุกบรรทัดตั้งแต่ต้น ซึ่งเป็นงานที่น่าเบื่อและมีโอกาสเกิดข้อผิดพลาด

AI จะทำให้ขั้นตอนที่ต้องใช้ความพยายามและเสียเวลาเหล่านี้เป็นไปโดยอัตโนมัติ โดยทำหน้าที่เป็นนักวิเคราะห์ที่ทำงานอย่างไม่เหน็ดเหนื่อย ซึ่งจะประมวลผลโปรไฟล์ทางสถิติได้ทันที และจัดทำ "ฉบับร่างแรก" ของนโยบายที่มีโครงสร้างดีและสมบูรณ์ 80%

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

• การใช้บริบททางธุรกิจที่สำคัญ
• ตรวจสอบความถูกต้องของตรรกะของ AI
• การตัดสินใจเชิงกลยุทธ์เกี่ยวกับกฎที่สำคัญอย่างแท้จริง

ในการเป็นพาร์ทเนอร์ครั้งนี้ AI จะจัดการ "อะไร" (รูปแบบทางสถิติคืออะไร) เพื่อให้มนุษย์มีเวลาไปโฟกัสที่ "ทำไม" (ทำไมรูปแบบนี้จึงสำคัญต่อธุรกิจของเรา) และ "แล้วไง" (แล้วนโยบายของเราควรเป็นอย่างไร) ดังนั้น AI จึงไม่ได้มาแทนที่ลูป แต่จะช่วยให้แต่ละรอบในลูปเร็วขึ้น ชาญฉลาดขึ้น และมีประสิทธิภาพมากขึ้น

6. การทำความสะอาดสภาพแวดล้อม

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

ลบการสแกน Dataplex

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

# 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:dataplex_dq_codelab

7. ยินดีด้วย

คุณทำ Codelab เสร็จเรียบร้อยแล้ว

คุณได้สร้างเวิร์กโฟลว์การกำกับดูแลข้อมูลแบบเป็นโปรแกรมตั้งแต่ต้นจนจบแล้ว คุณเริ่มต้นด้วยการใช้มุมมองที่แสดงข้อมูลจริงเพื่อทำให้ข้อมูล BigQuery ที่ซับซ้อนแบนราบ ซึ่งทำให้เหมาะสําหรับการวิเคราะห์ จากนั้นคุณจึงเรียกใช้การสแกนโปรไฟล์ Dataplex โดยอัตโนมัติเพื่อสร้างข้อมูลเมตาเชิงสถิติ ที่สำคัญที่สุดคือคุณใช้ประโยชน์จาก Gemini CLI เพื่อวิเคราะห์เอาต์พุตโปรไฟล์และสร้างอาร์ติแฟกต์ "นโยบายเป็นโค้ด" (dq_rules.yaml) อย่างชาญฉลาด จากนั้นคุณใช้ CLI เพื่อติดตั้งใช้งานการกำหนดค่านี้เป็นการสแกนคุณภาพของข้อมูลอัตโนมัติ ซึ่งเป็นการปิดลูปในกลยุทธ์การกำกับดูแลที่ทันสมัยและปรับขนาดได้

ตอนนี้คุณพร้อมที่จะใช้รูปแบบพื้นฐานในการสร้างระบบคุณภาพข้อมูลที่เชื่อถือได้ เร่งด้วย AI และได้รับการตรวจสอบจากมนุษย์ใน Google Cloud แล้ว

ขั้นตอนถัดไป

• ผสานรวมกับ CI/CD: นำไฟล์ dq_rules.yaml ไปคอมมิตในที่เก็บ Git สร้างไปป์ไลน์ CI/CD (เช่น ใช้ Cloud Build หรือ GitHub Actions) ที่จะทําให้การสแกน Dataplex ใช้งานได้โดยอัตโนมัติทุกครั้งที่มีการอัปเดตไฟล์กฎ
• สำรวจกฎ SQL ที่กำหนดเอง: ก้าวข้ามประเภทกฎมาตรฐาน Dataplex รองรับกฎ SQL ที่กำหนดเองเพื่อบังคับใช้ตรรกะที่ซับซ้อนยิ่งขึ้นและเฉพาะเจาะจงกับธุรกิจซึ่งไม่สามารถแสดงด้วยการตรวจสอบที่กำหนดไว้ล่วงหน้า นี่เป็นฟีเจอร์ที่มีประสิทธิภาพในการปรับแต่งการตรวจสอบให้ตรงกับข้อกำหนดเฉพาะของคุณ
• เพิ่มประสิทธิภาพการสแกนเพื่อประสิทธิภาพและต้นทุน: สำหรับตารางขนาดใหญ่มาก คุณสามารถปรับปรุงประสิทธิภาพและลดต้นทุนได้โดยไม่ต้องสแกนทั้งชุดข้อมูลเสมอไป ลองใช้ตัวกรองเพื่อจำกัดการสแกนให้แคบลงตามกรอบเวลาหรือกลุ่มข้อมูลที่เฉพาะเจาะจง หรือกำหนดค่าการสแกนแบบสุ่มตัวอย่างเพื่อตรวจสอบเปอร์เซ็นต์ที่เป็นตัวแทนของข้อมูล
• แสดงผลลัพธ์เป็นภาพ: ระบบจะเขียนเอาต์พุตของการสแกนคุณภาพข้อมูล Dataplex ทุกครั้งไปยังตาราง BigQuery เชื่อมต่อตารางนี้กับ Looker Studio เพื่อสร้างแดชบอร์ดที่ติดตามคะแนนคุณภาพของข้อมูลเมื่อเวลาผ่านไป โดยรวมตามมิติข้อมูลที่คุณกําหนด (เช่น ความสมบูรณ์ ความถูกต้อง) ซึ่งจะช่วยให้การตรวจสอบเป็นไปอย่างเชิงรุกและผู้มีส่วนเกี่ยวข้องทุกฝ่ายมองเห็นได้
• แชร์แนวทางปฏิบัติแนะนำ: สนับสนุนการแชร์ความรู้ภายในองค์กรเพื่อใช้ประโยชน์จากประสบการณ์ร่วมกันและปรับปรุงกลยุทธ์คุณภาพของข้อมูล การส่งเสริมวัฒนธรรมความน่าเชื่อถือของข้อมูลเป็นกุญแจสำคัญในการใช้ความพยายามด้านการกำกับดูแลให้เกิดประโยชน์สูงสุด
• อ่านเอกสารประกอบ
  • เอกสารอย่างเป็นทางการเกี่ยวกับคุณภาพของข้อมูล Dataplex
  • Gemini CLI: ตัวแทน AI แบบโอเพนซอร์สของคุณ
  • ตัวอย่างโค้ดใน GitHub