Knowledge Catalog और जनरेटिव एआई की मदद से, प्रोग्राम के हिसाब से अपने-आप डेटा की क्वालिटी तय करना

1. परिचय

इस कोडलैब में, डेटा प्रैक्टिशनर के लिए तकनीकी ब्लूप्रिंट दिया गया है. इसमें डेटा गवर्नेंस के लिए "कोड-फ़र्स्ट" अप्रोच के बारे में बताया गया है. साथ ही, यह दिखाया गया है कि डेवलपमेंट लाइफ़साइकल में सीधे तौर पर अच्छी क्वालिटी और मेटाडेटा मैनेजमेंट को कैसे एम्बेड किया जाए. नॉलेज कैटलॉग एक इंटेलिजेंट डेटा फ़ैब्रिक के तौर पर काम करता है. इससे संगठन, अपने पूरे डेटा को एक ही जगह से मैनेज, मॉनिटर, और कंट्रोल कर सकते हैं. इसमें डेटा लेक से लेकर वेयरहाउस तक का डेटा शामिल होता है.

इस कोडलैब में बताया गया है कि Knowledge Catalog, BigQuery, और Antigravity CLI का इस्तेमाल करके, जटिल डेटा को कैसे फ़्लैट किया जा सकता है. साथ ही, इसे प्रोग्राम के हिसाब से प्रोफ़ाइल किया जा सकता है, डेटा क्वालिटी के नियमों के बारे में स्मार्ट सुझाव जनरेट किए जा सकते हैं, और क्वालिटी स्कैन को अपने-आप डिप्लॉय किया जा सकता है. इसका मुख्य मकसद, मैन्युअल और यूज़र इंटरफ़ेस (यूआई) पर आधारित प्रोसेस को बंद करना है. इनमें गड़बड़ी होने की आशंका होती है और इन्हें स्केल करना मुश्किल होता है. इसके बजाय, एक मज़बूत "नीति के तौर पर कोड" फ़्रेमवर्क बनाना है, जिसे वर्शन के हिसाब से कंट्रोल किया जा सकता है.

आपको क्या सीखने को मिलेगा

• पूरी प्रोफ़ाइलिंग की सुविधा चालू करने के लिए, मटीरियलाइज़्ड व्यू का इस्तेमाल करके, BigQuery के नेस्ट किए गए डेटा को फ़्लैट करने का तरीका.
• Knowledge Catalog की Python क्लाइंट लाइब्रेरी का इस्तेमाल करके, प्रोग्राम के हिसाब से Knowledge Catalog की प्रोफ़ाइल स्कैन करने की सुविधा को ट्रिगर और मैनेज करने का तरीका.
• प्रोफ़ाइल का डेटा एक्सपोर्ट करने और उसे जनरेटिव एआई मॉडल के इनपुट के तौर पर इस्तेमाल करने का तरीका.
• Antigravity CLI के लिए, प्रोफ़ाइल डेटा का विश्लेषण करने और Knowledge Catalog के मुताबिक YAML फ़ाइल बनाने के लिए, प्रॉम्प्ट कैसे तैयार करें.
• एआई से जनरेट किए गए कॉन्फ़िगरेशन की पुष्टि करने के लिए, इंटरैक्टिव और ह्यूमन-इन-द-लूप (एचआईटीएल) प्रोसेस की अहमियत.
• जनरेट किए गए नियमों को, डेटा क्वालिटी की अपने-आप होने वाली स्कैनिंग के तौर पर कैसे डिप्लॉय करें.

आपको किन चीज़ों की ज़रूरत होगी

• Google Cloud खाता और Google Cloud प्रोजेक्ट
• कोई वेब ब्राउज़र, जैसे कि Chrome

मुख्य सिद्धांत: नॉलेज कैटलॉग में डेटा क्वालिटी के मुख्य आधार

डेटा क्वालिटी को बेहतर बनाने के लिए, नॉलेज कैटलॉग के मुख्य कॉम्पोनेंट को समझना ज़रूरी है.

• डेटा प्रोफ़ाइल स्कैन: यह Knowledge Catalog की एक ऐसी जॉब है जो डेटा का विश्लेषण करती है. साथ ही, आंकड़ों वाला मेटाडेटा जनरेट करती है. इसमें शून्य प्रतिशत, अलग-अलग वैल्यू की संख्या, और वैल्यू डिस्ट्रिब्यूशन शामिल हैं. यह प्रोग्राम के हिसाब से "खोज" का चरण होता है.
• डेटा क्वालिटी के नियम: ये ऐसे स्टेटमेंट होते हैं जिनमें उन शर्तों के बारे में बताया जाता है जिन्हें आपके डेटा को पूरा करना होता है. जैसे, NonNullExpectation, SetExpectation, RangeExpectation.
• नियमों के सुझाव के लिए जनरेटिव एआई: डेटा प्रोफ़ाइल का विश्लेषण करने और डेटा क्वालिटी से जुड़े काम के नियमों के सुझाव देने के लिए, लार्ज लैंग्वेज मॉडल (जैसे कि Gemini) का इस्तेमाल किया जाता है. इससे, क्वालिटी फ़्रेमवर्क की बुनियादी बातों को तय करने की प्रोसेस तेज़ हो जाती है.
• डेटा क्वालिटी स्कैन: यह Knowledge Catalog की एक ऐसी जॉब है जो पहले से तय किए गए या कस्टम नियमों के सेट के हिसाब से डेटा की पुष्टि करती है.
• प्रोग्राम के हिसाब से तय किए गए नियम: इसमें, क्वालिटी के नियमों जैसे गवर्नेंस कंट्रोल को कोड के तौर पर मैनेज करने पर फ़ोकस किया जाता है. जैसे, YAML फ़ाइलों और Python स्क्रिप्ट में. इससे ऑटोमेशन, वर्शनिंग, और सीआई/सीडी पाइपलाइन में इंटिग्रेशन की सुविधा मिलती है.
• ह्यूमन-इन-द-लूप (एचआईटीएल): यह ऑटोमेटेड वर्कफ़्लो में इंसानी विशेषज्ञता और निगरानी को इंटिग्रेट करने का अहम कंट्रोल पॉइंट है. एआई से जनरेट किए गए कॉन्फ़िगरेशन के लिए, एचआईटीएल ज़रूरी है. इससे यह पुष्टि की जा सकती है कि सुझाव सही हैं, कारोबार के लिए काम के हैं, और सुरक्षित हैं. इसके बाद ही, उन्हें लागू किया जा सकता है.

2. सेटअप और ज़रूरी शर्तें

Cloud Shell शुरू करना

Google Cloud को अपने लैपटॉप से रिमोटली ऐक्सेस किया जा सकता है. हालांकि, इस कोडलैब में Google Cloud Shell का इस्तेमाल किया जाएगा. यह क्लाउड में चलने वाला कमांड लाइन एनवायरमेंट है.

Google Cloud Console में, सबसे ऊपर दाएं कोने में मौजूद टूलबार पर, Cloud Shell आइकॉन पर क्लिक करें:

इसे चालू करने और एनवायरमेंट से कनेक्ट करने में सिर्फ़ कुछ सेकंड लगेंगे. यह प्रोसेस पूरी होने के बाद, आपको कुछ ऐसा दिखेगा:

इस वर्चुअल मशीन में, डेवलपमेंट के लिए ज़रूरी सभी टूल पहले से मौजूद हैं. यह 5 जीबी की होम डायरेक्ट्री उपलब्ध कराता है. साथ ही, Google Cloud पर काम करता है. इससे नेटवर्क की परफ़ॉर्मेंस और पुष्टि करने की प्रोसेस बेहतर होती है. इस कोडलैब में मौजूद सभी टास्क, ब्राउज़र में किए जा सकते हैं. आपको कुछ भी इंस्टॉल करने की ज़रूरत नहीं है.

ज़रूरी एपीआई चालू करना और एनवायरमेंट कॉन्फ़िगर करना

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

डेटा का नमूना तैयार करना

