1. Giriş
Bu codelab, veri uzmanları için teknik bir plan sunar. Veri yönetimi için "önce kod" yaklaşımını özetler ve güçlü kalite ve meta veri yönetiminin doğrudan geliştirme yaşam döngüsüne nasıl yerleştirileceğini gösterir. Dataplex Universal Catalog, temel olarak akıllı bir veri dokusu görevi görür. Kuruluşların, veri göllerinden depolara kadar tüm mülklerindeki verileri merkezi olarak yönetmesini, izlemesini ve yönetmesini sağlar.
Bu codelab'de, karmaşık verileri düzleştirmek, programatik olarak profillendirmek, akıllı veri kalitesi kuralı önerileri oluşturmak ve otomatik kalite taramaları dağıtmak için Dataplex, BigQuery ve Gemini CLI'den nasıl yararlanılacağı gösterilmektedir. Buradaki temel amaç, hataya açık ve ölçeklendirilmesi zor olan manuel, kullanıcı arayüzü odaklı süreçlerin ötesine geçerek bunun yerine sağlam ve sürüm kontrollü bir "kod olarak politika" çerçevesi oluşturmaktır.
Ön koşullar
- Google Cloud Console hakkında temel bilgiler
- Komut satırı arayüzü ve Google Cloud Shell'de temel beceriler
Neler öğreneceksiniz?
- Kapsamlı profil oluşturmayı etkinleştirmek için gerçekleştirilmiş görünümleri kullanarak iç içe yerleştirilmiş BigQuery verilerini düzleştirme
- Dataplex Python istemci kitaplığını kullanarak Dataplex profil taramalarını programatik olarak tetikleme ve yönetme
- Profil verilerini dışa aktarma ve üretken yapay zeka modeli için giriş olarak yapılandırma
- Gemini CLI'da profil verilerini analiz edip Dataplex uyumlu bir YAML kural dosyası oluşturmak için istem nasıl tasarlanır?
- Yapay zekayla üretilen yapılandırmaları doğrulamak için etkileşimli, insan etkileşimli (HITL) bir sürecin önemi.
- Oluşturulan kurallar, otomatik veri kalitesi taraması olarak nasıl dağıtılır?
Gerekenler
- Google Cloud hesabı ve Google Cloud projesi
- Chrome gibi bir web tarayıcısı
Temel kavramlar: Dataplex veri kalitesinin temel unsurları
Etkili bir veri kalitesi stratejisi oluşturmak için Dataplex'in temel bileşenlerini anlamak çok önemlidir.
- Veri Profili Tarama: Verileri analiz eden ve boş değer yüzdeleri, farklı değer sayıları ve değer dağılımları gibi istatistiksel meta veriler oluşturan bir Dataplex işidir. Bu, programatik "keşif" aşamamız olarak işlev görür.
- Veri kalitesi kuralları: Verilerinizin karşılaması gereken koşulları tanımlayan bildirimsel ifadeler (ör.
NonNullExpectation,SetExpectation,RangeExpectation). - Kural Önerisi için Üretken Yapay Zeka: Bir veri profilini analiz etmek ve alakalı veri kalitesi kuralları önermek için büyük bir dil modeli (ör. Gemini) kullanma. Bu, temel kalite çerçevesi tanımlama sürecini hızlandırır.
- Veri Kalitesi Taraması: Verileri önceden tanımlanmış veya özel bir dizi kurala göre doğrulayan bir Dataplex işidir.
- Programatik Yönetim: Yönetim kontrollerini (ör.kalite kuralları) kod olarak (ör. YAML dosyalarında ve Python komut dosyalarında) yönetmenin temel teması. Bu sayede otomasyon, sürüm oluşturma ve CI/CD ardışık düzenlerine entegrasyon sağlanır.
- İnsan Destekli (HITL): Otomatik bir iş akışına uzmanlık ve gözetim dahil etmenin kritik kontrol noktasıdır. Yapay zeka tarafından oluşturulan yapılandırmalarda, önerilerin doğruluğunu, işletmeyle alaka düzeyini ve güvenliğini dağıtımdan önce doğrulamak için HITL gereklidir.
2. Kurulum ve şartlar
Cloud Shell'i başlatma
Google Cloud, dizüstü bilgisayarınızdan uzaktan çalıştırılabilir. Ancak bu codelab'de, Cloud'da çalışan bir komut satırı ortamı olan Google Cloud Shell'i kullanacaksınız.
Google Cloud Console'da sağ üstteki araç çubuğunda Cloud Shell simgesini tıklayın:
Ortamın sağlanması ve bağlantının kurulması yalnızca birkaç saniye sürer. İşlem tamamlandığında aşağıdakine benzer bir sonuç görürsünüz:
Bu sanal makineye, ihtiyaç duyacağınız tüm geliştirme araçları yüklenmiştir. 5 GB boyutunda kalıcı bir ana dizin sunar ve Google Cloud üzerinde çalışır. Bu sayede ağ performansı ve kimlik doğrulama önemli ölçüde iyileştirilir. Bu codelab'deki tüm çalışmalarınızı tarayıcıda yapabilirsiniz. Herhangi bir şey yüklemeniz gerekmez.
Gerekli API'leri etkinleştirme ve ortamı yapılandırma
Cloud Shell'de proje kimliğinizin ayarlandığından emin olun:
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
Kullanacağımız herkese açık örnek veriler de us (çok bölgeli) konumunda bulunduğundan örnekte konum olarak us (çok bölgeli) kullanıyoruz. BigQuery, bir sorgunun kaynak verilerinin ve hedef tablosunun aynı konumda bulunmasını gerektirir.
Özel bir BigQuery veri kümesi oluşturma
Örnek verilerimizi ve sonuçlarımızı barındıracak yeni bir BigQuery veri kümesi oluşturun.
bq --location=us mk --dataset $PROJECT_ID:$DATASET_ID
Örnek verileri hazırlama
Bu codelab'de, Google Merchandise Store'dan alınmış ve kod karartma uygulanmış e-ticaret verilerini içeren herkese açık bir veri kümesi kullanacaksınız. Herkese açık veri kümeleri salt okunur olduğundan kendi veri kümenizde değiştirilebilir bir kopya oluşturmanız gerekir. Aşağıdaki bq komutu, dataplex_dq_codelab veri kümenizde ga4_transactions adlı yeni bir tablo oluşturur. Tarama işlemlerinin hızlı bir şekilde çalışmasını sağlamak için tek bir güne (2021-01-31) ait verileri kopyalar.
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`'
Demo dizinini ayarlama
Başlamak için bu codelab'de gerekli klasör yapısını ve destekleyici dosyaları içeren bir GitHub deposunu klonlayacaksınız.
git clone https://github.com/GoogleCloudPlatform/devrel-demos
cd devrel-demos/data-analytics/programmatic-dq
Bu dizin artık etkin çalışma alanınızdır. Sonraki tüm dosyalar burada oluşturulur.
3. Dataplex profili oluşturma ile otomatik veri keşfi
Dataplex veri profili oluşturma, verilerinizle ilgili istatistiksel bilgileri (ör. boş değer yüzdeleri, benzersizlik ve değer dağılımları) otomatik olarak keşfetmek için kullanılan güçlü bir araçtır. Bu işlem, verilerinizin yapısını ve kalitesini anlamak için gereklidir. Ancak Dataplex profillemenin bilinen bir sınırlaması, iç içe yerleştirilmiş veya tekrarlanan alanları (ör. RECORD veya ARRAY türleri) içermelidir. Bir sütunun karmaşık bir tür olduğunu belirleyebilir ancak bu iç içe yerleştirilmiş yapıdaki tek tek alanları profillendiremez.
Bu sorunu çözmek için verileri amaca yönelik olarak oluşturulmuş somutlaştırılmış görünümlere dönüştüreceğiz. Bu strateji, her alanı üst düzey bir sütun haline getirerek Dataplex'in her birini ayrı ayrı profillendirmesini sağlar.
İç içe yerleştirilmiş şemayı anlama
Öncelikle kaynak tablomuzun şemasını inceleyelim. Google Analytics 4 (GA4) veri kümesi, iç içe yerleştirilmiş ve tekrarlanan çeşitli sütunlar içerir. Tüm iç içe yerleştirilmiş yapılar da dahil olmak üzere tam şemayı programatik olarak almak için bq show komutunu kullanabilir ve çıkışı JSON dosyası olarak kaydedebilirsiniz.
bq show --schema --format=json $PROJECT_ID:$DATASET_ID.$TABLE_ID > bq_schema.json
bq_schema.json dosyası incelendiğinde cihaz, coğrafi konum, e-ticaret gibi karmaşık yapılar ve tekrarlanan kayıt öğeleri ortaya çıkar. Bunlar, etkili profilleme için düzleştirilmesi gereken yapılardır.
Gerçekleştirilmiş görünümlerle verileri düzleştirme
Gerçekleştirilmiş görünümler (MV'ler) oluşturmak, bu iç içe yerleştirilmiş veri sorununa yönelik en etkili ve pratik çözümdür. Düzleştirilmiş sonuçları önceden hesaplayan M'ler, sorgu performansı ve maliyet açısından önemli avantajlar sunarken analistler ve profilleme araçları için daha basit, ilişkisel benzeri bir yapı sağlar.
İlk düşünce, her şeyi tek bir dev görünümde birleştirmek olabilir. Ancak bu sezgisel yaklaşım, ciddi veri bozulmasına yol açabilecek tehlikeli bir tuzak barındırır. Bunun neden kritik bir hata olduğunu inceleyelim.
mv_ga4_user_session_flat.sql
CREATE OR REPLACE MATERIALIZED VIEW `$PROJECT_ID.$DATASET_ID.mv_ga4_user_session_flat`
OPTIONS (
enable_refresh = true,
refresh_interval_minutes = 30
) AS
SELECT
event_date, event_timestamp, event_name, user_pseudo_id, user_id, stream_id, platform,
device.category AS device_category,
device.operating_system AS device_os,
device.operating_system_version AS device_os_version,
device.language AS device_language,
device.web_info.browser AS device_browser,
geo.continent AS geo_continent,
geo.country AS geo_country,
geo.region AS geo_region,
geo.city AS geo_city,
traffic_source.name AS traffic_source_name,
traffic_source.medium AS traffic_source_medium,
traffic_source.source AS traffic_source_source
FROM
`$PROJECT_ID.$DATASET_ID.ga4_transactions`;
mv_ga4_ecommerce_transactions.sql
CREATE OR REPLACE MATERIALIZED VIEW `$PROJECT_ID.$DATASET_ID.mv_ga4_ecommerce_transactions`
OPTIONS (
enable_refresh = true,
refresh_interval_minutes = 30
) AS
SELECT
event_date, event_timestamp, user_pseudo_id, ecommerce.transaction_id,
ecommerce.total_item_quantity,
ecommerce.purchase_revenue_in_usd,
ecommerce.purchase_revenue,
ecommerce.refund_value_in_usd,
ecommerce.refund_value,
ecommerce.shipping_value_in_usd,
ecommerce.shipping_value,
ecommerce.tax_value_in_usd,
ecommerce.tax_value,
ecommerce.unique_items
FROM
`$PROJECT_ID.$DATASET_ID.ga4_transactions`
WHERE
ecommerce.transaction_id IS NOT NULL;
mv_ga4_ecommerce_items.sql
CREATE OR REPLACE MATERIALIZED VIEW `$PROJECT_ID.$DATASET_ID.mv_ga4_ecommerce_items`
OPTIONS (
enable_refresh = true,
refresh_interval_minutes = 30
) AS
SELECT
event_date, event_timestamp, event_name, user_pseudo_id, ecommerce.transaction_id,
item.item_id,
item.item_name,
item.item_brand,
item.item_variant,
item.item_category,
item.item_category2,
item.item_category3,
item.item_category4,
item.item_category5,
item.price_in_usd,
item.price,
item.quantity,
item.item_revenue_in_usd,
item.item_revenue,
item.coupon,
item.affiliation,
item.item_list_name,
item.promotion_name
FROM
`$PROJECT_ID.$DATASET_ID.ga4_transactions`,
UNNEST(items) AS item
WHERE
ecommerce.transaction_id IS NOT NULL;
Şimdi bu şablonları bq komut satırı aracını kullanarak yürütün. envsubst komutu her dosyayı okur, $PROJECT_ID ve $DATASET_ID gibi değişkenleri kabuk ortamınızdaki değerleriyle değiştirir ve son geçerli SQL'i bq query komutuna yönlendirir.
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 istemcisi aracılığıyla profil taramalarını yürütme
Düzleştirilmiş, profillendirilebilir görünümlerimiz olduğuna göre, her biri için programatik olarak Dataplex veri profili taramaları oluşturup çalıştırabiliriz. Aşağıdaki Python komut dosyası, bu işlemi otomatikleştirmek için google-cloud-dataplex istemci kitaplığını kullanır.
Komut dosyasını çalıştırmadan önce proje dizininizde izole bir Python ortamı oluşturmanız çok önemlidir. Bu sayede projenin bağımlılıkları ayrı olarak yönetilir ve Cloud Shell ortamınızdaki diğer paketlerle çakışmalar önlenir.
# Create the virtual environment
python3 -m venv dq_venv
# Activate the environment
source dq_venv/bin/activate
Şimdi, yeni etkinleştirilen ortamda Dataplex istemci kitaplığını yükleyin.
# Install the Dataplex client library
pip install google-cloud-dataplex
Ortam ayarlanıp kitaplık yüklendikten sonra orkestrasyon komut dosyasını oluşturmaya hazırsınız.
Cloud Shell araç çubuğunda Düzenleyiciyi Aç'ı tıklayın. 1_run_dataplex_scans.py adlı yeni bir dosya oluşturun ve aşağıdaki Python kodunu bu dosyaya yapıştırın. GitHub deposunu klonlarsanız bu dosya zaten klasörünüzde bulunur.
Bu komut dosyası, her gerçekleştirilmiş görünüm için (henüz yoksa) bir tarama oluşturur, taramayı çalıştırır ve ardından tüm tarama işleri tamamlanana kadar yoklama yapar.
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()
Şimdi komut dosyasını Cloud Shell terminalinizden çalıştırın.
python 1_run_dataplex_scans.py
Komut dosyası artık üç somutlaştırılmış görünümünüzün profil oluşturma işlemini düzenleyerek gerçek zamanlı durum güncellemeleri sağlayacak. İşlem tamamlandığında, iş akışımızın bir sonraki aşaması olan yapay zeka destekli veri kalitesi kuralı oluşturma için hazır, her görünüm için zengin ve makine tarafından okunabilir bir istatistiksel profiliniz olur.
Tamamlanan profil taramalarını Google Cloud Console'da görebilirsiniz.
- Gezinme menüsündeki Govern bölümünde Dataplex Universal Catalog ve Profile'a gidin.
- Üç profil taramanızın ve son iş durumlarının listelendiğini görürsünüz. Ayrıntılı sonuçları görüntülemek için bir taramayı tıklayabilirsiniz.
BigQuery profilinden yapay zekaya hazır girişe
Dataplex profil taramaları başarıyla çalıştırıldı. Sonuçlar Dataplex API'de kullanılabilir olsa da bunları üretken yapay zeka modeli için giriş olarak kullanmak üzere yapılandırılmış bir yerel dosyaya ayıklamamız gerekir.
Aşağıdaki Python komut dosyası (2_dq_profile_save.py), mv_ga4_user_session_flat görünümümüz için en son başarılı profil tarama işini programatik olarak bulur. Ardından, eksiksiz ve ayrıntılı profil sonucunu alır ve dq_profile_results.json adlı yerel bir JSON dosyası olarak kaydeder. Bu dosya, bir sonraki adımda yapay zeka analizimiz için doğrudan giriş olarak kullanılacaktır.
Cloud Shell düzenleyicinizde 2_dq_profile_save.py adlı yeni bir dosya oluşturun ve aşağıdaki kodu dosyaya yapıştırın. Önceki adımda olduğu gibi, depoyu klonladıysanız dosya oluşturma adımını atlayabilirsiniz.
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()
Şimdi komut dosyasını terminalinizden çalıştırın:
python 2_dq_profile_save.py
İşlem başarıyla tamamlandığında dizininizde dq_profile_results.json adlı yeni bir dosya bulunur. Bu dosya, veri kalitesi kuralları oluşturmak için kullanacağımız zengin ve ayrıntılı istatistiksel meta verileri içerir. dq_profile_results.json içeriğini kontrol etmek istiyorsanız aşağıdaki komutu yürütün:
cat dq_profile_results.json
4. Gemini CLI ile veri kalitesi kuralları oluşturma
Gemini CLI'yı yükleme ve yapılandırma
Gemini API'yi programatik olarak çağırabilirsiniz ancak Gemini CLI gibi bir aracı kullanmak, üretken yapay zekayı doğrudan terminal iş akışlarınıza entegre etmenin güçlü ve etkileşimli bir yolunu sunar. Gemini CLI yalnızca bir chatbot değildir. Yerel dosyalarınızı okuyabilen, kodunuzu anlayabilen ve karmaşık görevleri otomatikleştirmek için gcloud gibi diğer sistem araçlarıyla etkileşime girebilen bir komut satırı iş akışı aracıdır. Bu nedenle, kullanım alanımız için idealdir.
Ön koşul
Öncelikle, gerekli ön koşulu karşıladığınızdan emin olun: Cloud Shell ortamınıza Node.js 20 sürümü veya daha yeni bir sürüm yüklenmiş olmalıdır. node -v komutunu çalıştırarak sürümünüzü kontrol edebilirsiniz.
Yükleme
Gemini CLI'ı kullanmanın iki yolu vardır: geçici olarak yükleme veya daha kalıcı olarak yükleme. Bu makalede her iki yöntem de ele alınacaktır.
Gemini CLI'yı kalıcı olarak yüklemeden tek bir oturum için doğrudan çalıştırabilirsiniz. Bu, ortamınızı tamamen değiştirmeden "denemenin" en temiz ve en hızlı yoludur.
Cloud Shell terminalinizde şu komutu çalıştırın:
npx https://github.com/google-gemini/gemini-cli
Bu komut, CLI paketini geçici olarak indirip çalıştırır.
Herhangi bir gerçek proje için önerilen en iyi uygulama, CLI'yı yerel olarak proje dizininize yüklemektir. Bu yaklaşımın bazı önemli avantajları vardır:
- Bağımlılık izolasyonu: Projenizin kendi CLI sürümüne sahip olmasını sağlayarak diğer projelerle sürüm çakışmalarını önler.
- Yeniden üretilebilirlik: Projenizi klonlayan herkes aynı bağımlılıkları yükleyebilir. Bu sayede kurulumunuz güvenilir ve taşınabilir olur.
- En iyi uygulama uyumluluğu: Node.js proje bağımlılıklarını yönetmek için standart modeli izler ve genel (-g) kurulumların tuzaklarından kaçınır.
CLI'yı yerel olarak yüklemek için proje klasörünüzden (programmatic-dq) aşağıdaki komutu çalıştırın:
npm install @google/gemini-cli
Bu işlem, programmatic-dq içinde bir node_modules klasörü oluşturur. Yeni yüklediğiniz sürümü çalıştırmak için npx komutunu kullanın.
npx gemini
İlk kurulum
Hangi yöntemi seçerseniz seçin, CLI'yı ilk kez başlattığınızda tek seferlik kurulum sürecinde size yol gösterilir.
Bir renk teması seçmeniz ve ardından kimliğinizi doğrulamanız istenir. En basit yöntem, istendiğinde Google Hesabınızla oturum açmaktır. Sağlanan ücretsiz katman bu codelab için yeterlidir.
CLI yüklendiğine ve yapılandırıldığına göre artık kuralları oluşturmaya devam edebilirsiniz. CLI, geçerli dizinindeki dosyaları bilir. Bu, sonraki adım için çok önemlidir.
Veri kalitesi kurallarını oluşturma
Bir LLM'den tek seferde yapılandırma dosyası oluşturmasını istemek mümkün olsa da üretken modellerin deterministik olmayan yapısı nedeniyle çıkış, gcloud gibi araçların gerektirdiği katı şemaya her zaman tam olarak uymayabilir. Daha güvenilir bir yöntem, etkileşimli ve çok adımlı bir süreçtir. Bu süreçte önce yapay zekanın bir plan önermek için analist gibi davranmasını sağlarsınız, ardından bu planı (insan uzmanı olarak) inceleyip onaylarsınız ve ancak o zaman yapay zeka, onaylanmış talimatlarınıza göre son kodu oluşturur.
Bu yaklaşım, süreci basit bir komuttan ortak çalışma oturumuna dönüştürerek nihai çıktının doğru, doğrulanmış ve dağıtıma hazır olmasını sağlar.
İlk olarak Gemini'dan istatistiksel profili analiz etmesini ve uzman bir veri mühendisi gibi davranarak bir eylem planı önermesini isteyeceğiz. YAML dosyasını henüz yazmamasını açıkça söylüyoruz. Bu, dikkatini analiz ve gerekçelendirmeye odaklar.
Etkileşimli Gemini CLI oturumunuza aşağıdaki istemi yapıştırın:
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 dosyasını analiz eder ve aşağıdakine benzer yapılandırılmış bir plan döndürür:
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.
Bu, tüm iş akışındaki en kritik adımdır: Sürecin parçası olan insan (HITL) incelemesi. Gemini tarafından oluşturulan plan tamamen verilerdeki istatistiksel kalıplara dayanır. İşletme bağlamınız, gelecekteki veri değişiklikleri veya verilerinizin arkasındaki belirli amaç hakkında bilgi sahibi değildir. İnsan uzman olarak rolünüz, bu planı koda dönüştürmeden önce doğrulamak, düzeltmek ve onaylamaktır.
Gemini'ın sağladığı planı dikkatlice inceleyin.
- Mantıklı mı?
- Bu yanıt, işletme bilgilerinizle uyumlu mu?
- İstatistiksel olarak sağlam ancak pratik olarak işe yaramayan kurallar var mı?
Gemini'dan aldığınız çıkışlar farklılık gösterebilir. Hedefiniz, bu bilgileri daha iyi hale getirmektir.
Örneğin, tablodaki örnek verilerde sabit sayıda satır olduğu için planın rowCount kuralı önerdiğini varsayalım. Bir uzman olarak, bu tablonun boyutunun her gün büyümesinin beklendiğini, bu nedenle katı bir satır sayısı kuralının pratik olmadığını ve yanlış uyarılara neden olabileceğini biliyor olabilirsiniz. Bu, yapay zekanın eksik olduğu iş bağlamını uygulamaya dair mükemmel bir örnektir.
Şimdi Gemini'a geri bildirimde bulunacak ve kodu oluşturması için son komutu vereceksiniz. Aşağıdaki istemi, aldığınız plana ve yapmak istediğiniz düzeltmelere göre uyarlamanız gerekir.
Aşağıdaki istem bir şablondur. İlk satırda, düzeltmelerinizi belirteceksiniz. Gemini'ın verdiği plan mükemmelse ve herhangi bir değişiklik yapılması gerekmiyorsa bu satırı silebilirsiniz.
Aynı Gemini oturumunda, aşağıdaki istemin uyarlanmış sürümünü yapıştırın:
[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 artık YAML içeriğini, insan tarafından doğrulanmış talimatlarınıza göre oluşturacak. İşlem tamamlandığında çalışma dizininizde dq_rules.yaml adlı yeni bir dosya görürsünüz.
Veri kalitesi taraması oluşturma ve çalıştırma
Artık yapay zeka tarafından oluşturulmuş ve insan tarafından doğrulanmış bir dq_rules.yaml dosyanız olduğuna göre, bu dosyayı güvenle dağıtabilirsiniz.
/quit yazarak veya Ctrl+C tuşuna iki kez basarak Gemini CLI'dan çıkın.
Aşağıdaki gcloud komutu yeni bir Dataplex veri tarama kaynağı oluşturur. Tarama henüz çalıştırılmaz. Yalnızca taramanın tanımı ve yapılandırması (YAML dosyamız) Dataplex'e kaydedilir.
Terminalinizde şu komutu çalıştırın:
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"
Artık tanımlanmış olan taramayı yürütmek için bir iş tetikleyebilirsiniz.
gcloud dataplex datascans run $DQ_SCAN --location=$REGION --project=$PROJECT_ID
Bu komut bir iş kimliği oluşturur. Bu işin durumunu Google Cloud Console'un Dataplex bölümünde izleyebilirsiniz. Tamamlandıktan sonra sonuçlar analiz için bir BigQuery tablosuna yazılır.
5. Sürecin parçası olan insanın (HITL) kritik rolü
Kural oluşturma sürecini hızlandırmak için Gemini'ı kullanmak inanılmaz derecede etkili olsa da yapay zekayı tamamen otonom bir pilot olarak değil, son derece yetenekli bir yardımcı pilot olarak değerlendirmek çok önemlidir. Kullanıcıların dahil edilmesi (HITL) süreci isteğe bağlı bir öneri değildir. Bu süreç, sağlam ve güvenilir veri yönetimi iş akışlarında vazgeçilmez ve temel bir adımdır. Yapay zeka tarafından üretilen eserleri, titiz bir insan gözetimi olmadan kullanmak başarısızlığa yol açar.
Yapay zeka tarafından oluşturulan dq_rules.yaml, son derece hızlı ancak deneyimsiz bir yapay zeka geliştiricisi tarafından gönderilen bir çekme isteği olarak düşünülebilir. Yönetim politikanızın "ana dalına" birleştirilip dağıtılabilmesi için sizden, yani kıdemli bir uzman tarafından kapsamlı bir inceleme yapılması gerekir. Bu inceleme, büyük dil modellerinin doğasında bulunan zayıflıkları azaltmak için çok önemlidir.
Bu incelemenin neden vazgeçilmez olduğu ve özellikle nelere dikkat etmeniz gerektiğiyle ilgili ayrıntılı bilgiyi aşağıda bulabilirsiniz:
1. Bağlamsal doğrulama: Yapay zeka, işletme bilincine sahip değil
- LLM'nin zayıf noktası: LLM, kalıplar ve istatistikler konusunda uzmandır ancak işletme bağlamınız hakkında hiçbir fikri yoktur. Örneğin,
new_campaign_idsütununun boşluk oranı% 98 ise bir LLM, istatistiksel bir nedenden dolayı bu sütunu yoksayabilir. - Uzmanın kritik rolü: Uzman olarak siz,
new_campaign_idalanının önümüzdeki hafta yapılacak büyük bir ürün lansmanı için dün eklendiğini biliyorsunuz. Boş değer oranının şu anda yüksek olduğunu ancak önemli ölçüde düşmesinin beklendiğini biliyorsunuz. Ayrıca, bu alan doldurulduktan sonra belirli bir biçime uyması gerektiğini de biliyorsunuz. Yapay zeka, bu harici işletme bilgisini çıkaramaz. Sizin rolünüz, bu işletme bağlamını yapay zekanın istatistiksel önerilerine uygulamak, gerektiğinde bunları geçersiz kılmak veya artırmaktır.
2. Doğruluk ve hassasiyet: Halüsinasyon ve küçük hatalara karşı koruma
- LLM'lerin zayıf noktası: LLM'ler "kendinden emin bir şekilde yanlış" olabilir. Bu modeller "halüsinasyon" görebilir veya küçük hatalar içeren kodlar oluşturabilir. Örneğin, doğru adlandırılmış bir kural içeren ancak geçersiz bir parametreye sahip bir YAML dosyası oluşturabilir veya bir kural türünü yanlış yazabilir (ör.
setExpectationyerinesetExpectationskullanılması gibi küçük hatalar dağıtımın başarısız olmasına neden olur ancak bu hataları fark etmek zor olabilir. - İnsanın kritik rolü: Nihai linter ve şema doğrulayıcı olarak hareket etmeniz gerekir. Oluşturulan YAML'yi resmi Dataplex
DataQualityRulespesifikasyonuna göre titizlikle kontrol etmeniz gerekir. Yalnızca "doğru görünüp görünmediğini" kontrol etmiyorsunuz. Hedef API ile% 100 uyumlu olduğundan emin olmak için söz dizimsel ve anlamsal doğruluğunu da onaylıyorsunuz. Bu nedenle, codelab'deki istemler Gemini'ı şema dosyalarına başvurmaya yönlendirir. Böylece hata olasılığı azalır ancak son doğrulama size aittir.
3. Güvenlik ve risk azaltma: Sonraki sonuçları önleme
- LLM'nin zayıf noktası: Üretime dağıtılan hatalı bir veri kalitesi kuralı ciddi sonuçlara yol açabilir. Yapay zeka, finansal işlem tutarı için çok geniş bir
rangeExpectationönerirse sahtekarlık içeren etkinlikleri tespit edemeyebilir. Aksine, küçük bir veri örneğine dayalı olarak çok katı bir kural önerirse nöbetçi ekibinizi binlerce yanlış pozitif uyarıyla doldurabilir. Bu durum, uyarı yorgunluğuna yol açarak gerçek sorunların gözden kaçmasına neden olabilir. - İnsanın kritik rolü: Güvenlik mühendisi sizsiniz. Yapay zekanın önerdiği her kuralın potansiyel etkisini değerlendirmeniz gerekir. Kendinize şu soruyu sorun: "Bu kural başarısız olursa ne olur? Uyarı üzerinde işlem yapılabilir mi? Bu kural yanlışlıkla geçerse risk nedir?" Bu risk değerlendirmesi, başarısızlığın maliyetini kontrolün faydasıyla karşılaştıran, yalnızca insanlara özgü bir yetenektir.
4. Sürekli bir süreç olarak yönetişim: Geleceğe yönelik bilgileri dahil etme
- LLM'nin zayıf noktası: Yapay zekanın bilgisi, verilerin statik bir anlık görüntüsüne dayanır. Profil, belirli bir zamandaki sonuçlardan oluşur. Gelecekteki etkinlikler hakkında bilgisi yoktur.
- İnsanın kritik rolü: Yönetim stratejiniz ileriye dönük olmalıdır. Bir veri kaynağının gelecek ay taşınacağını ve bu işlemin stream_id değerini değiştireceğini biliyorsunuz.
geo_countrylistesine yeni bir ülke eklendiğini biliyorsunuz. HITL süreci, planlanan işletme veya teknik gelişmeler sırasında bozulmaları önlemek için kuralları güncellediğiniz ya da geçici olarak devre dışı bıraktığınız ve gelecekteki durumla ilgili bilgileri eklediğiniz yerdir. Veri kalitesi tek seferlik bir kurulum değildir. Gelişmesi gereken canlı bir süreçtir ve bu gelişimi yalnızca bir insan yönlendirebilir.
Özetle, HITL, yapay zeka destekli yönetimi yeni ancak riskli bir fikirden sorumlu, ölçeklenebilir ve kurumsal düzeyde bir uygulamaya dönüştüren temel kalite güvencesi ve güvenlik mekanizmasıdır. Bu sayede, son olarak dağıtılan politikaların yalnızca yapay zeka destekli değil, aynı zamanda insan tarafından doğrulanmış olması sağlanır. Böylece, makinelerin hızı ile uzmanların bilgeliği ve bağlamı bir araya getirilir.
Ancak insan gözetimine yapılan bu vurgu, yapay zekanın değerini azaltmaz. Aksine, üretken yapay zeka, HITL sürecinin hızlandırılmasında önemli bir rol oynar.
Yapay zeka olmadan bir veri mühendisinin yapması gerekenler:
- Verileri profillemek için karmaşık SQL sorgularını manuel olarak yazma (ör.
COUNT DISTINCT,AVG,MIN,MAX(her sütun için). - Sonuçları e-tablo e-tablo titizlikle analiz edin.
- YAML kural dosyasının her satırını sıfırdan yazmak zahmetli ve hataya açık bir iştir.
Yapay zeka, bu zahmetli ve zaman alıcı adımları otomatikleştirir. İstatistiksel profili anında işleyen ve politikayla ilgili iyi yapılandırılmış, %80 oranında tamamlanmış bir "ilk taslak" sağlayan yorulmak bilmez bir analist gibi çalışır.
Bu durum, insanın yaptığı işin doğasını temelden değiştirir. Uzman, saatlerini manuel veri işleme ve standart kodlama ile geçirmek yerine hemen en değerli görevlere odaklanabilir:
- Kritik iş bağlamını uygulama
- Yapay zekanın mantığının doğruluğunu doğrulama
- Hangi kuralların gerçekten önemli olduğu konusunda stratejik kararlar verme
Bu ortaklıkta yapay zeka, "ne" (istatistiksel kalıplar nelerdir?) sorusunu yanıtlayarak insanın "neden" (bu kalıp işletmemiz için neden önemlidir?) ve "peki ne olacak?" (politikamız ne olmalı?) sorularına odaklanmasını sağlar. Bu nedenle yapay zeka, döngünün yerini almaz. Döngüdeki her bir çevrimi daha hızlı, daha akıllı ve daha etkili hale getirir.
6. Ortamınızı temizleme
Bu codelab'de kullanılan kaynaklar için Google Cloud hesabınızın gelecekte ücretlendirilmesini önlemek istiyorsanız kaynakları içeren projeyi silmeniz gerekir. Ancak projeyi tutmak istiyorsanız oluşturduğunuz kaynakları ayrı ayrı silebilirsiniz.
Dataplex taramalarını silme
Öncelikle oluşturduğunuz profil ve kalite taramalarını silin. Önemli kaynakların yanlışlıkla silinmesini önlemek için bu komutlarda, bu codelab'de oluşturulan taramaların adları kullanılır.
# 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 veri kümesini silme
Ardından, BigQuery veri kümesini silin. Bu komut geri alınamaz ve veri kümesini ve tüm tablolarını onay olmadan kaldırmak için -f (zorla) işaretini kullanır.
# Manually type this command to confirm you are deleting the correct dataset
bq rm -r -f --dataset $PROJECT_ID:dataplex_dq_codelab
7. Tebrikler!
Codelab'i başarıyla tamamladınız.
Uçtan uca, programatik bir veri yönetimi iş akışı oluşturmuş olursunuz. Karmaşık BigQuery verilerini düzleştirerek analize uygun hale getirmek için materialized view'ları kullanarak başladınız. Ardından, istatistiksel meta veriler oluşturmak için Dataplex profil taramalarını programatik olarak çalıştırdınız. En önemlisi, profil çıkışını analiz etmek ve akıllıca bir "kod olarak politika" artefaktı oluşturmak için Gemini CLI'yi kullandınız (dq_rules.yaml). Ardından, bu yapılandırmayı otomatik bir veri kalitesi taraması olarak dağıtmak için CLI'yi kullandınız ve modern, ölçeklenebilir bir yönetim stratejisiyle döngüyü tamamladınız.
Artık Google Cloud'da güvenilir, yapay zeka destekli ve insan tarafından doğrulanmış veri kalitesi sistemleri oluşturmak için temel kalıba sahipsiniz.
Sırada ne var?
- CI/CD ile entegrasyon: dq_rules.yaml dosyasını alıp bir Git deposuna gönderin. Kural dosyası her güncellendiğinde Dataplex taramasını otomatik olarak dağıtan bir CI/CD işlem hattı (ör. Cloud Build veya GitHub Actions kullanılarak) oluşturun.
- Özel SQL kurallarını keşfedin: Standart kural türlerinin ötesine geçin. Dataplex, önceden tanımlanmış kontrollerle ifade edilemeyen daha karmaşık ve işletmeye özgü mantığı zorunlu kılmak için özel SQL kurallarını destekler. Bu, doğrulamayı benzersiz gereksinimlerinize göre uyarlamak için kullanabileceğiniz güçlü bir özelliktir.
- Tarama işlemlerini verimlilik ve maliyet açısından optimize etme: Çok büyük tablolarda, tüm veri kümesini her zaman taramayarak performansı artırabilir ve maliyetleri düşürebilirsiniz. Tarama kapsamını belirli zaman aralıkları veya veri segmentleriyle sınırlandırmak için filtreleri kullanmayı deneyin ya da verilerinizin temsili bir yüzdesini kontrol etmek için örneklenmiş taramalar yapılandırın.
- Sonuçları görselleştirme: Her Dataplex veri kalitesi taramasının çıkışı bir BigQuery tablosuna yazılır. Bu tabloyu Looker Studio'ya bağlayarak, tanımladığınız boyutlara (ör. Eksiksiz olma, Geçerlilik). Bu sayede izleme proaktif hale gelir ve tüm paydaşlar tarafından görülebilir.
- En iyi uygulamaları paylaşın: Toplu deneyimden yararlanmak ve veri kalitesi stratejinizi iyileştirmek için kuruluşunuzda bilgi paylaşımını teşvik edin. Veri güveni kültürünü teşvik etmek, yönetim çalışmalarınızdan en iyi şekilde yararlanmanın anahtarıdır.
- Belgeleri okuyun: