Mengaktifkan akses lakehouse yang sesuai dengan kebijakan menggunakan Knowledge Catalog

Saat Anda menyimpan data di berbagai sistem penyimpanan, mengelola keamanan yang terfragmentasi dapat menjadi tantangan besar. Anda ingin memastikan informasi sensitif, seperti catatan keuangan, tetap terlindungi, meskipun Anda menyimpannya dalam format terbuka seperti Apache Iceberg di Google Cloud penyimpanan.

Yang terpenting, langkah-langkah keamanan Anda harus berfungsi dengan lancar di berbagai mesin kueri, seperti BigQuery SQL dan Apache Spark. Dalam arsitektur ini, Knowledge Catalog memecahkan masalah ini dengan berfungsi sebagai mesin konteks universal. File ini menyimpan metadata yang diperlukan untuk memastikan konteks keamanan Anda diterapkan secara konsisten, terlepas dari mesin mana yang mengkueri data.

Dalam tutorial ini, Anda akan membangun lakehouse data yang aman untuk mengatasi tantangan ini. Dengan menggunakan skrip, Anda dapat menentukan kebijakan keamanan dan melihat Knowledge Catalog (sebelumnya Dataplex Universal Catalog) dan Lakehouse untuk Apache Iceberg bekerja sama untuk menerapkan kebijakan di berbagai mesin kueri.

Ringkasan arsitektur

Untuk menyiapkan kontrol akses mendetail pada format tabel terbuka seperti Apache Iceberg, Anda harus membuat arsitektur keamanan terpadu yang ketat.

Dengan desain ini, Knowledge Catalog berfungsi sebagai bidang kontrol pusat. Knowledge Catalog secara dinamis menerapkan konteks keamanan Anda di semua mesin yang didukung.

Arsitektur lakehouse yang mematuhi kebijakan yang menggunakan lapisan arsitektur yang aman dan penerapan kebijakan terpusat.
Arsitektur lakehouse yang mematuhi kebijakan

Tutorial ini mengandalkan dua konsep utama untuk membuat arsitektur terpadu ini:

  • Lapisan arsitektur yang aman: Daripada membiarkan pengguna atau mesin kueri mengakses bucket Cloud Storage Anda secara langsung, Anda membangun fondasi berlapis yang aman berdasarkan atribut berikut:
    • Format terbuka dengan metadata terkelola: Data Anda tetap dalam format Apache Iceberg (Parquet) terbuka di dalam Cloud Storage, sementara Lakehouse untuk Apache Iceberg mengelola metadata tabel.
    • Batas keamanan logis: Anda memisahkan izin penyimpanan dari kueri data menggunakan koneksi resource Cloud yang aman. Anda tidak pernah memberikan akses langsung ke file kepada pengguna akhir.
    • Delegasi komputasi: Untuk mencegah mesin kueri melewati aturan Anda, Anda merutekan semua permintaan data melalui BigQuery Storage API. Merutekan permintaan melalui BigQuery Storage API memastikan bahwa Knowledge Catalog dapat mencegat dan menerapkan kebijakan meskipun untuk mesin pemrosesan eksternal.
  • Penerapan kebijakan terpusat: Setelah fondasi yang aman diterapkan, Anda dapat menggunakan Knowledge Catalog untuk menerapkan aturan secara universal:
    • Tentukan sekali, terapkan di mana saja: Anda hanya perlu menentukan tag kebijakan di Knowledge Catalog satu kali, dan platform akan menerapkan aturan penyamaran yang konsisten di semua mesin kueri yang didukung.
    • Penyamaran data dinamis: Sistem mengevaluasi identitas pengguna selama kueri. Pengguna yang diberi otorisasi melihat nilai mentah, sedangkan pengguna yang dibatasi menerima output NULL di semua mesin kueri.
    • Silsilah data otomatis: Knowledge Catalog melacak transformasi data secara otomatis, sehingga membuat jalur audit tanpa kode logging kustom.

Tujuan

Sebelum memulai