इस कोडलैब के लिए, आपको एक सार्वजनिक डेटासेट का इस्तेमाल करना होगा. इसमें Google मर्चंडाइज़ स्टोर का अस्पष्ट ई-कॉमर्स डेटा शामिल होता है. सार्वजनिक डेटासेट सिर्फ़ पढ़ने के लिए होते हैं. इसलिए, आपको अपने डेटासेट में बदलाव करने के लिए, उनकी कॉपी बनानी होगी. नीचे दिया गया bq कमांड, आपके kc_dq_codelab डेटासेट में एक नई टेबल, ga4_transactions बनाता है. यह एक दिन (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 रिपॉज़िटरी को क्लोन करना होगा. इसमें इस कोडलैब के लिए ज़रूरी फ़ोल्डर स्ट्रक्चर और साथ में काम करने वाली फ़ाइलें शामिल हैं.

# 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 में डेटा की प्रोफ़ाइलिंग की सुविधा, आपके डेटा के बारे में आंकड़ों से जुड़ी जानकारी अपने-आप ढूंढने का एक बेहतरीन टूल है. जैसे, शून्य प्रतिशत, यूनीकनेस, और वैल्यू डिस्ट्रिब्यूशन. यह प्रोसेस, आपके डेटा के स्ट्रक्चर और क्वालिटी को समझने के लिए ज़रूरी है. हालांकि, नॉलेज कैटलॉग की प्रोफ़ाइलिंग की एक जानी-मानी सीमा यह है कि यह किसी टेबल में नेस्ट किए गए या दोहराए गए फ़ील्ड (जैसे, RECORD या ARRAY टाइप) की पूरी तरह से जांच नहीं कर सकता. यह पहचान कर सकता है कि कोई कॉलम कॉम्प्लेक्स टाइप का है. हालांकि, यह नेस्ट किए गए स्ट्रक्चर में मौजूद अलग-अलग फ़ील्ड की प्रोफ़ाइल नहीं बना सकता.

इस समस्या को हल करने के लिए, हम डेटा को खास तौर पर बनाए गए मटीरियलाइज़्ड व्यू में बदल देंगे. इस रणनीति में, हर फ़ील्ड को टॉप-लेवल कॉलम बनाया जाता है. इससे Knowledge Catalog, हर फ़ील्ड की अलग-अलग प्रोफ़ाइल बना पाता है.

नेस्ट किए गए स्कीमा को समझना

सबसे पहले, आइए सोर्स टेबल के स्कीमा की जांच करें. 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 पर जाएं. इसके बाद, अपना kc_dq_codelab डेटासेट ढूंढें, ga4_transactions टेबल चुनें, और स्कीमा टैब पर क्लिक करें.

bq_schema.json फ़ाइल की जांच करने पर, डिवाइस, भौगोलिक जगह, ई-कॉमर्स, और बार-बार रिकॉर्ड किए गए आइटम जैसे जटिल स्ट्रक्चर दिखते हैं. ये ऐसे स्ट्रक्चर हैं जिनकी प्रोफ़ाइलिंग को असरदार बनाने के लिए, उन्हें फ़्लैट करना ज़रूरी है.

मटेरियलाइज़्ड व्यू की मदद से डेटा को फ़्लैट करना

नेस्ट किए गए डेटा की इस समस्या को हल करने के लिए, मेटेरियलाइज़्ड व्यू (एमवी) बनाना सबसे असरदार और व्यावहारिक तरीका है. एमवी, फ़्लैट किए गए नतीजों की पहले से गणना करके रखते हैं. इससे क्वेरी की परफ़ॉर्मेंस और लागत में काफ़ी फ़ायदा मिलता है. साथ ही, विश्लेषकों और प्रोफ़ाइलिंग टूल के लिए, आसान और रिलेशनल जैसा स्ट्रक्चर उपलब्ध कराया जाता है.

सबसे पहले, आपके दिमाग़ में यह बात आ सकती है कि सभी डेटा को एक ही बड़े व्यू में दिखा दिया जाए. हालांकि, इस आसान तरीके में एक खतरनाक जाल छिपा होता है. इससे डेटा गंभीर रूप से खराब हो सकता है. आइए, जानते हैं कि यह एक गंभीर गलती क्यों है.

💡 कार्टीज़न प्रॉडक्ट ट्रैप: फ़्लैट किए गए एक व्यू से काम क्यों नहीं चलता

एक साथ कई ऐरे को अननेस्ट करके टेबल को फ़्लैट करने से, कार्टेशियन प्रॉडक्ट (क्रॉस जॉइन) बनता है. यह एक गंभीर गड़बड़ी है. इससे न सिर्फ़ क्वेरी की प्रोसेस धीमी हो जाती है, बल्कि आपका डेटा भी खराब हो जाता है.

उदाहरण के लिए, तीन आइटम और पांच पैरामीटर वाले एक इवेंट से 15 लाइनें बन जाएंगी. इससे इवेंट-लेवल की किसी भी मेट्रिक (जैसे कि रेवेन्यू) को 15 से गुणा किया जाएगा. साथ ही, इवेंट की संख्या का कोई मतलब नहीं रह जाएगा. हर लाइन का मतलब समझ नहीं आता.

सही रणनीति यह है कि अलग-अलग मकसद के लिए कई व्यू बनाए जाएं. हर व्यू में, विश्लेषण के लिए एक ही तरह का डेटा शामिल किया जाए.

इसे अलग-अलग विश्लेषण के लिए, डीनॉर्मलाइज़ की गई GA4 टेबल को "फिर से सामान्य बनाना" माना जा सकता है. यह ठीक वैसा ही है जैसे किसी पारंपरिक डेटाबेस में आपके पास अलग-अलग ऑर्डर और order_items टेबल होती हैं.

इसलिए, इस कोडलैब के लिए, हम इस रणनीति को तीन अलग-अलग मटीरियलाइज़्ड व्यू बनाकर लागू करेंगे:

• सेशन व्यू: हर इवेंट के लिए एक लाइन.
• लेन-देन का व्यू: हर लेन-देन के लिए एक लाइन.
• आइटम व्यू: हर आइटम के लिए एक लाइन.

इस तरीके से, प्रोफ़ाइलिंग और विश्लेषण के लिए डेटा सटीक होता है.

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 जैसे वैरिएबल को आपके शेल एनवायरमेंट से मिली वैल्यू से बदल देगी. इसके बाद, मान्य एसक्यूएल को 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 एनवायरमेंट बनाएं. इससे यह पक्का होता है कि प्रोजेक्ट की डिपेंडेंसी को अलग से मैनेज किया जाता है. इससे आपके Cloud Shell एनवायरमेंट में मौजूद अन्य पैकेज के साथ टकराव नहीं होता.

# Create the virtual environment
python3 -m venv dq_venv

# Activate the environment
source dq_venv/bin/activate

अब, नए चालू किए गए एनवायरमेंट में Knowledge Catalog की क्लाइंट लाइब्रेरी इंस्टॉल करें.

# Install the Knowledge Catalog client library
pip install google-cloud-dataplex

एनवायरमेंट सेट अप करने और लाइब्रेरी इंस्टॉल करने के बाद, ऑर्केस्ट्रेशन स्क्रिप्ट बनाई जा सकती है.

Cloud Shell टूलबार में, एडिटर खोलें पर क्लिक करें. 1_run_scan.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_scan.py

अब स्क्रिप्ट, आपके तीन मेटेरियलाइज़्ड व्यू की प्रोफ़ाइलिंग करेगी. साथ ही, रीयल-टाइम में स्टेटस अपडेट देगी. यह प्रोसेस पूरी होने के बाद, आपको हर व्यू के लिए मशीन के हिसाब से पढ़ी जा सकने वाली एक बेहतर स्टैटिस्टिकल प्रोफ़ाइल मिलेगी. यह हमारे वर्कफ़्लो के अगले चरण के लिए तैयार होगी: एआई की मदद से डेटा क्वालिटी के नियम जनरेट करना.

Google Cloud Console में जाकर, पूरी हो चुकी प्रोफ़ाइल स्कैन देखी जा सकती हैं.

1. नेविगेशन मेन्यू में, Govern सेक्शन में जाकर Knowledge Catalog और डेटा की प्रोफ़ाइलिंग और क्वालिटी पर जाएं.
2. आपको अपनी प्रोफ़ाइल के तीन स्कैन दिखेंगे. साथ ही, उनकी मौजूदा स्थिति भी दिखेगी. नतीजों की पूरी जानकारी देखने के लिए, किसी स्कैन पर क्लिक करें.

BigQuery प्रोफ़ाइल से लेकर एआई के लिए तैयार इनपुट तक

Knowledge Catalog की प्रोफ़ाइल स्कैन करने की प्रोसेस पूरी हो गई है. नतीजे, Knowledge Catalog API में उपलब्ध हैं. हालांकि, जनरेटिव एआई मॉडल के लिए इन नतीजों को इनपुट के तौर पर इस्तेमाल करने के लिए, हमें इन्हें स्ट्रक्चर्ड फ़ॉर्मैट वाली लोकल फ़ाइल में एक्सट्रैक्ट करना होगा.

नीचे दी गई Python स्क्रिप्ट, 2_dq_profile_save.py, प्रोग्राम के हिसाब से हमारे mv_ga4_user_session_flat व्यू के लिए, प्रोफ़ाइल स्कैन करने का सबसे नया और सफल जॉब ढूंढती है. इसके बाद, यह पूरी और ज़्यादा जानकारी वाली प्रोफ़ाइल का नतीजा वापस लाता है और इसे dq_profile_results.json नाम की लोकल JSON फ़ाइल के तौर पर सेव करता है. अगले चरण में, इस फ़ाइल का इस्तेमाल सीधे तौर पर एआई विश्लेषण के लिए किया जाएगा.

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 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) का इस्तेमाल किया जा सकता है. कॉम्प्लेक्स डेटासेट के लिए, डेटा क्वालिटी की खास जानकारी को मैन्युअल तरीके से लिखने में समय लगता है और इसमें गड़बड़ियां होने की आशंका भी होती है. अपने टर्मिनल में जनरेटिव एआई एजेंट का इस्तेमाल करने से, इस वर्कफ़्लो को तेज़ी से पूरा किया जा सकता है. यह कुछ ही सेकंड में, शुरुआती डिक्लेरेटिव कॉन्फ़िगरेशन का ड्राफ़्ट तैयार कर देता है. इससे डेटा टीमें, मैन्युअल सिंटैक्स ड्राफ़्टिंग से हटकर, कारोबार के हिसाब से ह्यूमन-इन-द-लूप (एचआईटीएल) की निगरानी पर फ़ोकस कर सकती हैं.

Antigravity CLI शुरू करने के लिए, अपने टर्मिनल में यह कमांड चलाएं:

agy

अब आपके पास क्वालिटी के नियम जनरेट करने का विकल्प है. सीएलआई, आपकी मौजूदा डायरेक्ट्री में मौजूद फ़ाइलें पढ़ सकता है. इसलिए, यह सीधे तौर पर आपकी नई प्रोफ़ाइल के स्कैन किए गए डेटा का इस्तेमाल कर सकता है.

एजेंट को प्लान बनाने के लिए निर्देश देना

सबसे पहले, हम 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.

एजेंट, 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']
   ...             │ ...                │ ...                        │ ...

डेटा क्वालिटी के नियम जनरेट करना

यह पूरे वर्कफ़्लो का सबसे अहम चरण है: ह्यूमन-इन-द-लूप (एचआईटीएल) समीक्षा. एजेंट ने जो प्लान जनरेट किया है वह पूरी तरह से डेटा में मौजूद आंकड़ों के पैटर्न पर आधारित है. इसे आपके कारोबार के कॉन्टेक्स्ट, डेटा में होने वाले बदलावों या डेटा के पीछे के खास मकसद के बारे में कोई जानकारी नहीं होती. एक विशेषज्ञ के तौर पर, आपकी भूमिका इस प्लान की पुष्टि करने, इसे ठीक करने, और इसे कोड में बदलने से पहले इसकी पुष्टि करने की है.

एजेंट से मिले प्लान को ध्यान से पढ़ें.

• क्या यह समझ में आया?
• क्या यह आपके कारोबार की जानकारी के मुताबिक है?
• क्या ऐसे कोई नियम हैं जो आंकड़ों के हिसाब से सही हैं, लेकिन असल में काम के नहीं हैं?

