Menggunakan kualitas data otomatis

Dokumen ini menjelaskan cara menggunakan pemindaian kualitas data Knowledge Catalog (sebelumnya Dataplex Universal Catalog) untuk mengukur, memantau, dan mengelola kualitas data Anda. Pemindaian kualitas data membantu Anda mengotomatiskan proses validasi data untuk kelengkapan, validitas, dan konsistensi.

Dengan pemindaian kualitas data, Anda dapat menentukan aturan untuk memeriksa nilai yang hilang, memastikan nilai cocok dengan ekspresi reguler atau termasuk dalam satu set, memverifikasi keunikan, atau menggunakan SQL kustom untuk validasi yang lebih kompleks seperti deteksi anomali. Dokumen ini menjelaskan cara membuat dan mengelola pemindaian kualitas data.

Pelajari lebih lanjut pemindaian kualitas data. Pelajari lebih lanjut cara menggunakan kembali aturan kualitas data di beberapa pemindaian.

Sebelum memulai

1. Mengaktifkan Dataplex API.

   Peran yang diperlukan untuk mengaktifkan API

   Untuk mengaktifkan API, Anda memerlukan izin serviceusage.services.enable. Jika Anda membuat project, kemungkinan Anda sudah memiliki izin ini melalui peran Pemilik (roles/owner). Jika tidak, Anda bisa mendapatkan izin ini melalui peran Admin Penggunaan Layanan (roles/serviceusage.serviceUsageAdmin). Pelajari cara memberikan peran.

   Mengaktifkan API

2. Opsional: Untuk membuat rekomendasi aturan kualitas data berdasarkan hasil pemindaian profil data, buat dan jalankan pemindaian profil data.

Peran dan izin yang diperlukan

Bagian ini menjelaskan peran dan izin IAM yang diperlukan untuk menggunakan pemindaian kualitas data Knowledge Catalog.

Peran dan izin pengguna

Untuk mendapatkan izin yang Anda perlukan untuk menjalankan dan mengelola pemindaian kualitas data, minta administrator untuk memberi Anda peran IAM berikut:

• Menjalankan pemindaian kualitas data pada tabel BigQuery:
  • BigQuery Job User (roles/bigquery.jobUser) di project untuk menjalankan tugas pemindaian
  • BigQuery Data Viewer (roles/bigquery.dataViewer) pada tabel BigQuery yang akan dipindai
• Memublikasikan hasil pemindaian kualitas data ke Knowledge Catalog:
  • BigQuery Data Editor (roles/bigquery.dataEditor) pada tabel yang dipindai
  • Dataplex Catalog Editor (roles/dataplex.catalogEditor) di grup entri @bigquery di lokasi yang sama dengan tabel
• Lakukan tugas tertentu pada resource DataScan:
  • Administrator Dataplex DataScan (roles/dataplex.dataScanAdmin) di project untuk akses penuh
  • Pembuat Dataplex DataScan (roles/dataplex.dataScanCreator) di project untuk membuat pemindaian
  • Dataplex DataScan Editor (roles/dataplex.dataScanEditor) di project untuk akses tulis
  • Pelihat Dataplex DataScan (roles/dataplex.dataScanViewer) di project untuk membaca metadata pemindaian
  • Dataplex DataScan DataViewer (roles/dataplex.dataScanDataViewer) di project untuk membaca data pemindaian, termasuk aturan dan hasil

Untuk mengetahui informasi selengkapnya tentang pemberian peran, lihat Mengelola akses ke project, folder, dan organisasi.

Peran bawaan ini berisi izin yang diperlukan untuk menjalankan dan mengelola pemindaian kualitas data. Untuk melihat izin yang benar-benar diperlukan, perluas bagian Izin yang diperlukan:

Anda mungkin juga bisa mendapatkan izin ini dengan peran khusus atau peran bawaan lainnya.

Jika Anda perlu mengakses kolom yang dilindungi oleh kebijakan akses tingkat kolom BigQuery, Anda juga memerlukan izin untuk kolom tersebut.

Peran dan izin akun layanan Knowledge Catalog

Jika Anda belum membuat pemindaian kualitas data atau profil data, atau Anda tidak memiliki data lake Knowledge Catalog di project ini, buat ID layanan dengan menjalankan: gcloud beta services identity create --service=dataplex.googleapis.com. Perintah ini akan menampilkan ID layanan Knowledge Catalog jika ada.

Untuk memastikan bahwa akun layanan Knowledge Catalog dari project yang berisi pemindaian kualitas data memiliki izin yang diperlukan untuk membaca data dari berbagai sumber dan mengekspor hasil, minta administrator Anda untuk memberikan peran IAM berikut kepada akun layanan Knowledge Catalog dari project yang berisi pemindaian kualitas data:

• Membaca data tabel BigQuery: BigQuery Data Viewer (roles/bigquery.dataViewer) pada tabel BigQuery yang akan dipindai dan tabel lain yang dirujuk dalam aturan
• Membaca data tabel Katalog REST Iceberg: Pelihat BigLake (roles/biglake.viewer) pada tabel Katalog REST Iceberg yang akan dipindai dan tabel lain yang dirujuk dalam aturan
• Mengekspor hasil pemindaian ke tabel BigQuery: BigQuery Data Editor (roles/bigquery.dataEditor) di set data dan tabel hasil
• Memindai data BigQuery yang disusun di danau Knowledge Catalog:
  • Dataplex Metadata Reader (roles/dataplex.metadataReader) pada resource Dataplex
  • Dataplex Viewer (roles/dataplex.viewer) pada resource Dataplex
• Memindai tabel eksternal BigQuery dari Cloud Storage: Storage Object Viewer (roles/storage.objectViewer) di bucket Cloud Storage

Untuk mengetahui informasi selengkapnya tentang pemberian peran, lihat Mengelola akses ke project, folder, dan organisasi.

Peran bawaan ini berisi izin yang diperlukan untuk membaca data dari berbagai sumber dan mengekspor hasil. Untuk melihat izin yang benar-benar diperlukan, perluas bagian Izin yang diperlukan:

Administrator Anda mungkin juga dapat memberikan izin ini kepada akun layanan Knowledge Catalog dari project yang berisi pemindaian kualitas data dengan peran khusus atau peran bawaan lainnya.

Jika Anda perlu mengakses kolom yang dilindungi oleh kebijakan akses tingkat kolom BigQuery, tetapkan izin akun layanan Knowledge Catalog untuk kolom tersebut.

Jika kebijakan akses tingkat baris BigQuery diaktifkan untuk tabel, Anda hanya dapat memindai baris yang terlihat oleh akun layanan Knowledge Catalog. Perhatikan bahwa hak akses pengguna perorangan tidak dievaluasi untuk kebijakan tingkat baris.

Persyaratan jaringan

Untuk menjalankan pemindaian, Anda harus mengaktifkan Akses Google Pribadi di subnet VPC yang Anda gunakan untuk pemindaian. Jika Anda tidak menentukan subnet, pastikan subnet default Anda telah mengaktifkan Akses Google Pribadi.

Menentukan aturan kualitas data

Anda dapat menentukan aturan kualitas data menggunakan hal berikut:

• Aturan bawaan

• Pemeriksaan SQL kustom

• Aturan yang dapat digunakan kembali, termasuk template aturan sistem

Jika menggunakan Google Cloud CLI, Anda dapat menentukan aturan ini dalam file JSON atau YAML.

Contoh di bagian berikut menunjukkan cara menentukan berbagai aturan kualitas data. Aturan ini memvalidasi tabel contoh yang berisi data tentang transaksi pelanggan. Asumsikan tabel memiliki skema berikut:

Menentukan aturan kualitas data menggunakan jenis aturan bawaan

Contoh berikut didasarkan pada jenis aturan bawaan. Anda dapat membuat aturan berdasarkan jenis aturan bawaan menggunakan konsol Google Cloud atau API. Knowledge Catalog mungkin merekomendasikan beberapa aturan ini.

Menentukan aturan kualitas data menggunakan aturan SQL kustom

Untuk membuat aturan SQL kustom, gunakan framework berikut:

• Saat Anda membuat aturan yang mengevaluasi satu baris dalam satu waktu, buat ekspresi yang menghasilkan jumlah baris yang berhasil saat Knowledge Catalog mengevaluasi kueri SELECT COUNTIF(CUSTOM_SQL_EXPRESSION) FROM TABLE. Knowledge Catalog memeriksa jumlah baris yang berhasil terhadap nilai minimum.

• Saat Anda membuat aturan yang mengevaluasi di seluruh baris atau menggunakan kondisi tabel, buat ekspresi yang menampilkan keberhasilan atau kegagalan saat Knowledge Catalog mengevaluasi kueri SELECT IF(CUSTOM_SQL_EXPRESSION) FROM TABLE.

• Saat Anda membuat aturan yang mengevaluasi status set data yang tidak valid, berikan pernyataan yang menampilkan baris yang tidak valid. Jika ada baris yang ditampilkan, aturan akan gagal. Hapus titik koma di akhir pernyataan SQL.

• Anda dapat merujuk ke tabel sumber data dan semua filter prasyaratnya dengan menggunakan parameter referensi data ${data()} dalam aturan, bukan dengan menyebutkan tabel sumber dan filternya secara eksplisit. Contoh filter prasyarat mencakup filter baris, persentase pengambilan sampel, dan filter inkremental. Parameter ${data()} peka huruf besar/kecil.