Sebelum memulai, lakukan hal berikut:

  • Pilih project Google Cloud untuk tutorial ini.
  • Konfirmasi bahwa penagihan diaktifkan untuk project Anda.

Menyiapkan lingkungan Anda

Tutorial ini menggunakan Cloud Shell, yaitu lingkungan command line yang berjalan di cloud.

  1. Dari Google Cloud Console, klik ikon Cloud Shell di toolbar kanan atas.

  2. Tetapkan variabel project Anda:

    export PROJECT_ID=$(gcloud config get-value project)
export REGION="us-central1"
export ICEBERG_BUCKET="iceberg-retail-demo-${PROJECT_ID}"
export DATASET_ID="lakehouse_retail_demo"
export CONN_NAME="iceberg-bq-conn-demo"

  3. Tentukan variabel untuk dua persona pengguna, yaitu analis ritel dan pengelola ritel:

    export USER_ANALYST="retail-analyst-demo"
export EMAIL_ANALYST="${USER_ANALYST}@${PROJECT_ID}.iam.gserviceaccount.com"

export USER_MANAGER="retail-manager-demo"
export EMAIL_MANAGER="${USER_MANAGER}@${PROJECT_ID}.iam.gserviceaccount.com"
export CURRENT_USER=$(gcloud config get-value account)

  4. Aktifkan Google Cloud API yang diperlukan.

    gcloud services enable \
  bigquery.googleapis.com \
  bigqueryconnection.googleapis.com \
  datacatalog.googleapis.com \
  bigquerydatapolicy.googleapis.com \
  datalineage.googleapis.com \
  dataplex.googleapis.com \
  dataproc.googleapis.com \
  storage-component.googleapis.com

Mendownload kode sumber tutorial

Download skrip Python untuk tutorial ini dari repositori DevRel Google Cloud :

# Shallow clone without full history
git clone --depth 1 --filter=blob:none --sparse https://github.com/GoogleCloudPlatform/devrel-demos.git
cd devrel-demos

# Download only the specific folder
git sparse-checkout set data-analytics/governed-lakehouse
cd data-analytics/governed-lakehouse

Membuat bucket penyimpanan

Buat bucket baru untuk menyimpan file tabel Iceberg:

gcloud storage buckets create gs://${ICEBERG_BUCKET} --location=${REGION}

Mempersiapkan identitas dan keamanan

Pada langkah ini, Anda akan menyiapkan delegasi komputasi dengan membuat koneksi resource Cloud. Koneksi ini berfungsi sebagai identitas yang didelegasikan dan aman yang digunakan BigQuery untuk mengelola dan membaca file Iceberg Anda. Hal ini membantu memastikan bahwa setiap pengguna tidak pernah memiliki akses langsung ke bucket Cloud Storage Anda.

Jalankan perintah berikut untuk membuat koneksi, mengambil akun layanan yang dibuat otomatis, dan memberikan izin yang diperlukan akun tersebut untuk mengelola data Iceberg Anda:

# Create the Cloud resource connection
bq mk --connection \
    --connection_type=CLOUD_RESOURCE \
    --location=${REGION} \
    ${CONN_NAME}

# Retrieve the connection's automatically generated Service Account
export BQ_CONN_SVC_ACCT=$(bq show --format=json --connection ${REGION}.${CONN_NAME} \
    | jq -r '.cloudResource.serviceAccountId')

# Grant Storage Object Admin to the connection for the Iceberg bucket
gcloud storage buckets add-iam-policy-binding gs://${ICEBERG_BUCKET} \
    --member="serviceAccount:${BQ_CONN_SVC_ACCT}" \
    --role="roles/storage.objectAdmin" \
    --quiet

Buat akun layanan untuk dua persona: Analis dan Pengelola. Perintah berikut menyiapkan akun layanan ini, mengizinkan pengguna saat ini meniru identitasnya untuk pengujian, dan memberikan peran tertentu kepada akun layanan tersebut untuk menjalankan kueri dan melihat data.

echo "Creating Service Accounts..."
for USER in "${USER_ANALYST}" "${USER_MANAGER}"; do
    gcloud iam service-accounts create ${USER} --display-name="Lakehouse ${USER}"
done

echo "⏳ Waiting 15 seconds for rules to apply..."
sleep 15

echo "Granting roles to service accounts..."
for USER in "${USER_ANALYST}" "${USER_MANAGER}"; do
    EMAIL="${USER}@${PROJECT_ID}.iam.gserviceaccount.com"
    
    # Allow Cloud Shell to impersonate them for testing
    gcloud iam service-accounts add-iam-policy-binding ${EMAIL} \
        --member="user:${CURRENT_USER}" \
        --role="roles/iam.serviceAccountTokenCreator" \
        --quiet

    # Allow logical viewing of the catalog, querying, and running Dataproc jobs
    for ROLE in "roles/datacatalog.viewer" "roles/bigquery.dataViewer" "roles/bigquery.user" "roles/bigquery.connectionUser" "roles/serviceusage.serviceUsageConsumer" "roles/dataproc.worker"; do
        gcloud projects add-iam-policy-binding ${PROJECT_ID} \
            --member="serviceAccount:${EMAIL}" \
            --role="${ROLE}" \
            --quiet
    done
done

# Grant the Manager data creation rights
gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member="serviceAccount:${EMAIL_MANAGER}" \
    --role="roles/bigquery.dataEditor" \
    --quiet

echo "✅ Identity and Security setup completed!"

Membuat tabel Apache Iceberg

Gunakan mesin SQL BigQuery untuk membuat tabel Apache Iceberg. Meskipun Anda menjalankan perintah pembuatan dengan BigQuery, Lakehouse bertindak sebagai lapisan pengelolaan yang menyimpan metadata tabel dan mengamankan file Parquet pokok di Cloud Storage.

Setelah membuat tabel, Anda menjalankan transformasi cepat untuk melihat cara Knowledge Catalog menangani keamanan dan secara otomatis melacak perjalanan data Anda.

Membuat set data BigQuery

Pertama, buat set data BigQuery untuk mengelompokkan tabel Anda:

echo "Creating BigQuery Dataset..."
bq mk --location=${REGION} --dataset ${PROJECT_ID}:${DATASET_ID}

Buat tabel Iceberg

Jalankan perintah berikut untuk membuat tabel inventaris dan transaksi:

echo "Creating Iceberg tables..."