आपको एजेंट से मिलने वाला आउटपुट अलग-अलग हो सकता है. आपका लक्ष्य इसे बेहतर बनाना है. उदाहरण के लिए, मान लें कि प्लान में rowCount नियम का सुझाव दिया गया है, क्योंकि टेबल में सैंपल डेटा में पंक्तियों की संख्या तय है. एक विशेषज्ञ के तौर पर, आपको पता होगा कि इस टेबल का साइज़ हर दिन बढ़ता है. इसलिए, लाइनों की संख्या से जुड़ा नियम लागू करना सही नहीं है. इससे गलत सूचनाएं मिलने की संभावना भी बढ़ जाती है. यह कारोबार के संदर्भ को लागू करने का एक बेहतरीन उदाहरण है, जो एआई के पास नहीं है.

अब आपको एजेंट को सुझाव/राय देनी होगी और कोड जनरेट करने के लिए आखिरी निर्देश देना होगा. आपको इस प्रॉम्प्ट में, मिले हुए प्लान और उसमें किए जाने वाले बदलावों के हिसाब से बदलाव करना होगा.

नीचे दिया गया प्रॉम्प्ट एक टेंप्लेट है. पहली लाइन में, आपको खास सुधारों के बारे में बताना होगा. अगर एजेंट ने आपको सही प्लान दिया है और उसमें कोई बदलाव नहीं करना है, तो उस लाइन को मिटाया जा सकता है.

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.

अब एजेंट, आपके सटीक और पुष्टि किए गए निर्देशों के आधार पर YAML कॉन्टेंट जनरेट करेगा. प्रोसेस पूरी होने के बाद, आपको अपनी वर्किंग डायरेक्ट्री में dq_rules.yaml नाम की एक नई फ़ाइल दिखेगी.

डेटा क्वालिटी स्कैन बनाना और उसे चलाना

अब आपके पास एजेंट से जनरेट की गई और व्यक्ति से पुष्टि की गई dq_rules.yaml फ़ाइल है. इसलिए, अब इसे आसानी से डिप्लॉय किया जा सकता है.

/quit टाइप करके या Ctrl+C को दो बार दबाकर, Antigravity CLI से बाहर निकलें.

नीचे दिए गए gcloud कमांड से, Knowledge Catalog का नया डेटा स्कैन संसाधन बनाया जाता है. यह फ़िलहाल स्कैन नहीं करता है. यह सिर्फ़ स्कैन की परिभाषा और कॉन्फ़िगरेशन (हमारी YAML फ़ाइल) को Knowledge Catalog में रजिस्टर करता है.

अपने टर्मिनल में यह कमांड चलाएं:

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 Console के नॉलेज कैटलॉग सेक्शन में जाकर, इस जॉब का स्टेटस देखा जा सकता है. यह प्रोसेस पूरी होने के बाद, नतीजों को विश्लेषण के लिए BigQuery टेबल में लिखा जाएगा.

5. ह्यूमन-इन-द-लूप (एचआईटीएल) की अहम भूमिका

नियम जनरेट करने की प्रोसेस को तेज़ करने के लिए Antigravity एजेंट का इस्तेमाल करना बहुत फ़ायदेमंद है. हालांकि, यह ज़रूरी है कि एआई को एक कुशल को-पायलट के तौर पर इस्तेमाल किया जाए, न कि पूरी तरह से स्वायत्त पायलट के तौर पर. ह्यूमन-इन-द-लूप (एचआईटीएल) प्रोसेस, सुझाव के तौर पर नहीं दी जाती है. यह डेटा को मैनेज करने के किसी भी वर्कफ़्लो का एक बुनियादी चरण है, जिसे अनदेखा नहीं किया जा सकता. सिर्फ़ एआई से जनरेट किए गए आर्टफ़ैक्ट को बिना किसी मानवीय निगरानी के डिप्लॉय करना, एक तरह से असफलता को न्योता देना है.

एआई से जनरेट किए गए dq_rules.yaml को ऐसे पुल अनुरोध के तौर पर देखें जिसे बहुत तेज़ी से काम करने वाले, लेकिन अनुभवहीन एआई डेवलपर ने सबमिट किया है. इसे आपकी शासन से जुड़ी नीति की "मुख्य शाखा" में मर्ज करने और लागू करने से पहले, किसी वरिष्ठ विशेषज्ञ (आप) से इसकी पूरी समीक्षा करानी होगी. यह समीक्षा, लार्ज लैंग्वेज मॉडल की कमियों को दूर करने के लिए ज़रूरी है.

यहां इस बारे में ज़्यादा जानकारी दी गई है कि मैन्युअल तरीके से समीक्षा करना क्यों ज़रूरी है और आपको किन बातों का खास तौर पर ध्यान रखना चाहिए:

1. संदर्भ के हिसाब से पुष्टि करना: AI को कारोबार के बारे में जानकारी नहीं है

• एलएलएम की कमज़ोरी: एलएलएम, पैटर्न और आंकड़ों का मास्टर होता है. हालांकि, इसे आपके कारोबार के बारे में कोई जानकारी नहीं होती. उदाहरण के लिए, अगर किसी कॉलम new_campaign_id में 98% वैल्यू मौजूद नहीं हैं, तो एलएलएम इस कॉलम को आंकड़ों से जुड़ी वजहों से अनदेखा कर सकता है.
• इंसान की अहम भूमिका: आप एक विशेषज्ञ हैं. आपको पता है कि अगले हफ़्ते किसी बड़े प्रॉडक्ट को लॉन्च किया जाना है. इसलिए, new_campaign_id फ़ील्ड को कल ही जोड़ा गया है. आपको पता है कि अब इसका नल अनुपात ज़्यादा होना चाहिए, लेकिन इसमें काफ़ी गिरावट आने की उम्मीद है. आपको यह भी पता है कि डेटा अपने-आप भरने के बाद, उसे एक खास फ़ॉर्मैट में होना चाहिए. एआई, कारोबार के बारे में इस बाहरी जानकारी का अनुमान नहीं लगा सकता. आपकी भूमिका, कारोबार के इस कॉन्टेक्स्ट को एआई के आंकड़ों से जुड़े सुझावों पर लागू करना है. साथ ही, ज़रूरत के हिसाब से उन्हें बदलना या बढ़ाना है.

2. सही और सटीक जानकारी: बनावटी तथ्यों और छोटी-छोटी गलतियों से बचना

• एलएलएम की कमज़ोरी: एलएलएम "आत्मविश्वास के साथ गलत जवाब दे सकते हैं." ये "हैलुसिनेट" कर सकते हैं. इसका मतलब है कि ये ऐसी जानकारी दे सकते हैं जो असल में मौजूद नहीं है. इसके अलावा, ये ऐसा कोड जनरेट कर सकते हैं जो थोड़ा-बहुत गलत हो. उदाहरण के लिए, यह सही नाम वाले नियम के साथ कोई YAML फ़ाइल जनरेट कर सकता है, लेकिन उसमें अमान्य पैरामीटर हो सकता है. इसके अलावा, यह नियम के टाइप को गलत तरीके से लिख सकता है. जैसे, सही setExpectation के बजाय setExpectations. इन छोटी-मोटी गड़बड़ियों की वजह से, डिप्लॉयमेंट पूरा नहीं हो पाएगा. हालांकि, इनका पता लगाना मुश्किल हो सकता है.
• इंसान की अहम भूमिका: आपको लिंटर और स्कीमा की पुष्टि करने वाले के तौर पर काम करना है. आपको जनरेट किए गए YAML की जांच, Knowledge Catalog DataQualityRule की आधिकारिक खास जानकारी के हिसाब से करनी होगी. आपको सिर्फ़ यह नहीं देखना है कि यह "सही दिख रहा है". आपको इसके सिंटैक्टिक और सिमैंटिक सही होने की पुष्टि करनी है, ताकि यह पक्का किया जा सके कि यह टारगेट एपीआई के साथ 100% काम करता है. इसलिए, कोडलैब एजेंट को स्कीमा फ़ाइलों का रेफ़रंस देने के लिए कहता है, ताकि गड़बड़ी की संभावना कम हो. हालांकि, पुष्टि करने का फ़ैसला आपके पास होता है.

3. सुरक्षा और जोखिम कम करना: डाउनस्ट्रीम के नतीजों को रोकना

• एलएलएम की कमज़ोरी: प्रोडक्शन में लागू किए गए डेटा क्वालिटी के गलत नियम के गंभीर नतीजे हो सकते हैं. अगर एआई, वित्तीय लेन-देन की रकम के लिए बहुत बड़ी rangeExpectation का सुझाव देता है, तो हो सकता है कि वह धोखाधड़ी वाली गतिविधि का पता न लगा पाए. इसके उलट, अगर यह छोटे डेटा सैंपल के आधार पर बहुत सख्त नियम का सुझाव देता है, तो इससे आपकी ऑन-कॉल टीम को हज़ारों फ़ॉल्स-पॉज़िटिव सूचनाएं मिल सकती हैं. इससे सूचनाओं की वजह से टीम का ध्यान भटक सकता है और असली समस्याएं छूट सकती हैं.
• इंसान की अहम भूमिका: आप एक सुरक्षा इंजीनियर हैं. एआई से मिले हर नियम के संभावित असर का आकलन करना ज़रूरी है. खुद से पूछें: "अगर यह नियम लागू नहीं होता है, तो क्या होगा? क्या सूचना के आधार पर कार्रवाई की जा सकती है? अगर यह नियम गलत तरीके से पास हो जाता है, तो क्या जोखिम है?" जोखिम का आकलन करने की क्षमता सिर्फ़ इंसानों में होती है. इसमें, जांच के फ़ायदे के मुकाबले गड़बड़ी होने की लागत का आकलन किया जाता है.

4. गवर्नेंस एक लगातार चलने वाली प्रोसेस है: इसमें आगे की सोच के साथ काम करने से जुड़ी जानकारी शामिल करना

• एलएलएम की कमज़ोरी: एआई की जानकारी, डेटा के स्टैटिक स्नैपशॉट पर आधारित होती है. प्रोफ़ाइल के नतीजे, किसी खास समय के हिसाब से मिलते हैं. इसके पास आने वाले समय में होने वाले इवेंट की जानकारी नहीं है.
• मानव की अहम भूमिका: आपकी गवर्नेंस रणनीति, आने वाले समय को ध्यान में रखकर बनाई जानी चाहिए. आपको पता है कि अगले महीने डेटा सोर्स माइग्रेट किया जाना है. इससे stream_id बदल जाएगा. आपको पता है कि geo_country सूची में एक नया देश जोड़ा जा रहा है. एचआईटीएल प्रोसेस में, आने वाले समय में होने वाले बदलावों के बारे में जानकारी दी जाती है. साथ ही, कारोबार या तकनीकी बदलावों के दौरान होने वाली समस्याओं को रोकने के लिए, नियमों को अपडेट किया जाता है या उन्हें कुछ समय के लिए बंद कर दिया जाता है. डेटा क्वालिटी को एक बार सेट अप नहीं किया जा सकता. यह एक ऐसी प्रोसेस है जिसमें समय के साथ बदलाव होते रहते हैं. इन बदलावों के बारे में सिर्फ़ कोई व्यक्ति ही बता सकता है.

संक्षेप में कहें, तो एचआईटीएल, क्वालिटी अश्योरेंस और सुरक्षा का ज़रूरी तरीका है. यह एआई की मदद से किए जाने वाले गवर्नेंस को एक नए, लेकिन जोखिम भरे आइडिया से बदलकर, ज़िम्मेदार, बड़े पैमाने पर इस्तेमाल किया जा सकने वाला, और एंटरप्राइज़-ग्रेड का तरीका बनाता है. इससे यह पक्का होता है कि लागू की गई नीतियां, सिर्फ़ एआई की मदद से नहीं बनाई गई हैं. बल्कि, इंसानों ने भी उनकी पुष्टि की है. इससे मशीनों की तेज़ी के साथ-साथ, इंसानों की विशेषज्ञता और संदर्भ का इस्तेमाल किया जा सकता है.

हालांकि, इंसानों की निगरानी पर ज़ोर देने से, एआई की अहमियत कम नहीं होती. इसके उलट, जनरेटिव एआई, एचआईटीएल प्रोसेस को तेज़ करने में अहम भूमिका निभाता है.

एआई के बिना, डेटा इंजीनियर को ये काम करने होंगे:

1. डेटा की प्रोफ़ाइल बनाने के लिए, मैन्युअल तरीके से मुश्किल एसक्यूएल क्वेरी लिखें. उदाहरण के लिए, हर कॉलम के लिए COUNT DISTINCT, AVG, MIN, MAX.
2. नतीजों की स्प्रेडशीट का बारीकी से विश्लेषण करें.
3. YAML फ़ाइल की हर लाइन को शुरू से लिखना, जो एक मुश्किल और गड़बड़ी वाला काम है.

एआई, इन मुश्किल और समय लेने वाले चरणों को अपने-आप पूरा कर देता है. यह एक ऐसे विश्लेषक के तौर पर काम करता है जो बिना थके काम करता है. यह तुरंत आंकड़ों वाली प्रोफ़ाइल को प्रोसेस करता है और नीति का "पहला ड्राफ़्ट" उपलब्ध कराता है. यह ड्राफ़्ट, अच्छी तरह से व्यवस्थित होता है और इसमें 80% जानकारी शामिल होती है.

इससे, इंसान के काम करने के तरीके में बुनियादी बदलाव होता है. मैन्युअल तरीके से डेटा प्रोसेस करने और बार-बार इस्तेमाल होने वाले कोड लिखने में घंटों बिताने के बजाय, विशेषज्ञ तुरंत सबसे ज़रूरी कामों पर फ़ोकस कर सकता है:

• कारोबार के बारे में अहम जानकारी लागू करना.
• एआई के लॉजिक के सही होने की पुष्टि करना.
• यह तय करना कि कौनसे नियम वाकई ज़रूरी हैं.

इस पार्टनरशिप में, एआई "क्या" (आंकड़ों के पैटर्न क्या हैं?) को हैंडल करता है. इससे इंसान को "क्यों" (यह पैटर्न हमारे कारोबार के लिए क्यों ज़रूरी है?) और "तो क्या" (तो हमारी नीति क्या होनी चाहिए?) पर फ़ोकस करने का समय मिल जाता है. इसलिए, एआई लूप को नहीं बदलता. यह लूप के हर साइकल को ज़्यादा तेज़, स्मार्ट, और असरदार बनाता है.

6. अपने एनवायरमेंट को क्लीन अप करना

इस कोडलैब में इस्तेमाल किए गए संसाधनों के लिए, अपने Google Cloud खाते से आने वाले समय में शुल्क न लिए जाने से बचने के लिए, आपको उन संसाधनों वाला प्रोजेक्ट मिटा देना चाहिए. हालांकि, अगर आपको प्रोजेक्ट रखना है, तो बनाए गए अलग-अलग संसाधनों को मिटाया जा सकता है.

नॉलेज कैटलॉग के स्कैन मिटाएं

सबसे पहले, बनाई गई प्रोफ़ाइल और क्वालिटी स्कैन मिटाएं. गलती से अहम संसाधनों को मिटाने से रोकने के लिए, इन कमांड में इस कोडलैब में बनाई गई स्कैन की खास जानकारी का इस्तेमाल किया जाता है.

# 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 (force) फ़्लैग का इस्तेमाल करके, बिना पुष्टि किए डेटासेट और उसकी सभी टेबल हटा देती है.

⚠️ चेतावनी: अनजाने में डेटा का नुकसान होने से बचने के लिए, हमारा सुझाव है कि आप कॉपी और चिपकाने के बजाय, यहां दिया गया कमांड मैन्युअल तरीके से टाइप करें. साथ ही, यह पक्का करें कि डेटासेट का नाम सही हो.