Contoh berikut didasarkan pada aturan SQL kustom.

        CREATE OR REPLACE FUNCTION
        myProject.myDataset.average_by_country (
          country STRING, average FLOAT64)
        RETURNS BOOL LANGUAGE js AS R"""
        if (country = "CAN" && average < 5000){
          return 1
        } else if (country = "IND" && average < 1000){
          return 1
        } else { return 0 }
        """;
       

        myProject.myDataset.average_by_country(
        "CAN",
        (SELECT avg(amount) FROM
          myProject.myDataset.transactions_table
            WHERE currency_id = 'CAN'
        ))
      

  CREATE MODEL
  model-project-id.dataset-id.model-name
        OPTIONS(model_type='logistic_reg') AS
  SELECT
  IF(discount_pct IS NULL, 0, 1) AS label,
  IFNULL(customer_id, "") AS customer,
  IFNULL(currency_id, "") AS currency,
  IFNULL(amount, 0.0) AS amount
  FROM
  `data-project-id.dataset-id.table-names`
  WHERE transaction_timestamp < '2022-01-01';
  

      SELECT
        accuracy > 0.99
      FROM
       ML.EVALUATE
        (MODEL model-project-id.dataset-id.model-name,
         (
          SELECT
            customer_id,
            currency_id,
            amount,
            discount_pct
          FROM
            data-project-id.dataset-id.table-names
          WHERE transaction_timestamp > '2022-01-01';
         )
        )
    

  CREATE MODEL
  model-project-id.dataset-id.model-name
        OPTIONS(model_type='logistic_reg') AS
  SELECT
  IF(discount_pct IS NULL, 0, 1) AS label,
  IFNULL(customer_id, "") AS customer,
  IFNULL(currency_id, "") AS currency,
  IFNULL(amount, 0.0) AS amount
  FROM
  `data-project-id.dataset-id.table-names`
  WHERE transaction_timestamp < '2022-01-01';
  

       IF(discount_pct > 0, 1, 0)
          =(SELECT predicted_label FROM
           ML.PREDICT(
            MODEL model-project-id.dataset-id.model-name,
              (
                SELECT
                  customer_id,
                  currency_id,
                  amount,
                  discount_pct
                FROM
                  data-project-id.dataset-id.table-names AS t
                    WHERE t.transaction_timestamp =
                     transaction_timestamp
                   LIMIT 1
              )
            )
         )
    

Menentukan aturan kualitas data menggunakan gcloud CLI

File YAML contoh berikut menggunakan beberapa aturan yang sama dengan contoh aturan menggunakan jenis bawaan dan contoh aturan SQL kustom. File YAML ini juga berisi spesifikasi lain untuk pemindaian kualitas data, seperti filter dan persentase pengambilan sampel. Saat menggunakan gcloud CLI untuk membuat atau mengupdate pemindaian kualitas data, Anda dapat menggunakan file YAML seperti ini sebagai input ke argumen --data-quality-spec-file.

rules:
- uniquenessExpectation: {}
  column: transaction_id
  dimension: UNIQUENESS
- nonNullExpectation: {}
  column: amount
  dimension: COMPLETENESS
  threshold: 1
- regexExpectation:
    regex: '^[a-zA-Z]{8}[0-9]{16}$'
  column : customer_id
  ignoreNull : true
  dimension : VALIDITY
  threshold : 1
- setExpectation :
    values :
    - 'USD'
    - 'JPY'
    - 'INR'
    - 'GBP'
    - 'CAN'
  column : currency_id
  ignoreNull : true
  dimension : VALIDITY
  threshold : 1
- rangeExpectation:
    minValue : '0'
    maxValue : '100'
  column : discount_pct
  ignoreNull : true
  dimension : VALIDITY
  threshold : 1
- rowConditionExpectation:
    sqlExpression : 0 < `discount_pct` AND `discount_pct` < 100
  column: discount_pct
  dimension: VALIDITY
  threshold: 1
- rowConditionExpectation:
    sqlExpression : currency_id in (select id from `my_project_id.dim_dataset.dim_currency`)
  column: currency_id
  dimension: VALIDITY
  threshold: 1
- tableConditionExpectation:
    sqlExpression : 30 < avg(discount_pct) AND avg(discount_pct) < 50
  dimension: VALIDITY
- rowConditionExpectation:
    sqlExpression : TIMESTAMP(transaction_timestamp) < CURRENT_TIMESTAMP()
  column: transaction_timestamp
  dimension: VALIDITY
  threshold: 1
- sqlAssertion:
    sqlStatement : SELECT * FROM `my_project_id.dim_dataset.dim_currency` WHERE discount_pct > 100
  dimension: VALIDITY
  debugQueries:
  - sqlStatement: SELECT MAX(discount_pct) FROM `my_project_id.dim_dataset.dim_currency`
samplingPercent: 50
rowFilter: discount_pct > 100
postScanActions:
  bigqueryExport:
    resultsTable: projects/my_project_id/datasets/dim_dataset/tables/dim_currency
  notificationReport:
    recipients:
      emails:
      - '222larabrown@gmail.com'
      - 'cloudysanfrancisco@gmail.com'
    scoreThresholdTrigger:
      scoreThreshold: 50
    jobFailureTrigger: {}
    jobEndTrigger: {}
catalogPublishingEnabled: true

Mengonfigurasi identitas eksekusi

Secara default, pemindaian kualitas data dijalankan menggunakan akun layanan Knowledge Catalog. Anda dapat mengganti setelan ini untuk menggunakan akun layanan kustom atau Kredensial Pengguna Akhir (EUC) Anda sendiri.

Menggunakan identitas eksekusi kustom akan mengubah cara penagihan pemindaian. Saat Anda menentukan identitas eksekusi kustom, biaya komputasi dan penyimpanan yang terkait dengan pemindaian akan ditagih langsung ke project BigQuery Anda, tanpa melalui SKU Premium Knowledge Catalog standar.

Izin yang diperlukan untuk identitas eksekusi kustom

Untuk mengonfigurasi akun layanan kustom atau menggunakan kredensial pengguna akhir, Anda harus memiliki izin Identity and Access Management (IAM) tambahan berikut:

• Untuk menggunakan akun layanan kustom, Anda memerlukan:
  • Izin iam.serviceAccounts.actAs yang diberikan untuk project yang berisi akun layanan (misalnya, roles/iam.serviceAccountUser).
  • Agen Layanan project Anda (service-PROJECT_NUMBER@gcp-sa-dataplex.iam.gserviceaccount.com) memerlukan izin iam.serviceAccounts.getAccessToken pada akun layanan kustom (misalnya, dengan memiliki peran roles/iam.serviceAccountTokenCreator).
  • Akun layanan kustom memerlukan bigquery.tables.getData pada tabel untuk memindai, bigquery.jobs.insert di project pemindaian, dan bigquery.dataEditor pada set data ekspor (jika menggunakan ekspor).
• Untuk menggunakan Kredensial Pengguna Akhir, Anda memerlukan:
  • bigquery.tables.getData di atas meja untuk dipindai.
  • bigquery.jobs.insert di project pemindaian.
  • bigquery.dataEditor pada set data ekspor (jika menggunakan ekspor).

Untuk mengonfigurasi identitas eksekusi, pilih salah satu opsi berikut:

"executionIdentity": {
  "serviceAccount": {
     "email": "YOUR_SERVICE_ACCOUNT_EMAIL"
  }
}
  

"executionIdentity": {
  "userCredential": {}
}
  

Membuat pemindaian kualitas data

gcloud dataplex datascans create data-quality DATASCAN \
    --location=LOCATION \
    --data-quality-spec-file=DATA_QUALITY_SPEC_FILE \
    --data-source-entity=DATA_SOURCE_ENTITY

gcloud dataplex datascans create data-quality DATASCAN \
    --location=LOCATION \
    --data-quality-spec-file=DATA_QUALITY_SPEC_FILE \
    --data-source-resource=DATA_SOURCE_RESOURCE

using Google.Api.Gax.ResourceNames;
using Google.Cloud.Dataplex.V1;
using Google.LongRunning;

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for CreateDataScan</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void CreateDataScanRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        CreateDataScanRequest request = new CreateDataScanRequest
        {
            ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
            DataScan = new DataScan(),
            DataScanId = "",
            ValidateOnly = false,
        };
        // Make the request
        Operation<DataScan, OperationMetadata> response = dataScanServiceClient.CreateDataScan(request);

        // Poll until the returned long-running operation is complete
        Operation<DataScan, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        DataScan result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<DataScan, OperationMetadata> retrievedResponse = dataScanServiceClient.PollOnceCreateDataScan(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            DataScan retrievedResult = retrievedResponse.Result;
        }
    }
}

//go:build examples

package main

import (
	"context"

	dataplex "cloud.google.com/go/dataplex/apiv1"
	dataplexpb "cloud.google.com/go/dataplex/apiv1/dataplexpb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := dataplex.NewDataScanClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.CreateDataScanRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#CreateDataScanRequest.
	}
	op, err := c.CreateDataScan(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

	resp, err := op.Wait(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

import com.google.cloud.dataplex.v1.CreateDataScanRequest;
import