# Inventory table
bq query --use_legacy_sql=false \
"CREATE OR REPLACE TABLE \`${PROJECT_ID}.${DATASET_ID}.inventory\` (
    product_id INT64, 
    product_name STRING, 
    stock_count INT64
) 
WITH CONNECTION \`${REGION}.${CONN_NAME}\` 
OPTIONS (
    file_format = 'PARQUET',
    table_format = 'ICEBERG',
    storage_uri = 'gs://${ICEBERG_BUCKET}/inventory/'
);"

# Transactions table
bq query --use_legacy_sql=false \
"CREATE OR REPLACE TABLE \`${PROJECT_ID}.${DATASET_ID}.transactions\` (
    id INT64, 
    item STRING, 
    amount FLOAT64, 
    transaction_date DATE
) 
WITH CONNECTION \`${REGION}.${CONN_NAME}\` 
OPTIONS (
    file_format = 'PARQUET',
    table_format = 'ICEBERG',
    storage_uri = 'gs://${ICEBERG_BUCKET}/transactions/'
);"

Menyisipkan data sampel

Masukkan data sampel ke dalam tabel:

echo "Inserting data into Iceberg tables..."

# Insert into Inventory table
bq query --use_legacy_sql=false \
"INSERT INTO \`${PROJECT_ID}.${DATASET_ID}.inventory\` (product_id, product_name, stock_count)
VALUES (101, 'Widget A', 500), (102, 'Widget B', 250), (103, 'Widget C', 800);"

# Insert into Transactions table
bq query --use_legacy_sql=false \
"INSERT INTO \`${PROJECT_ID}.${DATASET_ID}.transactions\` (id, item, amount, transaction_date)
VALUES 
    (1, 'Widget A', 100.0, DATE '2024-01-01'), 
    (2, 'Widget B', 150.0, DATE '2024-01-02'), 
    (3, 'Widget C', 50.0, DATE '2024-01-03');"

Sekarang Anda memiliki dua tabel Iceberg dengan data contoh mentah. Lakehouse mengelola metadata, tetapi file Parquet yang sebenarnya ada di bucket Cloud Storage Anda.

Mentransformasi data untuk silsilah otomatis

Gabungkan transaksi mentah Anda ke dalam ringkasan penjualan harian. Transformasi ini membuat tabel baru dan menghasilkan metadata yang digunakan Knowledge Catalog untuk memetakan perjalanan data Anda secara otomatis.

echo "Creating transactions summary table..."
bq query --use_legacy_sql=false \
"CREATE TABLE \`${PROJECT_ID}.${DATASET_ID}.transactions_summary\` AS 
 SELECT transaction_date, SUM(amount) as total_sales, COUNT(id) as transaction_count 
 FROM \`${PROJECT_ID}.${DATASET_ID}.transactions\` 
 GROUP BY transaction_date;"

Menentukan kebijakan tata kelola akses

Dalam lingkungan produksi, menulis aturan keamanan sebagai kode (infrastruktur sebagai kode) membuat kebijakan Anda dapat diulang, dikontrol versinya, dan lebih mudah dikelola. Di bagian ini, Anda akan menggunakan Google Cloud Python SDK untuk menentukan dan menerapkan aturan secara otomatis.

Siapkan lingkungan virtual Python

Siapkan lingkungan virtual Python yang terisolasi untuk mengelola dependensi dan memastikan skrip berjalan dengan andal:

# Create and activate a virtual environment
python3 -m venv lakehouse_env
source lakehouse_env/bin/activate

# Install required Knowledge Catalog and BigQuery governance libraries
pip install google-cloud-datacatalog google-cloud-bigquery-datapolicies google-cloud-bigquery --quiet

echo "✅ Python environment is ready!"

Menentukan taksonomi dan tag keamanan

Mulai dengan membangun fondasi untuk aturan keamanan Anda. Pada langkah ini, Anda akan membuat taksonomi untuk bertindak sebagai penampung dan tag kebijakan untuk berfungsi sebagai label keamanan tertentu untuk data sensitif.

Jalankan skrip untuk membuat resource:

python 1_create_taxonomy.py

Tinjau 1_create_taxonomy.py untuk melihat logika inti:

# Create Taxonomy with Fine-Grained Access Control enabled
taxonomy = datacatalog_v1.Taxonomy(
    display_name="BusinessCritical",
    activated_policy_types=[datacatalog_v1.Taxonomy.PolicyType.FINE_GRAINED_ACCESS_CONTROL]
)
created_taxonomy = client.create_taxonomy(parent=parent, taxonomy=taxonomy)

# Create Policy Tag inside the Taxonomy
policy_tag = datacatalog_v1.PolicyTag(display_name="RestrictedFinancial")
created_policy_tag = client.create_policy_tag(parent=created_taxonomy.name, policy_tag=policy_tag)

Dengan menetapkan jenis kebijakan FINE_GRAINED_ACCESS_CONTROL secara eksplisit, Anda mengubah tag metadata standar menjadi batas keamanan tolak menurut default yang ketat. Secara default, kolom apa pun dengan tag ini akan menolak akses semua pengguna.

Membuat kebijakan penyamaran data dinamis

Sekarang, tentukan apa yang terjadi saat seseorang tanpa hak istimewa membuat kueri kolom yang diberi tag. Buat kebijakan penyamaran data yang secara otomatis mengganti nilai sensitif dengan NULL untuk persona Analis.

Jalankan skrip untuk mengonfigurasi aturan penyamaran:

python 2_create_masking.py

Di dalam 2_create_masking.py, skrip akan mencari ID untuk tag kebijakan yang Anda buat dan menerapkan kebijakan data ke akun layanan Analyst:

# Define a Masking Policy that always returns NULL
data_policy = bigquery_datapolicies_v1.DataPolicy(
    data_policy_id="mask_financial_null",
    policy_tag=policy_tag_id,
    data_policy_type=bigquery_datapolicies_v1.DataPolicy.DataPolicyType.DATA_MASKING_POLICY,
    data_masking_policy=bigquery_datapolicies_v1.DataMaskingPolicy(
        predefined_expression=bigquery_datapolicies_v1.DataMaskingPolicy.PredefinedExpression.ALWAYS_NULL
    )
)

# ... (Policy creation code) ...

# Bind the Masked Reader role to the Analyst
iam_policy.bindings.add(
    role="roles/bigquerydatapolicy.maskedReader", 
    members=[f"serviceAccount:{analyst_email}"]
)

Memberikan akses istimewa ke data Anda

Karena konfigurasi tolak menurut default, tidak ada yang dapat membaca kolom yang diberi tag. Anda harus memberikan akses secara eksplisit kepada pengguna yang diberi otorisasi. Berikan peran Fine-Grained Reader kepada persona Pengelola dan akun Anda sendiri. Hal ini memungkinkan pengguna tertentu ini melewati aturan penyamaran dan membaca data yang tidak disamarkan.

Jalankan skrip untuk memberikan akses:

python 3_grant_access.py

Di dalam 3_grant_access.py, skrip mengubah kebijakan IAM tag kebijakan:

# Grant original data read access
iam_policy.bindings.add(
    role="roles/datacatalog.categoryFineGrainedReader",
    members=[f"serviceAccount:{manager_email}", f"user:{current_user}"]
)
client.set_iam_policy(request=iam_policy_pb2.SetIamPolicyRequest(resource=policy_tag_id, policy=iam_policy))

Melampirkan tag keamanan ke skema tabel

Terakhir, Anda dapat menghubungkan aturan logis ke data sebenarnya. Perbarui skema tabel Iceberg Anda untuk melampirkan tag kebijakan secara langsung ke kolom amount. Setelah Anda melakukannya, Lakehouse akan langsung menerapkan perlindungan Anda di seluruh file tabel Iceberg dalam bucket Anda.

Jalankan skrip untuk melampirkan tag kebijakan:

python 4_attach_tag.py

Tinjau 4_attach_tag.py. Skrip mengambil skema tabel BigQuery, melakukan iterasi melalui kolom, dan melampirkan tag secara khusus ke kolom amount:

new_schema =[]
for field in table.schema:
    if field.name == 'amount':
        # Wrap the Policy Tag ID and attach it to the column
        policy_tags_list = bigquery.PolicyTagList(names=[policy_tag_id])
        new_field = bigquery.SchemaField(
            name=field.name, field_type=field.field_type, mode=field.mode,
            description=field.description, policy_tags=policy_tags_list
        )
        new_schema.append(new_field)
    else:
        new_schema.append(field)

# Update the table schema in BigQuery
table.schema = new_schema
client.update_table(table, ["schema"])

Memverifikasi kebijakan keamanan Anda

Jalankan beberapa kueri pengujian untuk memastikan izin Anda berfungsi seperti yang diharapkan. Untuk membuktikan bahwa Knowledge Catalog bertindak sebagai mesin konteks universal dengan menerapkan kebijakan keamanan yang sama saat Anda beralih mesin kueri, Anda menjalankan pengujian ini menggunakan BigQuery dan Apache Spark.

Pengujian dengan BigQuery SQL

Mulailah dengan memeriksa kebijakan Anda secara langsung di BigQuery. Ini adalah cara tercepat untuk mengonfirmasi bahwa aturan dan izin penyamaran Anda aktif.

Periksa sebagai Pengelola

Persona Pengelola memiliki akses pembaca dengan hak istimewa dan terperinci. Mereka akan melihat setiap detail dalam tabel, termasuk nilai di kolom amount.

# Impersonate the Manager
gcloud config set auth/impersonate_service_account ${EMAIL_MANAGER}

# Query the transactions table
bq query --use_legacy_sql=false "SELECT * FROM \`${PROJECT_ID}.${DATASET_ID}.transactions\`"

Karena pengelola memiliki peran Fine-Grained Reader, kueri menampilkan nilai jumlah mentah:

+----+----------+--------+------------------+
| id |   item   | amount | transaction_date |
+----+----------+--------+------------------+
|  1 | Widget A |  100.0 |       2024-01-01 |
|  3 | Widget C |   50.0 |       2024-01-03 |
|  2 | Widget B |  150.0 |       2024-01-02 |
+----+----------+--------+------------------+

Periksa sebagai Analis

Beralihlah ke persona Analis dan jalankan kueri yang sama.

gcloud config set auth/impersonate_service_account ${EMAIL_ANALYST}

bq query --use_legacy_sql=false "SELECT * FROM \`${PROJECT_ID}.${DATASET_ID}.transactions\`"

Meskipun Anda menjalankan kueri yang sama, Knowledge Catalog akan menyamarkan nilai sensitif di kolom amount:

+----+----------+--------+------------------+
| id |   item   | amount | transaction_date |
+----+----------+--------+------------------+
|  1 | Widget A |   NULL |       2024-01-01 |
|  3 | Widget C |   NULL |       2024-01-03 |
|  2 | Widget B |   NULL |       2024-01-02 |
+----+----------+--------+------------------+

Kembali ke akun Anda

Bersihkan status autentikasi Cloud Shell Anda untuk kembali ke pengguna administrator Anda.

gcloud config unset auth/impersonate_service_account

Pengujian dengan Apache Spark

Keamanan sering kali terganggu saat pengguna langsung membuka file data di Cloud Storage. Jika ilmuwan data menggunakan Apache Spark untuk membaca file tabel Iceberg secara langsung, mereka biasanya akan melewati aturan Anda karena Cloud Storage hanya memahami izin tingkat bucket.

Untuk mencegah hal ini, gunakan delegasi komputasi. Dengan menggunakan Spark-BigQuery Connector, Anda membuat jembatan aman yang merutekan semua permintaan Spark melalui BigQuery Storage API. Hal ini memastikan bahwa Knowledge Catalog memeriksa izin dan menerapkan aturan penyamaran sebelum data apa pun mencapai cluster Spark.

Upload skrip read_transactions.py ke bucket Cloud Storage Anda agar Managed Service untuk Apache Spark dapat mengaksesnya:

# Upload script to Cloud Storage
gsutil cp read_transactions.py gs://${ICEBERG_BUCKET}/scripts/read_transactions.py

Tinjau logika inti dalam skrip yang Anda upload:

# Reading data via Compute Delegation (Knowledge Catalog policies are applied dynamically here)
df = spark.read \
    .format("bigquery") \
    .option("table", f"{project_id}.{dataset_id}.{table_name}") \
    .load()

print("\n=== 📊 Data Preview ===")
df.show(truncate=False)

Skrip tidak mengarahkan Spark ke jalur gs:// file Iceberg. Dengan menentukan .format("bigquery"), BigQuery Storage API akan mencegat permintaan baca, memeriksa identitas pengguna yang menjalankan tugas Spark, menerapkan aturan penyamaran Knowledge Catalog, dan hanya menampilkan data yang diotorisasi ke DataFrame Spark.

Menjalankan Spark sebagai Pengelola

Kirimkan tugas Spark sebagai persona Pengelola. Gunakan Managed Service untuk Apache Spark, layanan terkelola yang memungkinkan Anda menjalankan workload Spark tanpa perlu repot mengelola cluster sendiri:

echo "🚀 Submitting Dataproc Serverless Job as [MANAGER]..."
gcloud dataproc batches submit pyspark gs://${ICEBERG_BUCKET}/scripts/read_transactions.py \
    --project=${PROJECT_ID} \
    --region=${REGION} \
    --service-account=${EMAIL_MANAGER} \
    --version=2.3 \
    -- ${PROJECT_ID} ${DATASET_ID} \
    --format="value(name)"

Tinjau log output tugas di terminal. Karena pengelola memiliki peran Fine-Grained Reader, Spark berhasil mengambil jumlah yang tidak disamarkan:

=== 📊 Data Preview ===
+---+--------+------+-------------------+
|id |item    |amount|transaction_date   |
+---+--------+------+-------------------+
|1  |Widget A|100.0 |2024-01-01         |
|2  |Widget B|150.0 |2024-01-02         |
|3  |Widget C|50.0  |2024-01-03         |
+---+--------+------+-------------------+

Menjalankan Spark sebagai Analis

Terakhir, jalankan kode Spark yang sama sebagai persona Analis:

echo "🚀 Submitting Dataproc Serverless Job as [ANALYST]..."
gcloud dataproc batches submit pyspark gs://${ICEBERG_BUCKET}/scripts/read_transactions.py \
    --project=${PROJECT_ID} \
    --region=${REGION} \
    --service-account=${EMAIL_ANALYST} \
    --version=2.3 \
    -- ${PROJECT_ID} ${DATASET_ID} \
    --format="value(name)"

Tinjau kembali log. Meskipun Analis menjalankan kode Spark yang sama, BigQuery Storage API mencegat permintaan dan menerapkan kebijakan Knowledge Catalog. DataFrame Spark Analis menampilkan null untuk jumlah.

=== 📊 Data Preview ===
+---+--------+------+-------------------+
|id |item    |amount|transaction_date   |
+---+--------+------+-------------------+
|1  |Widget A|null  |2024-01-01         |
|2  |Widget B|null  |2024-01-02         |
|3  |Widget C|null  |2024-01-03         |
+---+--------+------+-------------------+

Anda baru saja membuktikan bahwa, sebagai bidang kontrol pusat, Knowledge Catalog menerapkan kebijakan keamanan Anda secara konsisten, terlepas dari mesin kueri yang Anda gunakan.

Melihat perjalanan data Anda dengan silsilah otomatis

Lakehouse yang mematuhi kebijakan memerlukan lebih dari sekadar kontrol akses; lakehouse juga memerlukan jejak audit yang jelas. Silsilah data membantu Anda memahami asal data dan cara data ditransformasi. Menjawab pertanyaan penting seperti, "Tabel mentah mana yang digunakan untuk membuat laporan penjualan ini?" membantu Anda mempertahankan kepatuhan, men-debug pipeline data dengan cepat, dan membangun fondasi data yang andal.

Daripada menulis kode logging yang rumit secara manual, Knowledge Catalog secara otomatis melacak siklus proses ini di seluruh arsitektur Anda. Misalnya, saat Anda membuat tabel ringkasan sebelumnya dalam tutorial ini, BigQuery langsung merekam detail transformasi dan mengirimkannya ke Knowledge Catalog. Cara ini akan memperbarui konteks dan histori data Anda secara dinamis.

Mempelajari grafik silsilah interaktif

Lihat peta interaktif yang dibuat oleh Knowledge Catalog. Diagram ini menunjukkan cara data mentah mengalir dari tabel transactions ke tabel transactions_summary. Karena Knowledge Catalog mengumpulkan metadata sebagai mesin konteks dinamis, grafik ini menunjukkan ketertelusuran real-time yang andal yang Anda butuhkan untuk audit data.

  1. Di Google Cloud Konsol, buka Knowledge Catalog > Search.
  2. Ketik lakehouse_retail_demo.transactions_summary di kotak penelusuran, lalu klik tabel.
  3. Klik tab Silsilah.
Grafik silsilah data yang menunjukkan alur dari tabel transaksi ke tabel transactions_summary.
Grafik silsilah data

Grafik interaktif mengonfirmasi bahwa tabel target (transactions_summary) berasal dari tabel Iceberg mentah yang dikelola (transactions). Visualisasi ini menunjukkan ketertelusuran data Anda secara menyeluruh.

Pembersihan

Untuk mencegah biaya berkelanjutan, hapus resource yang Anda buat untuk tutorial ini.

Menghapus aset kebijakan dan metadata

Sebelum dapat menghapus set data BigQuery atau bucket Cloud Storage, Anda harus menghapus kebijakan tata kelola data dan aset metadata.

Jalankan skrip pembersihan Python:

python cleanup_governance.py

Tinjau skrip cleanup_governance.py dari repositori untuk menemukan logika penonaktifan berikut. Urutan penghapusan sangat penting. Pertama, Anda menghapus kebijakan penyamaran data. Kemudian, Anda menghapus taksonomi induk, yang secara otomatis menghapus semua tag kebijakan di bawahnya dan menghindari error dependensi resource.

# 1. Delete Data Policy
data_policy_name = f"{parent_loc}/dataPolicies/mask_financial_null"
dp_client.delete_data_policy(name=data_policy_name)

# 2. Find and Delete Taxonomy (This auto-deletes child Policy Tags)
taxonomies = catalog_client.list_taxonomies(parent=parent_loc)
taxonomy_id = next((t.name for t in taxonomies if t.display_name == "BusinessCritical"), None)
catalog_client.delete_taxonomy(name=taxonomy_id)

Menghapus aset identitas, penyimpanan, dan komputasi

Hapus tabel BigQuery, bucket Cloud Storage, akun layanan, dan lingkungan virtual Python lokal.

Salin dan jalankan skrip pembersihan berikut di Cloud Shell Anda:

echo "Deleting Service Accounts and Impersonation Bindings..."
export CURRENT_USER=$(gcloud config get-value account)

for USER in "${USER_ANALYST}" "${USER_MANAGER}"; do
    EMAIL="${USER}@${PROJECT_ID}.iam.gserviceaccount.com"
    
    # Remove impersonation binding
    gcloud iam service-accounts remove-iam-policy-binding ${EMAIL} \
        --member="user:${CURRENT_USER}" \
        --role="roles/iam.serviceAccountTokenCreator" \
        --quiet > /dev/null 2>&1
        
    # Delete the Service Account
    gcloud iam service-accounts delete ${EMAIL} --quiet
done

echo "Removing BigQuery Dataset and Tables..."
bq rm -f ${DATASET_ID}.transactions_summary
bq rm -f ${DATASET_ID}.transactions
bq rm -f ${DATASET_ID}.inventory
bq rm -f -d ${DATASET_ID}

echo "Removing BigQuery Cloud Resource Connection..."
bq rm --connection --location=${REGION} ${CONN_NAME}

echo "Removing Iceberg Cloud Storage Bucket..."
gcloud storage rm --recursive gs://${ICEBERG_BUCKET} --quiet

echo "Removing Auto-generated Dataproc Staging & Temp Buckets..."
for BUCKET in $(gcloud storage ls | grep -E "gs://dataproc-(staging|temp)-${REGION}"); do
    gcloud storage rm --recursive $BUCKET --quiet
done

echo "✅ Clean up completed successfully!"

Membersihkan file project:

echo "Deactivating and removing the local Python environment..."
deactivate
cd ../..
rm -rf devrel-demos

Kesimpulan

Anda telah berhasil membangun data lakehouse yang aman. Dengan menggunakan Lakehouse untuk Apache Iceberg guna mengelola tabel Iceberg, Anda dapat menjaga keamanan file tabel pokok di Cloud Storage. Dengan menetapkan Knowledge Catalog sebagai mesin konteks universal, Anda menentukan tag kebijakan di lokasi pusat dan menerapkannya secara konsisten di berbagai mesin kueri seperti BigQuery SQL dan Apache Spark. Terakhir, Anda secara otomatis melacak seluruh perjalanan data dengan silsilah data real-time.

Langkah berikutnya