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

1. परिचय

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

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

ज़रूरी शर्तें

  • Google Cloud Console की बुनियादी जानकारी
  • कमांड लाइन इंटरफ़ेस और Google Cloud Shell की बुनियादी जानकारी

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

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

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

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

मुख्य कॉन्सेप्ट: Dataplex की डेटा क्वालिटी के मुख्य सिद्धांत

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

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

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

Cloud Shell शुरू करें

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

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

55efc1aaa7a4d3ad.png

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

7ffe5cbb04455448.png

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

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

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

3. Dataplex की प्रोफ़ाइलिंग की मदद से, डेटा अपने-आप खोजने की सुविधा

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

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

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

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

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

  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`;
  1. 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;
  1. 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 क्लाइंट की मदद से प्रोफ़ाइल स्कैन करना

अब हमारे पास फ़्लैट किए गए, प्रोफ़ाइल बनाने लायक व्यू हैं. इसलिए, हम प्रोग्राम के हिसाब से हर व्यू के लिए, Dataplex की डेटा प्रोफ़ाइल के स्कैन बना सकते हैं और उन्हें चला सकते हैं. यहां दी गई Python स्क्रिप्ट, इस प्रोसेस को अपने-आप पूरा करने के लिए google-cloud-dataplex क्लाइंट लाइब्रेरी का इस्तेमाल करती है.

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

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

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

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

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

  1. नेविगेशन मेन्यू में, 'गवर्न' सेक्शन में जाकर, Dataplex Universal catalogue और Profile पर जाएं.

5acda859404968c.png

  1. आपको अपनी प्रोफ़ाइल के तीन स्कैन और उनकी नौकरी की मौजूदा स्थिति दिखेगी. नतीजों की पूरी जानकारी देखने के लिए, किसी स्कैन पर क्लिक करें.

8a09dae0ef485289.png

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

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

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

Cloud Shell एडिटर में, 2_dq_profile_save.py नाम की एक नई फ़ाइल बनाएं और उसमें यह कोड चिपकाएं. पिछले चरण की तरह, अगर आपने रिपॉज़िटरी को क्लोन किया है, तो फ़ाइल बनाने की ज़रूरत नहीं है.

import os
import sys
import json
from google.cloud import dataplex_v1
from google.api_core.exceptions import NotFound
from google.protobuf.json_format import MessageToDict

# --- Configuration ---
# The Materialized View to analyze is fixed for this step.
TARGET_VIEW = "mv_ga4_user_session_flat"
OUTPUT_FILENAME = "dq_profile_results.json"


def save_to_json_file(content: dict, filename: str):
    """Saves the given dictionary content to a JSON file."""
    try:
        with open(filename, "w", encoding="utf-8") as f:
            # Use indent=2 for a readable, "pretty-printed" JSON file.
            json.dump(content, f, indent=2, ensure_ascii=False)
        print(f"\n[SUCCESS] Profile results were saved to '{filename}'.")
    except (IOError, TypeError) as e:
        print(f"[ERROR] An error occurred while saving the file: {e}")


def get_latest_successful_job(
    client: dataplex_v1.DataScanServiceClient,
    project_id: str,
    location: str,
    data_scan_id: str
) -> dataplex_v1.DataScanJob | None:
    """Finds and returns the most recently succeeded job for a given data scan."""
    scan_path = client.data_scan_path(project_id, location, data_scan_id)
    print(f"\n[INFO] Looking for the latest successful job for scan '{data_scan_id}'...")

    try:
        # List all jobs for the specified scan, which are ordered most-recent first.
        jobs_pager = client.list_data_scan_jobs(parent=scan_path)

        # Iterate through jobs to find the first one that succeeded.
        for job in jobs_pager:
            if job.state == dataplex_v1.DataScanJob.State.SUCCEEDED:
                return job

        # If no successful job is found after checking all pages.
        return None
    except NotFound:
        print(f"[WARN] No scan history found for '{data_scan_id}'.")
        return None


def main():
    """Main execution function."""
    # --- Load configuration from environment variables ---
    PROJECT_ID = os.environ.get("PROJECT_ID")
    LOCATION = os.environ.get("LOCATION")

    if not all([PROJECT_ID, LOCATION]):
        print("[ERROR] Required environment variables PROJECT_ID or LOCATION are not set.")
        sys.exit(1)

    print(f"[INFO] Using Project: {PROJECT_ID}, Location: {LOCATION}")
    print(f"--- Starting Profile Retrieval for: {TARGET_VIEW} ---")

    # Construct the data_scan_id based on the target view name.
    data_scan_id = f"profile-scan-{TARGET_VIEW.replace('_', '-')}"

    # 1. Initialize 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 जैसे टूल का इस्तेमाल करने से, जनरेटिव एआई को सीधे तौर पर अपने टर्मिनल वर्कफ़्लो में इंटिग्रेट करने का एक बेहतर और इंटरैक्टिव तरीका मिलता है. Gemini CLI सिर्फ़ एक चैटबॉट नहीं है. यह कमांड-लाइन वर्कफ़्लो टूल है. यह आपकी लोकल फ़ाइलों को पढ़ सकता है, आपके कोड को समझ सकता है, और जटिल कामों को अपने-आप पूरा करने के लिए, gcloud जैसे अन्य सिस्टम टूल के साथ इंटरैक्ट कर सकता है. इसलिए, यह हमारे इस्तेमाल के उदाहरण के लिए सबसे सही है.

ज़रूरी शर्त

सबसे पहले, पक्का करें कि आपने ज़रूरी शर्तें पूरी की हों: आपके Cloud Shell एनवायरमेंट में Node.js का वर्शन 20 या उसके बाद का वर्शन इंस्टॉल होना चाहिए. node -v कमांड चलाकर, अपने वर्शन की जानकारी देखी जा सकती है.

इंस्टॉल करना

Gemini CLI का इस्तेमाल दो तरीकों से किया जा सकता है: कुछ समय के लिए इंस्टॉल करके या हमेशा के लिए इंस्टॉल करके. हम यहां दोनों तरीकों के बारे में बताएंगे.

Gemini CLI को बिना इंस्टॉल किए, सीधे तौर पर किसी एक सेशन के लिए इस्तेमाल किया जा सकता है. "इसे आज़माएं" विकल्प का इस्तेमाल करने का यह सबसे आसान और तेज़ तरीका है. इससे आपके एनवायरमेंट में कोई बदलाव नहीं होता.

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

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

यह कमांड, सीएलआई पैकेज को कुछ समय के लिए डाउनलोड करती है और उसे चलाती है.

किसी भी असली प्रोजेक्ट के लिए, हमारा सुझाव है कि आप सीएलआई को अपने प्रोजेक्ट डायरेक्ट्री में स्थानीय तौर पर इंस्टॉल करें. इस तरीके के कई मुख्य फ़ायदे हैं:

  • डिपेंडेंसी आइसोलेशन: इससे यह पक्का होता है कि आपके प्रोजेक्ट में सीएलआई का अपना वर्शन है. इससे दूसरे प्रोजेक्ट के साथ वर्शन के टकराव को रोका जा सकता है.
  • दोहराने की क्षमता: आपके प्रोजेक्ट को क्लोन करने वाला कोई भी व्यक्ति, ठीक उसी तरह की डिपेंडेंसी इंस्टॉल कर सकता है. इससे आपका सेटअप भरोसेमंद और पोर्टेबल बन जाता है.
  • सबसे सही तरीके के मुताबिक: यह Node.js प्रोजेक्ट की डिपेंडेंसी को मैनेज करने के लिए, स्टैंडर्ड मॉडल का इस्तेमाल करता है. इससे ग्लोबल (-g) इंस्टॉलेशन की कमियों से बचा जा सकता है.

सीएलआई को स्थानीय तौर पर इंस्टॉल करने के लिए, अपने प्रोजेक्ट फ़ोल्डर (programmatic-dq) से यह निर्देश चलाएं:

npm install @google/gemini-cli

इससे programmatic-dq फ़ोल्डर में एक node_modules फ़ोल्डर बन जाता है. अभी इंस्टॉल किए गए वर्शन को चलाने के लिए, npx कमांड का इस्तेमाल करें.

npx gemini

पहली बार सेटअप करना

आप चाहे कोई भी तरीका चुनें, पहली बार सीएलआई लॉन्च करने पर, यह आपको एक बार के सेटअप की प्रोसेस के बारे में बताएगा.

8a25fab5951c6c39.png

इसके बाद, आपको रंग की थीम चुनने के लिए कहा जाएगा. इसके बाद, आपको पुष्टि करनी होगी. सबसे आसान तरीका यह है कि जब आपसे कहा जाए, तब अपने Google खाते से साइन इन करें. इस कोडलैब के लिए, मुफ़्त टियर काफ़ी है.

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

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

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

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

सबसे पहले, हम Gemini से स्टैटिस्टिकल प्रोफ़ाइल का विश्लेषण करने के लिए कहेंगे. साथ ही, उसे डेटा इंजीनियर के तौर पर काम करने के लिए कहेंगे, ताकि वह कार्रवाई का प्लान सुझा सके. हमने इसे साफ़ तौर पर बताया है कि अभी YAML फ़ाइल न लिखें. इसमें विश्लेषण और वजह बताने पर ध्यान दिया जाता है.

Gemini CLI के इंटरैक्टिव सेशन में, यह प्रॉम्प्ट चिपकाएं:

cd9792a6f1eb9f3.png

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.

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

Gemini ने जो प्लान दिया है उसे ध्यान से देखें.

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

आपको Gemini से मिलने वाला आउटपुट अलग-अलग हो सकता है. आपका लक्ष्य इसे बेहतर बनाना है.

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

अब आपको 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 फ़ाइल है. इसलिए, इसे आसानी से डिप्लॉय किया जा सकता है.

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

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

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

export DQ_SCAN="dq-scan"
gcloud dataplex datascans create data-quality $DQ_SCAN \
    --project=$PROJECT_ID \
    --location=$REGION \
    --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=$REGION --project=$PROJECT_ID

इस कमांड से, जॉब आईडी मिलेगा. Google Cloud Console के Dataplex सेक्शन में जाकर, इस जॉब की स्थिति देखी जा सकती है. यह प्रोसेस पूरी होने के बाद, नतीजों को विश्लेषण के लिए BigQuery टेबल में लिखा जाएगा.

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

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

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

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

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

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

2. सटीक और सही जानकारी: एआई के जवाबों में तथ्यों के ग़लत होने और मामूली गड़बड़ियों को रोकना

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

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

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

4. शासन को एक सतत प्रक्रिया के तौर पर अपनाना: आगे की सोच के साथ जानकारी को शामिल करना

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

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

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

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

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

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

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

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

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

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 data-scans delete profile-scan-mv-ga4-user-session-flat \
    --location=us-central1 \
    --project=$PROJECT_ID --quiet

gcloud dataplex data-scans delete profile-scan-mv-ga4-ecommerce-transactions \
    --location=us-central1 \
    --project=$PROJECT_ID --quiet

gcloud dataplex data-scans 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:dataplex_dq_codelab

7. बधाई हो!

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

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

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

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

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