# Manually type this command to confirm you are deleting the correct dataset
bq rm -r -f --dataset $PROJECT_ID:kc_dq_codelab

7. बधाई हो!

आपने कोडलैब पूरा कर लिया है!

आपने डेटा को मैनेज करने का एंड-टू-एंड, प्रोग्राम के हिसाब से वर्कफ़्लो बनाया हो. आपने सबसे पहले, BigQuery के जटिल डेटा को आसान बनाने के लिए, मटीरियलाइज़्ड व्यू का इस्तेमाल किया. इससे डेटा का विश्लेषण करना आसान हो गया. इसके बाद, आपने प्रोग्राम के हिसाब से नॉलेज कैटलॉग की प्रोफ़ाइल स्कैन कीं, ताकि आंकड़ों वाला मेटाडेटा जनरेट किया जा सके. सबसे अहम बात यह है कि आपने Antigravity CLI का इस्तेमाल करके, प्रोफ़ाइल के आउटपुट का विश्लेषण किया. साथ ही, "नीति के तौर पर कोड" आर्टफ़ैक्ट (dq_rules.yaml) को समझदारी से जनरेट किया. इसके बाद, आपने CLI का इस्तेमाल करके इस कॉन्फ़िगरेशन को, डेटा क्वालिटी स्कैन के तौर पर डिप्लॉय किया. इससे, आधुनिक और बड़े पैमाने पर लागू की जा सकने वाली गवर्नेंस रणनीति को पूरा किया जा सका.

अब आपके पास Google Cloud पर, भरोसेमंद, एआई की मदद से बेहतर बनाए गए, और इंसानों से पुष्टि किए गए डेटा क्वालिटी सिस्टम बनाने का बुनियादी पैटर्न है.

आगे क्या करना है?

• CI/CD के साथ इंटिग्रेट करें: dq_rules.yaml फ़ाइल लें और उसे Git रिपॉज़िटरी में सेव करें. एक सीआई/सीडी पाइपलाइन बनाएं.जैसे, Cloud Build या GitHub Actions का इस्तेमाल करके. यह पाइपलाइन, नियम फ़ाइल के अपडेट होने पर, नॉलेज कैटलॉग स्कैन को अपने-आप डिप्लॉय करती है.
• कस्टम एसक्यूएल नियमों के बारे में जानें: स्टैंडर्ड नियमों के टाइप से आगे बढ़ें. नॉलेज कैटलॉग में कस्टम एसक्यूएल नियमों का इस्तेमाल किया जा सकता है. इससे कारोबार की ज़रूरतों के हिसाब से ज़्यादा जटिल लॉजिक लागू किया जा सकता है. इस लॉजिक को पहले से तय की गई जांचों के ज़रिए नहीं दिखाया जा सकता. यह सुविधा, पुष्टि करने की प्रोसेस को अपनी ज़रूरतों के हिसाब से बनाने के लिए है.
• स्कैन को ज़्यादा असरदार और किफ़ायती बनाएं: बहुत बड़ी टेबल के लिए, परफ़ॉर्मेंस को बेहतर बनाया जा सकता है और लागत को कम किया जा सकता है. इसके लिए, पूरे डेटासेट को हमेशा स्कैन न करें. फ़िल्टर का इस्तेमाल करके, स्कैन को किसी खास समयावधि या डेटा सेगमेंट तक सीमित करें. इसके अलावा, अपने डेटा के कुछ हिस्से की जांच करने के लिए, सैंपल किए गए स्कैन कॉन्फ़िगर करें.
• नतीजों को विज़ुअलाइज़ करना: Knowledge Catalog में डेटा क्वालिटी के हर स्कैन का आउटपुट, BigQuery टेबल में लिखा जाता है. इस टेबल को Looker Studio से कनेक्ट करें, ताकि ऐसे डैशबोर्ड बनाए जा सकें जो समय के साथ आपके डेटा क्वालिटी स्कोर को ट्रैक करें. इन स्कोर को आपके तय किए गए डाइमेंशन (जैसे, पूरी जानकारी, मान्य) के हिसाब से एग्रीगेट किया जाता है. इससे निगरानी करने की प्रोसेस आसान हो जाती है और सभी स्टेकहोल्डर को इसकी जानकारी मिलती रहती है.
• सबसे सही तरीके शेयर करें: अपने संगठन में जानकारी शेयर करने को बढ़ावा दें, ताकि सामूहिक अनुभव का फ़ायदा उठाया जा सके. साथ ही, डेटा क्वालिटी को बेहतर बनाने की रणनीति को बेहतर बनाया जा सके. डेटा पर भरोसा करने की संस्कृति को बढ़ावा देना, गवर्नेंस से जुड़े प्रयासों का ज़्यादा से ज़्यादा फ़ायदा पाने के लिए ज़रूरी है.
• दस्तावेज़ पढ़ें:
  • Knowledge Catalog में डेटा क्वालिटी से जुड़ा आधिकारिक दस्तावेज़
  • Antigravity CLI के लिए क्विकस्टार्ट गाइड
  • GitHub पर कोड का सैंपल