A partire dal 10 aprile 2026, Dataplex Universal Catalog si chiama Knowledge Catalog. I nomi di API, libreria client, CLI e IAM rimangono invariati. Per ulteriori informazioni, consulta Presentazione di Google Cloud Knowledge Catalog.

Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Utilizzare la qualità dei dati automatica

Questo documento descrive come utilizzare le scansioni della qualità dei dati di Knowledge Catalog (in precedenza Dataplex Universal Catalog) per misurare, monitorare e gestire la qualità dei dati. Le scansioni della qualità dei dati ti aiutano ad automatizzare il processo di convalida dei dati per verificarne la completezza, la validità e la coerenza.

Con le scansioni della qualità dei dati, puoi definire regole per verificare la presenza di valori mancanti, assicurarti che i valori corrispondano a un'espressione regolare o appartengano a un insieme, verificare l'unicità o utilizzare SQL personalizzato per convalide più complesse, come il rilevamento di anomalie. Questo documento spiega come creare e gestire le scansioni della qualità dei dati.

Scopri di più sulle scansioni della qualità dei dati. Scopri di più sul riutilizzo delle regole di qualità dei dati in più scansioni.

Prima di iniziare

Abilita l'API Dataplex, se non è già abilitata.
Ruoli richiesti per abilitare le API
Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente hai già questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore Service Usage (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli.
Abilitare l'API
(Facoltativo) Per generare suggerimenti per le regole di qualità dei dati in base ai risultati di una scansione di profilazione dei dati, crea ed esegui la scansione di profilazione dei dati.

Ruoli e autorizzazioni richiesti

Questa sezione descrive i ruoli e le autorizzazioni IAM necessari per utilizzare le scansioni della qualità dei dati di Knowledge Catalog.

Ruoli utente e autorizzazioni

Per ottenere le autorizzazioni necessarie per eseguire e gestire le scansioni della qualità dei dati, chiedi all'amministratore di concederti i seguenti ruoli IAM:

Esegui una scansione della qualità dei dati su una tabella BigQuery:
- Utente job BigQuery (roles/bigquery.jobUser) sul progetto per eseguire i job di scansione
- BigQuery Data Viewer (roles/bigquery.dataViewer) sulla tabella BigQuery da scansionare
Pubblica i risultati della scansione della qualità dei dati in Knowledge Catalog:
- BigQuery Data Editor (roles/bigquery.dataEditor) sulla tabella scansionata
- Dataplex Catalog Editor (roles/dataplex.catalogEditor) nel gruppo di voci @bigquery nella stessa posizione della tabella
Eseguire attività specifiche sulle risorse DataScan:
- Dataplex DataScan Administrator (roles/dataplex.dataScanAdmin) sul progetto per l'accesso completo
- Dataplex DataScan Creator (roles/dataplex.dataScanCreator) sul progetto per creare scansioni
- Dataplex DataScan Editor (roles/dataplex.dataScanEditor) sul progetto per l'accesso in scrittura
- Dataplex DataScan Viewer (roles/dataplex.dataScanViewer) sul progetto per leggere i metadati di scansione
- Dataplex DataScan DataViewer (roles/dataplex.dataScanDataViewer) sul progetto per leggere i dati di scansione, incluse regole e risultati

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questi ruoli predefiniti contengono le autorizzazioni necessarie per eseguire e gestire le scansioni della qualità dei dati. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per eseguire e gestire le scansioni della qualità dei dati sono necessarie le seguenti autorizzazioni:

Esegui una scansione della qualità dei dati su una tabella BigQuery:
- bigquery.jobs.create sul progetto per eseguire i job di scansione
- bigquery.tables.get sulla tabella BigQuery da scansionare
- bigquery.tables.getData sulla tabella BigQuery da scansionare
Pubblica i risultati della scansione della qualità dei dati in Knowledge Catalog:
- bigquery.tables.update sulla tabella scansionata
- dataplex.entryGroups.useDataQualityScorecardAspect sul gruppo di voci @bigquery nella stessa località della tabella
Crea un DataScan: dataplex.datascans.create sul progetto
Elimina un DataScan: dataplex.datascans.delete sul progetto
Visualizza i metadati DataScan: dataplex.datascans.get sul progetto
Visualizza i dettagli di DataScan, tra cui regole e risultati: dataplex.datascans.getData sul progetto
Elenca DataScan: dataplex.datascans.list sul progetto
Esegui un DataScan: dataplex.datascans.run sul progetto
Aggiorna un DataScan: dataplex.datascans.update sul progetto
Recupera o imposta la policy IAM su un DataScan:
- dataplex.datascans.getIamPolicy sul progetto
- dataplex.datascans.setIamPolicy sul progetto

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Se devi accedere alle colonne protette dalle policy di accesso a livello di colonna di BigQuery, devi disporre anche delle autorizzazioni per queste colonne.

Ruoli e autorizzazioni del account di servizio di Knowledge Catalog

Se non hai creato scansioni della qualità dei dati o scansioni di profilazione dei dati o se non hai un lake Knowledge Catalog in questo progetto, crea un identificatore di servizio eseguendo: gcloud beta services identity create --service=dataplex.googleapis.com. Questo comando restituisce un identificatore del servizio Knowledge Catalog, se esiste.

Per assicurarti che il account di servizio di Knowledge Catalog del progetto contenente l'analisi della qualità dei dati disponga delle autorizzazioni necessarie per leggere i dati da varie origini ed esportare i risultati, chiedi all'amministratore di concedere i seguenti ruoli IAM al account di servizio di Knowledge Catalog del progetto contenente l'analisi della qualità dei dati:

Lettura dei dati delle tabelle BigQuery: Visualizzatore dati BigQuery (roles/bigquery.dataViewer) sulle tabelle da scansionare e su qualsiasi altra tabella a cui fanno riferimento le regole
Leggi i dati delle tabelle Lakehouse di Iceberg REST Catalog, SAP Business Data Cloud Delta Lake e Apache Hive su Google Cloud : BigLake Viewer (roles/biglake.viewer) sulle rispettive tabelle da scansionare e su qualsiasi altra tabella a cui si fa riferimento nelle regole
Esportare i risultati della scansione in una tabella BigQuery: BigQuery Data Editor (roles/bigquery.dataEditor) nel set di dati e nella tabella dei risultati
Scansiona i dati BigQuery organizzati in un lake di Knowledge Catalog:
- Dataplex Metadata Reader (roles/dataplex.metadataReader) sulle risorse Dataplex
- Dataplex Viewer (roles/dataplex.viewer) sulle risorse Dataplex
Scansiona una tabella esterna BigQuery da Cloud Storage: Storage Object Viewer (roles/storage.objectViewer) sul bucket Cloud Storage

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questi ruoli predefiniti contengono le autorizzazioni necessarie per leggere i dati da varie origini ed esportare i risultati. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per leggere i dati da varie origini ed esportare i risultati sono necessarie le seguenti autorizzazioni:

Leggi i dati della tabella BigQuery:
- bigquery.tables.get su tabelle BigQuery
- bigquery.tables.getData su tabelle BigQuery
Esporta i risultati della scansione in una tabella BigQuery:
- bigquery.datasets.get sul set di dati e sulla tabella dei risultati
- bigquery.tables.create sul set di dati e sulla tabella dei risultati
- bigquery.tables.get sul set di dati e sulla tabella dei risultati
- bigquery.tables.getData sul set di dati e sulla tabella dei risultati
- bigquery.tables.update sul set di dati e sulla tabella dei risultati
- bigquery.tables.updateData sul set di dati e sulla tabella dei risultati
Scansiona i dati BigQuery organizzati in un lake Knowledge Catalog:
- dataplex.lakes.list sulle risorse Dataplex
- dataplex.lakes.get sulle risorse Dataplex
- dataplex.zones.list sulle risorse Dataplex
- dataplex.zones.get sulle risorse Dataplex
- dataplex.entities.list sulle risorse Dataplex
- dataplex.entities.get sulle risorse Dataplex
- dataplex.operations.get sulle risorse Dataplex
Scansiona una tabella esterna BigQuery da Cloud Storage:
- storage.buckets.get sul bucket Cloud Storage
- storage.objects.get sul bucket Cloud Storage

L'amministratore potrebbe anche essere in grado di concedere al account di servizio Knowledge Catalog del progetto contenente la scansione della qualità dei dati queste autorizzazioni tramite ruoli personalizzati o altri ruoli predefiniti.

Se devi accedere alle colonne protette dalle policy di accesso a livello di colonna di BigQuery, assegna i permessi dell'account di servizio Knowledge Catalog per queste colonne.

Se per una tabella sono abilitati i criteri di accesso a livello di riga di BigQuery, puoi scansionare solo le righe visibili al account di servizio di Knowledge Catalog. Tieni presente che i privilegi di accesso dei singoli utenti non vengono valutati per le policy a livello di riga.

Requisiti di networking

Per eseguire un'analisi, devi abilitare l'accesso privato Google nella subnet VPC che utilizzi per l'analisi. Se non specifichi una subnet, assicurati che l'accesso privato Google sia abilitato per la subnet predefinita.

Definisci le regole sulla qualità dei dati

Puoi definire le regole di qualità dei dati utilizzando:

Se utilizzi Google Cloud CLI, puoi definire queste regole in un file JSON o YAML.

Gli esempi nelle sezioni seguenti mostrano come definire una serie di regole per la qualità dei dati. Le regole convalidano una tabella di esempio che contiene dati sulle transazioni dei clienti. Supponiamo che la tabella abbia il seguente schema:

Nome colonna	Tipo di colonna	Descrizione colonna
transaction_timestamp	Timestamp	Timestamp della transazione. La tabella è partizionata in base a questo campo.
customer_id	Stringa	Un ID cliente nel formato di 8 lettere seguite da 16 cifre.
transaction_id	Stringa	L'ID transazione deve essere univoco nella tabella.
currency_id	Stringa	Una delle valute supportate. Il tipo di valuta deve corrispondere a una delle valute disponibili nella tabella delle dimensioni `dim_currency`.
quantità	float	Importo della transazione.
discount_pct	float	Percentuale di sconto. Questo valore deve essere compreso tra 0 e 100.

Definisci le regole sulla qualità dei dati utilizzando i tipi di regole integrati

I seguenti esempi si basano su tipi di regole integrate. Puoi creare regole basate su tipi di regole integrate utilizzando la console Google Cloud o l'API. Knowledge Catalog potrebbe consigliare alcune di queste regole.

Nome colonna	Tipo di regola	Dimensione suggerita	Parametri delle regole
`transaction_id`	Controllo unicità	Unicità	Soglia: `Not Applicable`
`amount`	Controllo NULL	Completezza	Soglia: `100%`
`customer_id`	Controllo regex (espressione regolare)	Validità	Espressione regolare: `^[a-zA-Z]{8}[0-9]{16}$` Soglia: `100%`
`currency_id`	Controllo valore-set	Validità	Insieme di: `USD,JPY,INR,GBP,CAN` Soglia: `100%`

Definisci le regole sulla qualità dei dati utilizzando regole SQL personalizzate

Per creare regole SQL personalizzate, utilizza il seguente framework:

Quando crei una regola che valuta una riga alla volta, crea un'espressione che genera il numero di righe riuscite quando Knowledge Catalog valuta la query SELECT COUNTIF(CUSTOM_SQL_EXPRESSION) FROM TABLE. Knowledge Catalog confronta il numero di righe riuscite con la soglia.
Quando crei una regola che esegue la valutazione tra le righe o utilizza una condizione della tabella, crea un'espressione che restituisca l'esito positivo o negativo quando Knowledge Catalog valuta la query SELECT IF(CUSTOM_SQL_EXPRESSION) FROM TABLE.
Quando crei una regola che valuta lo stato non valido di un set di dati, fornisci un'istruzione che restituisca righe non valide. Se vengono restituite delle righe, la regola non riesce. Ometti il punto e virgola finale dall'istruzione SQL.
Puoi fare riferimento a una tabella dell'origine dati e a tutti i relativi filtri di precondizione utilizzando il parametro di riferimento dei dati ${data()} in una regola, anziché menzionare esplicitamente la tabella di origine e i relativi filtri. Esempi di filtri di precondizione includono filtri di riga, percentuali di campionamento e filtri incrementali. Il parametro ${data()} è sensibile alle maiuscole.

Gli esempi seguenti si basano su regole SQL personalizzate.

Tipo di regola	Descrizione regola	Espressione SQL
Condizione di riga	Controlla se il valore di `discount_pct` è compreso tra 0 e 100.	`0` <`discount_pct` AND `discount_pct` < `100`
Condizione di riga	Controllo di riferimento per verificare che `currency_id` sia una delle valute supportate.	`currency_id in (select id from my_project_id.dim_dataset.dim_currency)`
Condizione della tabella	Espressione SQL aggregata che controlla se la media di `discount_pct` è compresa tra il 30% e il 50%.	`30<avg(discount) AND avg(discount) <50`
Condizione di riga	Controlla se una data non è nel futuro.	`TIMESTAMP(transaction_timestamp) < CURRENT_TIMESTAMP()`
Condizione della tabella	Una funzione definita dall'utente (UDF) di BigQuery per verificare che l'importo medio della transazione sia inferiore a un valore predefinito per paese. Crea la funzione definita dall'utente (JavaScript) eseguendo questo comando: 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 } """;	Regola di esempio per controllare l'importo medio delle transazioni per `country=CAN`. myProject.myDataset.average_by_country( "CAN", (SELECT avg(amount) FROM myProject.myDataset.transactions_table WHERE currency_id = 'CAN' ))
Condizione della tabella	Una clausola di previsione BigQuery ML per identificare le anomalie in `discount_pct`. Controlla se deve essere applicato uno sconto in base a `customer`, `currency` e `transaction`. La regola verifica se la previsione corrisponde al valore effettivo, almeno il 99% delle volte. Presupposto: il modello ML viene creato prima di utilizzare la regola. Crea il modello ML utilizzando il seguente comando: 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';	La seguente regola controlla se l'accuratezza della previsione è superiore al 99%. 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'; ) )
Condizione di riga	Una funzione di previsione di BigQuery ML per identificare le anomalie in `discount_pct`. La funzione controlla se deve essere applicato uno sconto in base a `customer`, `currency` e `transaction`. La regola identifica tutte le occorrenze in cui la previsione non corrisponde. Presupposto: il modello ML viene creato prima di utilizzare la regola. Crea il modello ML utilizzando il seguente comando: 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';	La regola seguente controlla se la previsione dello sconto corrisponde al valore effettivo per ogni riga. 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 ) ) )
Asserzione SQL	Convalida se `discount_pct` è superiore al 30% per oggi controllando se esistono righe con una percentuale di sconto inferiore o uguale a 30.	`SELECT * FROM my_project_id.dim_dataset.dim_currency WHERE discount_pct <= 30 AND transaction_timestamp >= current_date()`
Asserzione SQL (con parametro di riferimento dei dati)	Controlla se il valore `discount_pct` è superiore al 30% per tutte le valute supportate oggi. Il filtro della data `transaction_timestamp >= current_date()` viene applicato come filtro di riga alla tabella dell'origine dati. Il parametro di riferimento dei dati `${data()}` funge da segnaposto per `my_project_id.dim_dataset.dim_currency WHERE transaction_timestamp >= current_date()` e applica il filtro di riga.	`SELECT * FROM ${data()} WHERE discount_pct > 30`

Definisci le regole sulla qualità dei dati utilizzando gcloud CLI

Il seguente file YAML di esempio utilizza alcune delle stesse regole delle regole di esempio che utilizzano tipi integrati e delle regole SQL personalizzate di esempio. Questo file YAML contiene anche altre specifiche per l'analisi della qualità dei dati, come filtri e percentuale di campionamento. Quando utilizzi gcloud CLI per creare o aggiornare un controllo della qualità dei dati, puoi utilizzare un file YAML come questo come input per l'argomento --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

Configura l'identità di esecuzione

Per impostazione predefinita, le scansioni della qualità dei dati vengono eseguite utilizzando l'account di servizio Knowledge Catalog. Puoi eseguire l'override di questa impostazione per utilizzare un account di servizio personalizzato o le tue credenziali utente finali (EUC).

L'utilizzo di un'identità di esecuzione personalizzata modifica il modo in cui ti viene addebitato il costo dell'analisi. Quando specifichi un'identità di esecuzione personalizzata, i costi di calcolo e archiviazione associati alla scansione vengono fatturati direttamente al tuo progetto BigQuery, bypassando gli SKU Knowledge Catalog Premium standard.

Autorizzazioni richieste per le identità di esecuzione personalizzate

Per configurare un account di servizio personalizzato o utilizzare le credenziali dell'utente finale, devi disporre delle seguenti autorizzazioni aggiuntive di Identity and Access Management (IAM):

Per utilizzare un service account personalizzato, devi disporre di:
- L'autorizzazione iam.serviceAccounts.actAs concessa per il progetto che contiene il account di servizio (ad esempio roles/iam.serviceAccountUser).
- L'agente di servizio del tuo progetto (service-PROJECT_NUMBER@gcp-sa-dataplex.iam.gserviceaccount.com) deve disporre dell'autorizzazione iam.serviceAccounts.getAccessToken sul service account personalizzato (ad esempio, con il ruolo roles/iam.serviceAccountTokenCreator).
- Il account di servizio personalizzato deve avere bigquery.tables.getData sulla tabella da scansionare, bigquery.jobs.insert nel progetto di scansione e bigquery.dataEditor sul set di dati di esportazione (se utilizzi l'esportazione).
Per utilizzare le credenziali utente finale, devi disporre di:
- bigquery.tables.getData sulla tabella da scansionare.
- bigquery.jobs.insert nel progetto di scansione.
- bigquery.dataEditor sul set di dati di esportazione (se utilizzi l'esportazione).

Per configurare l'identità di esecuzione, seleziona una delle seguenti opzioni:

Console

Per configurare l'identità di esecuzione nella console Google Cloud , seleziona l'identità quando crei l'analisi della qualità dei dati.

Nella sezione Identità di esecuzione, seleziona una delle seguenti opzioni:

Agente di servizio Dataplex: il comportamento predefinito.
Service account: inserisci l'indirizzo email del account di servizio che vuoi utilizzare.
Credenziali utente: utilizza le tue credenziali per eseguire l'analisi.

REST

Per utilizzare un account di servizio personalizzato, aggiungi l'oggetto executionIdentity alla definizione della risorsa DataScan durante la richiesta create:

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

Sostituisci quanto segue:

YOUR_SERVICE_ACCOUNT_EMAIL: l'indirizzo email del account di servizio che vuoi utilizzare.

Per utilizzare le credenziali dell'utente finale, specifica invece l'oggetto userCredential:

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

Crea una scansione della qualità dei dati

Console

Nella console Google Cloud , vai alla pagina Profilazione e qualità dei dati di Knowledge Catalog.

Vai a Profilazione e qualità dei dati
Fai clic su Crea scansione della qualità dei dati.
Nella finestra Definisci scansione, compila i seguenti campi:
1. (Facoltativo) Inserisci un Nome visualizzato.
2. Inserisci un ID. Consulta le convenzioni di denominazione delle risorse.
3. Facoltativo: inserisci una descrizione.
4. Nel campo Tabella, fai clic su Sfoglia. Scegli la tabella da scansionare e poi fai clic su Seleziona. Sono supportate solo le tabelle BigQuery standard, il catalogo REST Iceberg, SAP BDC Delta e Hive su Lakehouse Google Cloud.
  
  Per le tabelle in set di dati multiregionali, scegli una regione in cui creare la scansione dei dati.
  
  Per sfogliare le tabelle organizzate nei lake Knowledge Catalog, fai clic su Sfoglia i lake Knowledge Catalog.
5. Nel campo Ambito, scegli Incrementale o Tutti i dati.
  - Se scegli Incrementale: nel campo Colonna timestamp, seleziona una colonna di tipo DATE o TIMESTAMP dalla tabella BigQuery che aumenta man mano che vengono aggiunti nuovi record e che può essere utilizzata per identificare i nuovi record. Può essere una colonna che partiziona la tabella.
6. (Facoltativo) Per filtrare i dati, seleziona la casella di controllo Filtra righe. Fornisci un filtro di riga costituito da un'espressione SQL valida che può essere utilizzata come parte di una clausola WHERE nella sintassi GoogleSQL. Ad esempio: col1 >= 0. Il filtro può essere una combinazione di più condizioni di colonna. Ad esempio, col1 >= 0 AND col2 < 10.
7. Per campionare i dati, nell'elenco Dimensione di campionamento, seleziona una percentuale di campionamento. Scegli un valore percentuale compreso tra lo 0,0% e il 100,0% con un massimo di 3 cifre decimali. Per set di dati più grandi, scegli una percentuale di campionamento inferiore. Ad esempio, per una tabella da 1 PB, se inserisci un valore compreso tra lo 0,1% e l'1,0%, l'analisi della qualità dei dati campiona tra 1 e 10 TB di dati. Per le scansioni dei dati incrementali, la scansione della qualità dei dati applica il campionamento all'ultimo incremento.
8. (Facoltativo) Per pubblicare i risultati della scansione della qualità dei dati come metadati di Knowledge Catalog, seleziona la casella di controllo Pubblica i risultati in Knowledge Catalog.
  
  Puoi visualizzare i risultati della scansione più recente nella scheda Qualità dei dati nelle pagine BigQuery e Knowledge Catalog della tabella di origine. Per consentire agli utenti di accedere ai risultati della scansione pubblicati, consulta la sezione Concedi l'accesso ai risultati della scansione della qualità dei dati di questo documento.
9. Per Tipo di credenziale, consulta Configura l'identità di esecuzione.
10. Per creare un'analisi della qualità dei dati utilizzando le regole, seleziona Tipo di regola > Crea con regola basata su voce.
11. Nella sezione Pianificazione, scegli una delle seguenti opzioni:
  - Ripeti: esegui la scansione della qualità dei dati in base a una pianificazione: ogni ora, ogni giorno, ogni settimana, ogni mese o personalizzata. Specifica la frequenza e l'ora di esecuzione dell'analisi. Se scegli Personalizzata, utilizza il formato cron per specificare la pianificazione.
  - On demand: esegui la scansione della qualità dei dati on demand.
  - Esecuzione una tantum: esegui la scansione della qualità dei dati una volta ora e rimuovila dopo il tempo di eliminazione automatica. Questa funzionalità è in anteprima.
    - Imposta l'eliminazione automatica dei risultati post-scansione: il tempo di eliminazione automatica è l'intervallo di tempo tra l'esecuzione della scansione e la sua eliminazione. Una scansione della qualità dei dati senza un tempo di eliminazione automatica specificato viene eliminata automaticamente 24 ore dopo la sua esecuzione. Il tempo di eliminazione automatica può variare da 0 secondi (eliminazione immediata) a 365 giorni.
12. Fai clic su Continua.
Nella finestra Regole sulla qualità dei dati, definisci le regole da configurare per questa scansione della qualità dei dati.
1. Fai clic su Aggiungi regole, quindi scegli una delle seguenti opzioni.
  - Suggerimenti basati sul profilo: crea regole dai suggerimenti in base a una scansione di profilazione dei dati esistente.
    1. Scegli colonne: seleziona le colonne per cui vuoi ricevere regole consigliate.
    2. Scegli progetto di analisi: se la scansione di profilazione dei dati si trova in un progetto diverso da quello in cui stai creando la scansione della qualità dei dati, seleziona il progetto da cui estrarre le scansioni del profilo.
    3. Scegli i risultati del profilo: seleziona uno o più risultati del profilo e poi fai clic su Ok. In questo modo viene compilato un elenco di regole suggerite che puoi utilizzare come punto di partenza.
    4. Seleziona la casella di controllo corrispondente alle regole che vuoi aggiungere e poi fai clic su Seleziona. Una volta selezionate, le regole vengono aggiunte all'elenco delle regole attuali. Poi, puoi modificare le regole.
  - Tipi di regole integrate: crea regole a partire da regole predefinite. Consulta l'elenco delle regole preconfigurate.
    1. Scegli colonne: seleziona le colonne per cui selezionare le regole.
    2. Scegli i tipi di regole: seleziona i tipi di regole tra cui vuoi scegliere, quindi fai clic su Ok. I tipi di regole visualizzati dipendono dalle colonne selezionate.
    3. Seleziona la casella di controllo corrispondente alle regole che vuoi aggiungere e poi fai clic su Seleziona. Una volta selezionate, le regole vengono aggiunte all'elenco delle regole attuali. Poi, puoi modificare le regole.
  - Regola per il controllo delle righe SQL: crea una regola SQL personalizzata da applicare a ogni riga.
    1. In Dimensione, scegli una dimensione.
    2. In Soglia di superamento, scegli una percentuale di record che devono superare il controllo.
    3. In Nome colonna, scegli una colonna.
    4. Nel campo Fornisci un'espressione SQL, inserisci un'espressione SQL che restituisce un valore booleano true (superato) o false (non superato). Per saperne di più, consulta Tipi di regole SQL personalizzate supportate e gli esempi in Definisci le regole di qualità dei dati.
    5. Fai clic su Aggiungi.
  - Regola per il controllo aggregato SQL: crea una regola per la condizione della tabella SQL personalizzata.
    1. In Dimensione, scegli una dimensione.
    2. In Nome colonna, scegli una colonna.
    3. Nel campo Fornisci un'espressione SQL, inserisci un'espressione SQL che restituisce un valore booleano true (superato) o false (non superato). Per saperne di più, consulta Tipi di regole SQL personalizzate supportate e gli esempi in Definisci le regole di qualità dei dati.
    4. Fai clic su Aggiungi.
  - Regola di asserzione SQL: crea una regola di asserzione SQL personalizzata per verificare la presenza di uno stato non valido dei dati.
    1. In Dimensione, scegli una dimensione.
    2. (Facoltativo) In Nome colonna, scegli una colonna.
    3. Nel campo Fornisci un'istruzione SQL, inserisci un'istruzione SQL che restituisca le righe corrispondenti allo stato non valido. Se vengono restituite delle righe, questa regola non riesce. Ometti il punto e virgola finale dall'istruzione SQL. Per saperne di più, consulta Tipi di regole SQL personalizzate supportate e gli esempi in Definisci le regole di qualità dei dati.
    4. Fai clic su Aggiungi.
2. (Facoltativo) Per qualsiasi regola di qualità dei dati, puoi assegnare un nome personalizzato da utilizzare per il monitoraggio e gli avvisi e una descrizione. Per farlo, modifica una regola e specifica i seguenti dettagli:
  - Nome regola: inserisci un nome della regola personalizzato di massimo 63 caratteri. Il nome della regola può includere lettere (a-z, A-Z), cifre (0-9) e trattini (-) e deve iniziare con una lettera e terminare con un numero o una lettera.
  - Descrizione: inserisci una descrizione della regola con una lunghezza massima di 1024 caratteri.
3. Ripeti i passaggi precedenti per aggiungere altre regole all'analisi della qualità dei dati. Al termine, fai clic su Continua.
(Facoltativo) Esporta i risultati della scansione in una tabella BigQuery standard. Nella sezione Esporta i risultati della scansione in una tabella BigQuery, segui questi passaggi:
1. Nel campo Seleziona set di dati BigQuery, fai clic su Sfoglia. Seleziona un set di dati BigQuery per archiviare i risultati della scansione della qualità dei dati.
2. Nel campo Tabella BigQuery, specifica la tabella in cui archiviare i risultati della scansione della qualità dei dati. Se utilizzi una tabella esistente, assicurati che sia compatibile con lo schema della tabella di esportazione. Se la tabella specificata non esiste, Knowledge Catalog la crea per te.
  
  Nota: puoi utilizzare la stessa tabella dei risultati per più scansioni della qualità dei dati.
(Facoltativo) Aggiungi delle etichette. Le etichette sono coppie chiave-valore che consentono di raggruppare oggetti correlati fra loro o con altre risorse Google Cloud .
(Facoltativo) Configura i report di notifica via email per avvisare le persone dello stato e dei risultati di un job di scansione della qualità dei dati. Nella sezione Report sulle notifiche, fai clic su Aggiungi ID email e inserisci fino a cinque indirizzi email. Poi, seleziona gli scenari per i quali vuoi inviare i report:
- Punteggio di qualità (<=): invia un report quando un job viene eseguito correttamente con un punteggio di qualità dei dati inferiore al punteggio target specificato. Inserisci un punteggio di qualità target compreso tra 0 e 100.
- Errori dei job: invia un report quando il job non va a buon fine, indipendentemente dai risultati della qualità dei dati.
- Completamento job (con esito positivo o negativo): invia un report al termine del job, indipendentemente dai risultati della qualità dei dati.
Fai clic su Crea.

Dopo aver creato l'analisi, puoi eseguirla in qualsiasi momento facendo clic su Esegui ora.

gcloud

Per creare un'analisi della qualità dei dati, utilizza il comando gcloud dataplex datascans create data-quality.

Se i dati di origine sono organizzati in un lake di Knowledge Catalog, includi il flag --data-source-entity:

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

Se i dati di origine non sono organizzati in un lake Knowledge Catalog, includi il flag --data-source-resource:

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

Sostituisci le seguenti variabili:

DATASCAN: il nome della scansione della qualità dei dati.
LOCATION: la regione Google Cloud in cui creare l'analisi della qualità dei dati.
DATA_QUALITY_SPEC_FILE: il percorso del file JSON o YAML contenente le specifiche per l'analisi della qualità dei dati. Il file può essere un file locale o un percorso di Cloud Storage con il prefisso gs://. Utilizza questo file per specificare le regole di qualità dei dati per la scansione. In questo file puoi anche specificare ulteriori dettagli, come filtri, percentuale di campionamento e azioni post-scansione, ad esempio l'esportazione in BigQuery o l'invio di report di notifica via email. Consulta la documentazione per la rappresentazione JSON e l'esempio di rappresentazione YAML.
DATA_SOURCE_ENTITY: l'entità Knowledge Catalog che contiene i dati per la scansione della qualità dei dati. Ad esempio, projects/test-project/locations/test-location/lakes/test-lake/zones/test-zone/entities/test-entity.
DATA_SOURCE_RESOURCE: il nome della risorsa che contiene i dati per l'analisi della qualità dei dati. Ad esempio, //bigquery.googleapis.com/projects/test-project/datasets/test-dataset/tables/test-table.

C#

Prima di provare questo esempio, segui le istruzioni di configurazione di C# nella guida rapida di Knowledge Catalog per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Knowledge Catalog C#.

Per eseguire l'autenticazione in Knowledge Catalog, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

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;
        }
    }
}

Vai

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di Knowledge Catalog per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Knowledge Catalog Go.


//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
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di Knowledge Catalog per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Knowledge Catalog Java.

import com.google.cloud.dataplex.v1.CreateDataScanRequest;
import com.google.cloud.dataplex.v1.DataScan;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.LocationName;

public class SyncCreateDataScan {

  public static void main(String[] args) throws Exception {
    syncCreateDataScan();
  }

  public static void syncCreateDataScan() throws Exception {
    // 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/java/docs/setup#configure_endpoints_for_the_client_library
    try (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      CreateDataScanRequest request =
          CreateDataScanRequest.newBuilder()
              .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
              .setDataScan(DataScan.newBuilder().build())
              .setDataScanId("dataScanId1260787906")
              .setValidateOnly(true)
              .build();
      DataScan response = dataScanServiceClient.createDataScanAsync(request).get();
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di Knowledge Catalog per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Knowledge Catalog Node.js.

// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// ** This file is automatically generated by gapic-generator-typescript. **
// ** https://github.com/googleapis/gapic-generator-typescript **
// ** All changes to this file may be overwritten. **



'use strict';

function main(parent, dataScan) {
  /**
   * 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.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. The resource name of the parent location:
   *  `projects/{project}/locations/{location_id}`
   *  where `project` refers to a *project_id* or *project_number* and
   *  `location_id` refers to a Google Cloud region.
   */
  // const parent = 'abc123'
  /**
   *  Required. DataScan resource.
   */
  // const dataScan = {}
  /**
   *  Optional. DataScan identifier. If not provided, a unique ID will be
   *  generated with the prefix "data-scan-".
   *  * Must contain only lowercase letters, numbers and hyphens.
   *  * Must start with a letter.
   *  * Must end with a number or a letter.
   *  * Must be between 1-63 characters.
   *  * Must be unique within the customer project / location.
   */
  // const dataScanId = 'abc123'
  /**
   *  Optional. Only validate the request, but do not perform mutations.
   *  The default is `false`.
   */
  // const validateOnly = true

  // Imports the Dataplex library
  const {DataScanServiceClient} = require('@google-cloud/dataplex').v1;

  // Instantiates a client
  const dataplexClient = new DataScanServiceClient();

  async function callCreateDataScan() {
    // Construct request
    const request = {
      parent,
      dataScan,
    };

    // Run request
    const [operation] = await dataplexClient.createDataScan(request);
    const [response] = await operation.promise();
    console.log(response);
  }

  callCreateDataScan();
}

process.on('unhandledRejection', err => {
  console.error(err.message);
  process.exitCode = 1;
});
main(...process.argv.slice(2));

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di Knowledge Catalog per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Knowledge Catalog Python.

# Copyright 2026 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import google.api_core.exceptions
from google.cloud import dataplex_v1


def create_data_quality_scan_global(
    project_id: str,
    dataset_id: str,
    table_id: str,
    location: str,
    column_id_1: str,
    column_id_2: str,
) -> None:
    """Creates a Dataplex Data Quality Scan using global API endpoint routing.

    Args:
        project_id (str): Google Cloud project ID where the scan is created.
        dataset_id (str): Target BigQuery dataset ID.
        table_id (str): Target BigQuery table ID to scan.
        location (str): Google Cloud region where serverless compute runs.
        column_id_1 (str): Name of the first column to evaluate.
        column_id_2 (str): Name of the second column to evaluate.
    """
    client = dataplex_v1.DataScanServiceClient()

    parent = client.common_location_path(project=project_id, location=location)

    # A bigquery table with at least 2 columns is assumed.
    bigquery_table = (
        f"//bigquery.googleapis.com/projects/{project_id}"
        f"/datasets/{dataset_id}/tables/{table_id}"
    )

    data_quality_spec = dataplex_v1.DataQualitySpec(
        rules=[
            dataplex_v1.DataQualityRule(
                name="global-null-assertion",
                dimension="COMPLETENESS",
                description="Fails if any row contains a null value",
                sql_assertion=dataplex_v1.DataQualityRule.SqlAssertion(
                    # Use ${data()} as the placeholder for the table Dataplex is scanning
                    sql_statement=(
                        "SELECT * FROM ${data()} "
                        f"WHERE {column_id_1} IS NULL OR {column_id_2} IS NULL"
                    )
                ),
            )
        ]
    )

    data_scan = dataplex_v1.DataScan(
        display_name="Global Data Quality Scan",
        data=dataplex_v1.DataSource(resource=bigquery_table),
        data_quality_spec=data_quality_spec,
    )

    request = dataplex_v1.CreateDataScanRequest(parent=parent, data_scan=data_scan)

    try:
        operation = client.create_data_scan(request=request)
        print(operation.result())
    except google.api_core.exceptions.AlreadyExists:
        print("A scan with this ID already exists.")
    except google.api_core.exceptions.InvalidArgument as e:
        print(f"Your scan configuration is invalid: {e}")
    except google.api_core.exceptions.GoogleAPIError as e:
        print(f"Unexpected exception: {e}")

Ruby

Prima di provare questo esempio, segui le istruzioni di configurazione di Ruby nella guida rapida di Knowledge Catalog per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Knowledge Catalog Ruby.

require "google/cloud/dataplex/v1"

##
# Snippet for the create_data_scan call in the DataScanService service
#
# 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/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::DataScanService::Client#create_data_scan.
#
def create_data_scan
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::CreateDataScanRequest.new

  # Call the create_data_scan method.
  result = client.create_data_scan request

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

REST

Per creare un'analisi della qualità dei dati, utilizza il metodo dataScans.create.

La seguente richiesta crea una scansione della qualità dei dati una tantum:

POST https://dataplex.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/dataScans?data_scan_id=DATASCAN_ID

{
"data": {
  "resource": "//bigquery.googleapis.com/projects/PROJECT_ID/datasets/DATASET_ID/tables/TABLE_ID"
},
"type": "DATA_QUALITY",
"executionSpec": {
  "trigger": {
    "oneTime": {
      "ttl_after_scan_completion": "120s"
    }
  }
},
"dataQualitySpec": {
  "rules": [
    {
      "nonNullExpectation": {},
      "column": "COLUMN_NAME",
      "dimension": "DIMENSION",
      "threshold": 1
    }
  ],
  "filter": "FILTER_CONDITION"
}
}

Sostituisci quanto segue:

PROJECT_ID: il tuo ID progetto.
LOCATION: la regione in cui creare l'analisi della qualità dei dati.
DATASCAN_ID: l'ID della scansione della qualità dei dati.
DATASET_ID: l'ID del set di dati BigQuery.
TABLE_ID: l'ID della tabella BigQuery.
COLUMN_NAME: il nome della colonna per la regola.
DIMENSION: la dimensione della regola, ad esempio VALIDITY.
FILTER_CONDITION: una stringa di filtro AIP-160 facoltativa per eseguire le regole in modo selettivo (ad esempio, name = \"RULE_NAME\").

Se vuoi creare regole per la scansione della qualità dei dati utilizzando i suggerimenti sulle regole basati sui risultati di una scansione di profilazione dei dati, ottieni i suggerimenti chiamando il metodo dataScans.jobs.generateDataQualityRules sulla scansione di profilazione dei dati.

Nota: se la tabella BigQuery è configurata con l'opzione Richiedi filtro di partizione impostata su true, utilizza la colonna di partizione BigQuery come filtro di riga per l'analisi della qualità dei dati o come colonna del timestamp.

Schema della tabella di esportazione

Per esportare i risultati della scansione della qualità dei dati in una tabella BigQuery esistente, assicurati che sia compatibile con il seguente schema della tabella:

Nome colonna	Tipo di dati della colonna	Nome del sottocampo (se applicabile)	Tipo di dati del sottocampo	Modalità	Esempio
data_quality_scan	`struct/record`	`resource_name`	`string`	nullable	`//dataplex.googleapis.com/projects/test-project/locations/europe-west2/datascans/test-datascan`
		`project_id`	`string`	nullable	`dataplex-back-end-dev-project`
		`location`	`string`	nullable	`us-central1`
		`data_scan_id`	`string`	nullable	`test-datascan`
		`display_name`	`string`	nullable	`datascan-display-name`
data_source	`struct/record`	`resource_name`	`string`	nullable	Entity case: `//dataplex.googleapis.com/projects/dataplex-back-end-dev-project/locations/europe-west2/lakes/a0-datascan-test-lake/zones/a0-datascan-test-zone/entities/table1` Table case: `//bigquery.googleapis.com/projects/test-project/datasets/test-dataset/tables/test-table`
		`dataplex_entity_project_id`	`string`	nullable	`dataplex-back-end-dev-project`
		`dataplex_entity_project_number`	`integer`	nullable	`123456789`
		`dataplex_lake_id`	`string`	nullable	(Valido solo se l'origine è un'entità) `test-lake`
		`dataplex_zone_id`	`string`	nullable	(Valido solo se l'origine è un'entità) `test-zone`
		`dataplex_entity_id`	`string`	nullable	(Valido solo se l'origine è un'entità) `test-entity`
		`table_project_id`	`string`	nullable	`test-project`
		`table_project_number`	`integer`	nullable	`987654321`
		`dataset_id`	`string`	nullable	(Valido solo se l'origine è una tabella) `test-dataset`
		`table_id`	`string`	nullable	(Valido solo se l'origine è una tabella) `test-table`
data_quality_job_id	`string`			nullable	`caeba234-cfde-4fca-9e5b-fe02a9812e38`
data_quality_job_configuration	`json`			nullable	`{"trigger": "ondemand", "incremental": true}`
job_labels	`json`			nullable	`{"key1":value1}`
job_start_time	`timestamp`			nullable	`2023-01-01 00:00:00 UTC`
job_end_time	`timestamp`			nullable	`2023-01-01 00:00:00 UTC`
job_quality_result	`struct/record`	`passed`	`boolean`	nullable	`true`/`false`
		`score`	`float`	nullable	`90.8`
		`incremental_start`	`string`	nullable	`2023-01-01T00:00:00`
		`incremental_end`	`string`	nullable	`2024-01-01T00:00:00`
job_dimension_result	`json`			nullable	`{"ACCURACY":{"passed":true,"score":100},"CONSISTENCY":{"passed":false,"score":60}}`
job_rows_scanned	`integer`			nullable	`7500`
rule_name	`string`			nullable	`test-rule`
rule_description	`string`			nullable	`Test rule description`
rule_type	`string`			nullable	`Range Check`
rule_evaluation_type	`string`			nullable	`Per row`
rule_column	`string`			nullable	`Rule only attached to a certain column`
rule_dimension	`string`			nullable	`UNIQUENESS`
rule_threshold_percent	`float`			nullable	(0.0-100.0) `Rule-threshold-pct in API * 100`
rule_parameters	`json`			nullable	`{min: 24, max:5345}`
rule_passed	`boolean`			nullable	`true`
rule_rows_evaluated	`integer`			nullable	`7400`
rule_rows_passed	`integer`			nullable	`3`
rule_rows_passed_percent	`float`			nullable	(0.0-100.0) `80.0` (indica l'80%)
rule_rows_null	`integer`			nullable	`4`
rule_failed_records_query	`string`			nullable	"SELECT * FROM `test-project.test-dataset.test-table` WHERE (NOT((`cTime` >= '15:31:38.776361' and `cTime` <= '19:23:53.754823') IS TRUE));"
created_on	`timestamp`			nullable	`2023-01-01 00:00:00 UTC`
last_updated	`timestamp`			nullable	`2023-01-01 00:00:00 UTC`
rule_assertion_row_count	`integer`			nullable	`10`
debug_queries	`struct/record`	`description`	`string`	nullable	`Test debug query description`
		`sql_statement`	`string`	nullable	`SELECT MIN(col1) AS min_col1, AVG(col1) FROM ${data()}`
		`debug_query_results`	`struct/record`	ripetuto	`[{"name": "min_col1", "type": "INTEGER", "value": "5"}, {"type": "FLOAT", "value": "7"}]`
		↳ `name`	`string`	nullable	Il nome della colonna dei risultati della query, ad esempio `min_col1`
		↳ `type`	`string`	nullable	Il tipo di colonna dei risultati della query, ad esempio `INTEGER`
		↳ `value`	`string`	nullable	Il valore della colonna dei risultati della query, ad esempio `5`
rule_attributes	`json`			nullable	`{"key": "value"}`
rule_source	`struct/record`	`rule_path_elements`	`struct/record`	ripetuto	`[{"entry_source": {"entry_type": "bigquery_table"}}]`
		↳ `entry_source`	`struct/record`	nullable	`{"entry_type": "bigquery_table"}`
		↳ `entry_type`	`string`	nullable	`bigquery_table`
		↳ `entry`	`string`	nullable	`projects/test-project/locations/us/entryGroups/@bigquery/entries/test-table`
		↳ `display_name`	`string`	nullable	`test-table`
		↳ `entry_link_source`	`struct/record`	nullable	`{"entry_link_type": "table_spec"}`
		↳ `entry_link_type`	`string`	nullable	`table_spec`
		↳ `entry_link`	`string`	nullable	`projects/test-project/locations/us/entryLinks/test-link`

Quando configuri BigQueryExport per un job di scansione della qualità dei dati, segui queste linee guida:

Per il campo resultsTable, utilizza il formato: //bigquery.googleapis.com/projects/{project-id}/datasets/{dataset-id}/tables/{table-id}.
Utilizza una tabella standard di BigQuery.
Se la tabella non esiste quando viene creata o aggiornata l'analisi, Knowledge Catalog la crea per te.
Per impostazione predefinita, la tabella viene partizionata in base alla colonna job_start_time su base giornaliera.
Se vuoi che la tabella venga partizionata in altre configurazioni o se non vuoi la partizione, ricrea la tabella con lo schema e le configurazioni richiesti, quindi fornisci la tabella precreata come tabella dei risultati.
Assicurati che la tabella dei risultati si trovi nella stessa località della tabella di origine.
Se VPC-SC è configurato nel progetto, la tabella dei risultati deve trovarsi nello stesso perimetro VPC-SC della tabella di origine.
Se la tabella viene modificata durante la fase di esecuzione della scansione, il job attualmente in esecuzione esporta nella tabella dei risultati precedente e la modifica della tabella ha effetto dal job di scansione successivo.
Non modificare lo schema della tabella. Se hai bisogno di colonne personalizzate, crea una vista sulla tabella.
Per ridurre i costi, imposta una scadenza per la partizione in base al tuo caso d'uso. Per saperne di più, scopri come impostare la scadenza della partizione.

Esegui una scansione della qualità dei dati

Console

Nella console Google Cloud , vai alla pagina Profilazione e qualità dei dati di Knowledge Catalog.

Vai a Profilazione e qualità dei dati
Fai clic sulla scansione della qualità dei dati da eseguire.
Fai clic su Esegui ora.

gcloud

Per eseguire una scansione della qualità dei dati, utilizza il comando gcloud dataplex datascans run:

gcloud dataplex datascans run DATASCAN \
--location=LOCATION \

Sostituisci le seguenti variabili:

LOCATION: la regione Google Cloud in cui è stata creata la scansione della qualità dei dati.
DATASCAN: il nome della scansione della qualità dei dati.

C#

using Google.Cloud.Dataplex.V1;

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for RunDataScan</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 RunDataScanRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        RunDataScanRequest request = new RunDataScanRequest
        {
            DataScanName = DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
        };
        // Make the request
        RunDataScanResponse response = dataScanServiceClient.RunDataScan(request);
    }
}

Vai

Go


//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.RunDataScanRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#RunDataScanRequest.
	}
	resp, err := c.RunDataScan(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

import com.google.cloud.dataplex.v1.DataScanName;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.RunDataScanRequest;
import com.google.cloud.dataplex.v1.RunDataScanResponse;

public class SyncRunDataScan {

  public static void main(String[] args) throws Exception {
    syncRunDataScan();
  }

  public static void syncRunDataScan() throws Exception {
    // 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/java/docs/setup#configure_endpoints_for_the_client_library
    try (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      RunDataScanRequest request =
          RunDataScanRequest.newBuilder()
              .setName(DataScanName.of("[PROJECT]", "[LOCATION]", "[DATASCAN]").toString())
              .build();
      RunDataScanResponse response = dataScanServiceClient.runDataScan(request);
    }
  }
}

Python

# 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://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_run_data_scan():
    # Create a client
    client = dataplex_v1.DataScanServiceClient()

    # Initialize request argument(s)
    request = dataplex_v1.RunDataScanRequest(
        name="name_value",
    )

    # Make the request
    response = client.run_data_scan(request=request)

    # Handle the response
    print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the run_data_scan call in the DataScanService service
#
# 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/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::DataScanService::Client#run_data_scan.
#
def run_data_scan
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::RunDataScanRequest.new

  # Call the run_data_scan method.
  result = client.run_data_scan request

  # The returned object is of type Google::Cloud::Dataplex::V1::RunDataScanResponse.
  p result
end

REST

Per eseguire una scansione della qualità dei dati, utilizza il metodo dataScans.run.

Airflow

Per eseguire una scansione della qualità dei dati utilizzando un grafo diretto aciclico (DAG) in Managed Service for Apache Airflow (Cloud Composer), utilizza DataplexRunDataQualityScanOperator:

from datetime import datetime
from airflow import DAG
from airflow.providers.google.cloud.operators.dataplex import DataplexRunDataQualityScanOperator

with DAG(
  "dataplex_auto_dq_scan",
  start_date=datetime(2026, 1, 1),
  schedule_interval="@daily",
  catchup=False,
) as dag:

  run_dq_scan = DataplexRunDataQualityScanOperator(
      task_id="run_dataplex_dq_scan",
      project_id="PROJECT_ID",
      region="REGION",
      data_scan_id="DATASCAN_ID",
  )

Sostituisci quanto segue:

PROJECT_ID: l'ID progetto Google Cloud .
REGION: la regione Google Cloud in cui è stata creata l'analisi della qualità dei dati.
DATASCAN_ID: l'ID della scansione della qualità dei dati.

Annulla un job di scansione della qualità dei dati

Se un job di scansione della qualità dei dati viene eseguito più a lungo del previsto o è stato avviato con una configurazione errata, puoi annullarlo. Questa è un'operazione "best effort". Se il job è già in uno stato terminale (ad esempio SUCCEEDED o FAILED), la richiesta di annullamento viene ignorata.

Ruoli e autorizzazioni richiesti

Per ottenere le autorizzazioni necessarie per annullare un job di scansione della qualità dei dati, chiedi all'amministratore di concederti il ruolo IAM Dataplex Editor (roles/dataplex.editor) o Dataplex DataScan Administrator (roles/dataplex.dataScanAdmin) nel progetto.

Annulla un job

Puoi annullare un job di scansione della qualità dei dati in esecuzione o in attesa utilizzando l'API REST.

Console

Nella console Google Cloud , vai alla pagina Profilazione e qualità dei dati.

Vai a Profilazione e qualità dei dati
Fai clic sul nome della scansione della qualità dei dati che contiene il job che vuoi annullare.
Nella scheda Cronologia job, individua il job con lo stato In esecuzione o In attesa.
Fai clic su Annulla in corrispondenza del job.

REST

Utilizza il metodo projects.locations.dataScans.jobs.cancel.

POST https://dataplex.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/dataScans/DATASCAN_ID/jobs/JOB_ID:cancel

Sostituisci quanto segue:

PROJECT_ID: l'ID progetto
LOCATION: la regione in cui si trova l'analisi dei dati.
DATASCAN_ID: l'ID dell'analisi dei dati.
JOB_ID: l'ID del job da annullare.

Visualizza i risultati della scansione della qualità dei dati

Console

Nella console Google Cloud , vai alla pagina Profilazione e qualità dei dati di Knowledge Catalog.

Vai a Profilazione e qualità dei dati
Fai clic sul nome di una scansione della qualità dei dati.
- La sezione Panoramica mostra informazioni sui job più recenti, tra cui la data di esecuzione della scansione, il numero di record scansionati in ogni job, se tutti i controlli della qualità dei dati sono stati superati e, in caso di errori, il numero di controlli della qualità dei dati non superati.
- La sezione Configurazione dell'analisi della qualità dei dati mostra i dettagli dell'analisi.
Per visualizzare informazioni dettagliate su un job, ad esempio i punteggi di qualità dei dati che indicano la percentuale di regole superate, quali regole non sono state superate e i log del job, fai clic sulla scheda Cronologia job. Poi, fai clic su un ID job.

gcloud

Per visualizzare i risultati di un job di scansione della qualità dei dati, utilizza il comando gcloud dataplex datascans jobs describe:

gcloud dataplex datascans jobs describe JOB \
--location=LOCATION \
--datascan=DATASCAN \
--view=FULL

Sostituisci le seguenti variabili:

JOB: l'ID job del job di scansione della qualità dei dati.
LOCATION: la regione Google Cloud in cui è stata creata l'analisi della qualità dei dati.
DATASCAN: il nome della scansione della qualità dei dati a cui appartiene il job.
--view=FULL: per visualizzare il risultato del job di scansione, specifica FULL.

C#

using Google.Cloud.Dataplex.V1;

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for GetDataScan</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 GetDataScanRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        GetDataScanRequest request = new GetDataScanRequest
        {
            DataScanName = DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
            View = GetDataScanRequest.Types.DataScanView.Unspecified,
        };
        // Make the request
        DataScan response = dataScanServiceClient.GetDataScan(request);
    }
}

Vai

Go


//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.GetDataScanRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#GetDataScanRequest.
	}
	resp, err := c.GetDataScan(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}
	// TODO: Use resp.
	_ = resp
}

Java

import com.google.cloud.dataplex.v1.DataScan;
import com.google.cloud.dataplex.v1.DataScanName;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.GetDataScanRequest;

public class SyncGetDataScan {

  public static void main(String[] args) throws Exception {
    syncGetDataScan();
  }

  public static void syncGetDataScan() throws Exception {
    // 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/java/docs/setup#configure_endpoints_for_the_client_library
    try (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      GetDataScanRequest request =
          GetDataScanRequest.newBuilder()
              .setName(DataScanName.of("[PROJECT]", "[LOCATION]", "[DATASCAN]").toString())
              .build();
      DataScan response = dataScanServiceClient.getDataScan(request);
    }
  }
}

Python

# 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://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_get_data_scan():
    # Create a client
    client = dataplex_v1.DataScanServiceClient()

    # Initialize request argument(s)
    request = dataplex_v1.GetDataScanRequest(
        name="name_value",
    )

    # Make the request
    response = client.get_data_scan(request=request)

    # Handle the response
    print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the get_data_scan call in the DataScanService service
#
# 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/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::DataScanService::Client#get_data_scan.
#
def get_data_scan
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::GetDataScanRequest.new

  # Call the get_data_scan method.
  result = client.get_data_scan request

  # The returned object is of type Google::Cloud::Dataplex::V1::DataScan.
  p result
end

REST

Per visualizzare i risultati di una scansione della qualità dei dati, utilizza il metodo dataScans.get.

Visualizza i risultati pubblicati

Se i risultati della scansione della qualità dei dati vengono pubblicati come metadati di Knowledge Catalog, puoi visualizzare i risultati della scansione più recente nelle pagine di BigQuery e Knowledge Catalog nella consoleGoogle Cloud , nella scheda Qualità dei dati della tabella di origine.

Nella console Google Cloud , vai alla pagina Knowledge Catalog.

Vai a Cerca
Cerca e seleziona la tabella.
Fai clic sulla scheda Qualità dei dati.

Vengono visualizzati gli ultimi risultati pubblicati.

Nota: i risultati pubblicati potrebbero non essere disponibili se un'analisi viene eseguita per la prima volta.

Visualizza i risultati delle scansioni storiche

Knowledge Catalog salva la cronologia delle scansioni della qualità dei dati degli ultimi 300 job o dell'ultimo anno, a seconda di quale evento si verifica per primo.

Console

Nella console Google Cloud , vai alla pagina Profilazione e qualità dei dati di Knowledge Catalog.

Vai a Profilazione e qualità dei dati
Fai clic sul nome di una scansione della qualità dei dati.
Fai clic sulla scheda Cronologia job.

La scheda Cronologia job fornisce informazioni sui job passati, ad esempio il numero di record scansionati in ogni job, lo stato del job, l'ora di esecuzione del job e se ogni regola è stata superata o meno.
Per visualizzare informazioni dettagliate su un job, fai clic su uno dei job nella colonna ID job.

gcloud

Per visualizzare i job di scansione della qualità dei dati storici, utilizza il comando gcloud dataplex datascans jobs list:

gcloud dataplex datascans jobs list \
--location=LOCATION \
--datascan=DATASCAN \

Sostituisci le seguenti variabili:

LOCATION: la regione Google Cloud in cui è stata creata l'analisi della qualità dei dati.
DATASCAN: il nome della scansione della qualità dei dati per cui visualizzare i job storici.

C#

using Google.Api.Gax;
using Google.Cloud.Dataplex.V1;
using System;

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for ListDataScanJobs</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 ListDataScanJobsRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        ListDataScanJobsRequest request = new ListDataScanJobsRequest
        {
            ParentAsDataScanName = DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
            Filter = "",
        };
        // Make the request
        PagedEnumerable<ListDataScanJobsResponse, DataScanJob> response = dataScanServiceClient.ListDataScanJobs(request);

        // Iterate over all response items, lazily performing RPCs as required
        foreach (DataScanJob item in response)
        {
            // Do something with each item
            Console.WriteLine(item);
        }

        // Or iterate over pages (of server-defined size), performing one RPC per page
        foreach (ListDataScanJobsResponse page in response.AsRawResponses())
        {
            // Do something with each page of items
            Console.WriteLine("A page of results:");
            foreach (DataScanJob item in page)
            {
                // Do something with each item
                Console.WriteLine(item);
            }
        }

        // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
        int pageSize = 10;
        Page<DataScanJob> singlePage = response.ReadPage(pageSize);
        // Do something with the page of items
        Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
        foreach (DataScanJob item in singlePage)
        {
            // Do something with each item
            Console.WriteLine(item);
        }
        // Store the pageToken, for when the next page is required.
        string nextPageToken = singlePage.NextPageToken;
    }
}

Vai

Go


//go:build examples

package main

import (
	"context"

	dataplex "cloud.google.com/go/dataplex/apiv1"
	dataplexpb "cloud.google.com/go/dataplex/apiv1/dataplexpb"
	"google.golang.org/api/iterator"
)

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.ListDataScanJobsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#ListDataScanJobsRequest.
	}
	it := c.ListDataScanJobs(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*dataplexpb.ListDataScanJobsResponse)
	}
}

Java

import com.google.cloud.dataplex.v1.DataScanJob;
import com.google.cloud.dataplex.v1.DataScanName;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.ListDataScanJobsRequest;

public class SyncListDataScanJobs {

  public static void main(String[] args) throws Exception {
    syncListDataScanJobs();
  }

  public static void syncListDataScanJobs() throws Exception {
    // 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/java/docs/setup#configure_endpoints_for_the_client_library
    try (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      ListDataScanJobsRequest request =
          ListDataScanJobsRequest.newBuilder()
              .setParent(DataScanName.of("[PROJECT]", "[LOCATION]", "[DATASCAN]").toString())
              .setPageSize(883849137)
              .setPageToken("pageToken873572522")
              .setFilter("filter-1274492040")
              .build();
      for (DataScanJob element : dataScanServiceClient.listDataScanJobs(request).iterateAll()) {
        // doThingsWith(element);
      }
    }
  }
}

Python

# 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://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_list_data_scan_jobs():
    # Create a client
    client = dataplex_v1.DataScanServiceClient()

    # Initialize request argument(s)
    request = dataplex_v1.ListDataScanJobsRequest(
        parent="parent_value",
    )

    # Make the request
    page_result = client.list_data_scan_jobs(request=request)

    # Handle the response
    for response in page_result:
        print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the list_data_scan_jobs call in the DataScanService service
#
# 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/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::DataScanService::Client#list_data_scan_jobs.
#
def list_data_scan_jobs
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::ListDataScanJobsRequest.new

  # Call the list_data_scan_jobs method.
  result = client.list_data_scan_jobs request

  # The returned object is of type Gapic::PagedEnumerable. You can iterate
  # over elements, and API calls will be issued to fetch pages as needed.
  result.each do |item|
    # Each element is of type ::Google::Cloud::Dataplex::V1::DataScanJob.
    p item
  end
end

REST

Per visualizzare i job di scansione della qualità dei dati storici, utilizza il metodo dataScans.jobs.list.

Stati dei job

I job di scansione dei dati possono avere i seguenti stati:

PENDING: il job è stato creato, ma non è ancora stato eseguito. In questo stato, l'analisi configura attivamente l'infrastruttura o acquisisce slot. Questa fase può richiedere da 10 a 20 secondi o più, a seconda della complessità dello schema e della contesa delle risorse.
RUNNING: il job è in esecuzione.
CANCELING: il job è in fase di annullamento.
CANCELLED: il job è stato annullato correttamente.
SUCCEEDED: il job viene completato correttamente. Lo stato di completamento potrebbe essere in ritardo rispetto al completamento effettivo della query fino a 60 secondi a causa di passaggi di post-elaborazione, come l'aggregazione e la sincronizzazione dei metadati.
FAILED: il job non va a buon fine a causa di un errore. Lo stato di completamento potrebbe essere in ritardo rispetto al completamento effettivo della query fino a 60 secondi a causa di passaggi di post-elaborazione, come l'aggregazione e la sincronizzazione dei metadati.
SUCCEEDED_WITH_ERRORS: il job viene completato correttamente, ma si verificano alcuni errori durante l'esecuzione.

Best practice per il monitoraggio

Quando monitori i job di scansione dei dati, tieni presente le seguenti best practice:

Evita il polling aggressivo: evita il polling aggressivo (ad esempio, chiamando GetJob o un equivalente ogni 1-5 secondi). Il polling aggressivo spreca la quota dell'API e non accelera le transizioni di stato.
Utilizza il backoff esponenziale: se il polling ripetitivo è inevitabile, utilizza il backoff esponenziale a partire da 10-15 secondi.
Utilizza il disaccoppiamento asincrono basato sugli eventi (consigliato): anziché il polling sincrono delle API, utilizza i trigger Eventarc che ascoltano Cloud Audit Logs (cloudaudit.googleapis.com). Puoi utilizzare questi trigger per avviare i workflow downstream immediatamente dopo gli eventi di completamento dei job DataScan. Questo approccio bypassa i limiti di polling dell'API, conserva la quota e riduce la latenza percepita.

Per consentire agli utenti della tua organizzazione di visualizzare i risultati della scansione:

Nella console Google Cloud , vai alla pagina Profilazione e qualità dei dati di Knowledge Catalog.

Vai a Profilazione e qualità dei dati
Fai clic sulla scansione della qualità dei dati di cui vuoi condividere i risultati.
Fai clic sulla scheda Autorizzazioni.
Segui questi passaggi:
- Per concedere l'accesso a un'entità, fai clic su Concedi l'accesso. Concedi il ruolo Dataplex DataScan DataViewer all'entità associata.
- Per rimuovere l'accesso da un'entità, seleziona l'entità da cui vuoi rimuovere il ruolo Dataplex DataScan DataViewer. Fai clic su Rimuovi accesso, quindi conferma quando richiesto.

Imposta avvisi in Logging

Per impostare avvisi per gli errori di qualità dei dati utilizzando i log in Cloud Logging, segui questi passaggi:

Console

Nella console Google Cloud , vai a Esplora log di Logging.

Vai a Esplora log
Nella finestra Query, inserisci la query. Consulta le query di esempio.
Fai clic su Esegui query.
Fai clic su Crea avviso. Si apre un riquadro laterale.
Inserisci il nome della policy di avviso e fai clic su Avanti.
Esamina la query.
1. Fai clic su Anteprima log per testare la query. Mostra i log con condizioni corrispondenti.
2. Fai clic su Avanti.
Imposta il tempo tra le notifiche e fai clic su Avanti.
Definisci chi deve ricevere la notifica per l'avviso e fai clic su Salva per creare la policy di avviso.

In alternativa, puoi configurare e modificare gli avvisi andando alla sezione Monitoring > Avvisi della consoleGoogle Cloud .

gcloud

Non supportati.

REST

Scopri come impostare gli avvisi in Logging.

Query di esempio per l'impostazione di avvisi a livello di job o di dimensione

Una query di esempio per impostare avvisi sugli errori generali di qualità dei dati per una scansione della qualità dei dati:

resource.type="dataplex.googleapis.com/DataScan"
AND labels."dataplex.googleapis.com/data_scan_state"="SUCCEEDED"
AND resource.labels.resource_container="projects/112233445566"
AND resource.labels.datascan_id="a0-test-dec6-dq-3"
AND NOT jsonPayload.dataQuality.passed=true

Una query di esempio per impostare avvisi sugli errori di qualità dei dati per una dimensione (ad esempio, l'unicità) di una determinata scansione della qualità dei dati:

resource.type="dataplex.googleapis.com/DataScan"
AND labels."dataplex.googleapis.com/data_scan_state"="SUCCEEDED"
AND resource.labels.resource_container="projects/112233445566"
AND resource.labels.datascan_id="a0-test-dec6-dq-3"
AND jsonPayload.dataQuality.dimensionPassed.UNIQUENESS=false

Una query di esempio per impostare avvisi sugli errori di qualità dei dati per una tabella.

Imposta avvisi sugli errori di qualità dei dati per una tabella BigQuery non organizzata in un lake Knowledge Catalog:

resource.type="dataplex.googleapis.com/DataScan"
AND jsonPayload.dataSource="//bigquery.googleapis.com/projects/test-project/datasets/testdataset/table/chicago_taxi_trips"
AND labels."dataplex.googleapis.com/data_scan_state"="SUCCEEDED"
AND resource.labels.resource_container="projects/112233445566"
AND NOT jsonPayload.dataQuality.passed=true

Imposta avvisi sugli errori di qualità dei dati per una tabella BigQuery organizzata in un lake Knowledge Catalog:

resource.type="dataplex.googleapis.com/DataScan"
AND jsonPayload.dataSource="projects/test-project/datasets/testdataset/table/chicago_taxi_trips"
AND labels."dataplex.googleapis.com/data_scan_state"="SUCCEEDED"
AND resource.labels.resource_container="projects/112233445566"
AND NOT jsonPayload.dataQuality.passed=true

Query di esempio per impostare avvisi per regola

Una query di esempio per impostare avvisi su tutte le regole di qualità dei dati non riuscite con il nome della regola personalizzata specificato per un'analisi della qualità dei dati:
```
resource.type="dataplex.googleapis.com/DataScan"
AND jsonPayload.ruleName="custom-name"
AND jsonPayload.result="FAILED"
```
Una query di esempio per impostare avvisi su tutte le regole di qualità dei dati non riuscite di un tipo di valutazione specifico per una scansione della qualità dei dati:
```
resource.type="dataplex.googleapis.com/DataScan"
AND jsonPayload.evalutionType="PER_ROW"
AND jsonPayload.result="FAILED"
```
Una query di esempio per impostare avvisi su tutte le regole di qualità dei dati non riuscite per una colonna nella tabella utilizzata per una scansione della qualità dei dati:
```
resource.type="dataplex.googleapis.com/DataScan"
AND jsonPayload.column="CInteger"
AND jsonPayload.result="FAILED"
```

Risolvi un errore di qualità dei dati

Per ogni job con regole a livello di riga che non vanno a buon fine, Knowledge Catalog fornisce una query per ottenere i record non riusciti. Esegui questa query per visualizzare i record che non corrispondono alla regola.

Console

Nella console Google Cloud , vai alla pagina Profilazione e qualità dei dati di Knowledge Catalog.

Vai a Profilazione e qualità dei dati
Fai clic sul nome dell'analisi della qualità dei dati di cui vuoi risolvere i problemi relativi ai record.
Fai clic sulla scheda Cronologia job.
Fai clic sull'ID job del job che ha identificato errori di qualità dei dati.
Nella finestra dei risultati del job che si apre, nella sezione Regole, individua la colonna Query per ottenere i record non riusciti. Fai clic su Copia query negli appunti per la regola non riuscita.
Esegui la query in BigQuery per visualizzare i record che hanno causato l'errore del job.

gcloud

Non supportati.

REST

Per ottenere il job che ha identificato gli errori di qualità dei dati, utilizza il metodo dataScans.get.

Nell'oggetto della risposta, il campo failingRowsQuery mostra la query.
Esegui la query in BigQuery per visualizzare i record che hanno causato l'errore del job.

Knowledge Catalog esegue anche la query di debug, a condizione che sia stata inclusa durante la creazione della regola. I risultati della query di debug sono inclusi nell'output di ogni regola. Questa funzionalità è in anteprima.

Console

Non supportati.

gcloud

Non supportati.

REST

Per ottenere il job che ha identificato gli errori di qualità dei dati, utilizza il metodo dataScans.get. Nell'oggetto della risposta, il campo debugQueriesResultSets mostra i risultati delle query di debug.

Gestisci le scansioni della qualità dei dati per una tabella specifica

I passaggi descritti in questo documento mostrano come gestire le scansioni di profilazione dei dati nel tuo progetto utilizzando la pagina Profilazione e qualità dei dati di Knowledge Catalog nella console Google Cloud .

Puoi anche creare e gestire scansioni di profilazione dei dati quando lavori con una tabella specifica. Nella console Google Cloud , nella pagina Knowledge Catalog della tabella, utilizza la scheda Qualità dei dati. Segui questi passaggi:

Nella console Google Cloud , vai alla pagina Ricerca di Knowledge Catalog.

Vai a Cerca

Cerca e seleziona la tabella.
Fai clic sulla scheda Qualità dei dati.
A seconda che la tabella abbia o meno una scansione della qualità dei dati i cui risultati sono pubblicati come metadati di Knowledge Catalog, puoi utilizzare le scansioni della qualità dei dati della tabella nei seguenti modi:
- I risultati della scansione della qualità dei dati sono pubblicati: i risultati della scansione più recente vengono visualizzati nella pagina.
  
  Per gestire le scansioni della qualità dei dati per questa tabella, fai clic su Analisi della qualità dei dati e poi seleziona una delle seguenti opzioni:
  - Crea nuova scansione: crea una nuova scansione della qualità dei dati. Per saperne di più, consulta la sezione Crea un'analisi della qualità dei dati di questo documento. Quando crei un'analisi dalla pagina dei dettagli di una tabella, la tabella è preselezionata.
  - Esegui ora: esegui l'analisi.
  - Modifica configurazione di scansione: modifica le impostazioni, tra cui il nome visualizzato, i filtri e la pianificazione.
    
    Per modificare le regole sulla qualità dei dati, nella scheda Qualità dei dati, fai clic sulla scheda Regole. Fai clic su Modifica regole. Aggiorna le regole e poi fai clic su Salva.
  - Gestisci autorizzazioni della scansione: controlla chi può accedere ai risultati della scansione. Per saperne di più, consulta la sezione Concedi l'accesso ai risultati della scansione della qualità dei dati di questo documento.
  - Visualizza i risultati storici: visualizza informazioni dettagliate sui job di scansione della qualità dei dati precedenti. Per saperne di più, consulta le sezioni Visualizza i risultati della scansione della qualità dei dati e Visualizza i risultati della cronologia delle visualizzazioni di questo documento.
  - Visualizza tutte le scansioni: visualizza un elenco di scansioni della qualità dei dati applicabili a questa tabella.
- I risultati della scansione della qualità dei dati non vengono pubblicati: seleziona una delle seguenti opzioni:
  - Crea scansione della qualità dei dati: crea una nuova scansione della qualità dei dati. Per saperne di più, consulta la sezione Crea un'analisi della qualità dei dati di questo documento. Quando crei un'analisi dalla pagina dei dettagli di una tabella, la tabella è preselezionata.
  - Visualizza le scansioni esistenti: visualizza un elenco delle scansioni della qualità dei dati applicabili a questa tabella.

Aggiorna una scansione della qualità dei dati

Puoi modificare varie impostazioni per una scansione della qualità dei dati esistente, ad esempio il nome visualizzato, i filtri, la pianificazione e le regole di qualità dei dati.

Console

Nella console Google Cloud , vai alla pagina Profilazione e qualità dei dati di Knowledge Catalog.

Vai a Profilazione e qualità dei dati
Fai clic sul nome di una scansione della qualità dei dati.
Per modificare le impostazioni, tra cui il nome visualizzato, i filtri e la pianificazione, fai clic su Modifica. Modifica i valori e poi fai clic su Salva.
Per modificare le regole di qualità dei dati, nella pagina dei dettagli della scansione, fai clic sulla scheda Regole attuali. Fai clic su Modifica regole. Aggiorna le regole e poi fai clic su Salva.

gcloud

Per aggiornare la descrizione di un'analisi della qualità dei dati, utilizza il comando gcloud dataplex datascans update data-quality:

gcloud dataplex datascans update data-quality DATASCAN \
--location=LOCATION \
--description=DESCRIPTION

Sostituisci quanto segue:

DATASCAN: il nome della scansione della qualità dei dati da aggiornare.
LOCATION: la regione Google Cloud in cui è stata creata l'analisi della qualità dei dati.
DESCRIPTION: la nuova descrizione per l'analisi della qualità dei dati.

C#

using Google.Cloud.Dataplex.V1;
using Google.LongRunning;
using Google.Protobuf.WellKnownTypes;

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for UpdateDataScan</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 UpdateDataScanRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        UpdateDataScanRequest request = new UpdateDataScanRequest
        {
            DataScan = new DataScan(),
            UpdateMask = new FieldMask(),
            ValidateOnly = false,
        };
        // Make the request
        Operation<DataScan, OperationMetadata> response = dataScanServiceClient.UpdateDataScan(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.PollOnceUpdateDataScan(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;
        }
    }
}

Vai

Go


//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.UpdateDataScanRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#UpdateDataScanRequest.
	}
	op, err := c.UpdateDataScan(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

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

Java

import com.google.cloud.dataplex.v1.DataScan;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.UpdateDataScanRequest;
import com.google.protobuf.FieldMask;

public class SyncUpdateDataScan {

  public static void main(String[] args) throws Exception {
    syncUpdateDataScan();
  }

  public static void syncUpdateDataScan() throws Exception {
    // 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/java/docs/setup#configure_endpoints_for_the_client_library
    try (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      UpdateDataScanRequest request =
          UpdateDataScanRequest.newBuilder()
              .setDataScan(DataScan.newBuilder().build())
              .setUpdateMask(FieldMask.newBuilder().build())
              .setValidateOnly(true)
              .build();
      DataScan response = dataScanServiceClient.updateDataScanAsync(request).get();
    }
  }
}

Python

# 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://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_update_data_scan():
    # Create a client
    client = dataplex_v1.DataScanServiceClient()

    # Initialize request argument(s)
    data_scan = dataplex_v1.DataScan()
    data_scan.data.entity = "entity_value"

    request = dataplex_v1.UpdateDataScanRequest(
        data_scan=data_scan,
    )

    # Make the request
    operation = client.update_data_scan(request=request)

    print("Waiting for operation to complete...")

    response = operation.result()

    # Handle the response
    print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the update_data_scan call in the DataScanService service
#
# 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/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::DataScanService::Client#update_data_scan.
#
def update_data_scan
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::UpdateDataScanRequest.new

  # Call the update_data_scan method.
  result = client.update_data_scan request

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

REST

Per modificare un'analisi della qualità dei dati, utilizza il metodo dataScans.patch.

Elimina una scansione della qualità dei dati

Console

Nella console Google Cloud , vai alla pagina Profilazione e qualità dei dati di Knowledge Catalog.

Vai a Profilazione e qualità dei dati
Fai clic sulla scansione che vuoi eliminare.
Fai clic su Elimina e poi conferma quando richiesto.

gcloud

Per eliminare una scansione della qualità dei dati, utilizza il comando gcloud dataplex datascans delete:

gcloud dataplex datascans delete DATASCAN \
--location=LOCATION \
--async

Sostituisci le seguenti variabili:

DATASCAN: il nome dell'analisi della qualità dei dati da eliminare.
LOCATION: la regione Google Cloud in cui è stata creata l'analisi della qualità dei dati.

C#

using Google.Cloud.Dataplex.V1;
using Google.LongRunning;
using Google.Protobuf.WellKnownTypes;

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for DeleteDataScan</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 DeleteDataScanRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        DeleteDataScanRequest request = new DeleteDataScanRequest
        {
            DataScanName = DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
            Force = false,
        };
        // Make the request
        Operation<Empty, OperationMetadata> response = dataScanServiceClient.DeleteDataScan(request);

        // Poll until the returned long-running operation is complete
        Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        Empty 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<Empty, OperationMetadata> retrievedResponse = dataScanServiceClient.PollOnceDeleteDataScan(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            Empty retrievedResult = retrievedResponse.Result;
        }
    }
}

Vai

Go


//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.DeleteDataScanRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#DeleteDataScanRequest.
	}
	op, err := c.DeleteDataScan(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

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

Java

import com.google.cloud.dataplex.v1.DataScanName;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.DeleteDataScanRequest;
import com.google.protobuf.Empty;

public class SyncDeleteDataScan {

  public static void main(String[] args) throws Exception {
    syncDeleteDataScan();
  }

  public static void syncDeleteDataScan() throws Exception {
    // 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/java/docs/setup#configure_endpoints_for_the_client_library
    try (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      DeleteDataScanRequest request =
          DeleteDataScanRequest.newBuilder()
              .setName(DataScanName.of("[PROJECT]", "[LOCATION]", "[DATASCAN]").toString())
              .setForce(true)
              .build();
      dataScanServiceClient.deleteDataScanAsync(request).get();
    }
  }
}

Python

# 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://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_delete_data_scan():
    # Create a client
    client = dataplex_v1.DataScanServiceClient()

    # Initialize request argument(s)
    request = dataplex_v1.DeleteDataScanRequest(
        name="name_value",
    )

    # Make the request
    operation = client.delete_data_scan(request=request)

    print("Waiting for operation to complete...")

    response = operation.result()

    # Handle the response
    print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the delete_data_scan call in the DataScanService service
#
# 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/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::DataScanService::Client#delete_data_scan.
#
def delete_data_scan
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::DeleteDataScanRequest.new

  # Call the delete_data_scan method.
  result = client.delete_data_scan request

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

REST

Per eliminare una scansione della qualità dei dati, utilizza il metodo dataScans.delete.

Passaggi successivi

Segui un tutorial per creare un workflow di qualità dei dati basato su policy-as-code.
Segui un tutorial per gestire le regole di qualità dei dati come codice con Terraform.
Scopri di più sulla profilazione dei dati.
Scopri come utilizzare la profilazione dei dati.

Utilizzare la qualità dei dati automatica Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Prima di iniziare

Ruoli e autorizzazioni richiesti

Ruoli utente e autorizzazioni

Autorizzazioni obbligatorie

Ruoli e autorizzazioni del account di servizio di Knowledge Catalog

Autorizzazioni obbligatorie

Requisiti di networking

Definisci le regole sulla qualità dei dati

Definisci le regole sulla qualità dei dati utilizzando i tipi di regole integrati

Definisci le regole sulla qualità dei dati utilizzando regole SQL personalizzate

Definisci le regole sulla qualità dei dati utilizzando gcloud CLI

Configura l'identità di esecuzione

Autorizzazioni richieste per le identità di esecuzione personalizzate

Console

REST

Crea una scansione della qualità dei dati

Console

gcloud

C#

C#

Vai

Go

Java

Java

Node.js

Node.js

Python

Python

Ruby

Ruby

REST

Schema della tabella di esportazione

Esegui una scansione della qualità dei dati

Console

gcloud

C#

C#

Vai

Go

Java

Java

Python

Python

Ruby

Ruby

REST

Airflow

Annulla un job di scansione della qualità dei dati

Ruoli e autorizzazioni richiesti

Annulla un job

Console

REST

Visualizza i risultati della scansione della qualità dei dati

Console

gcloud

C#

C#

Vai

Go

Java

Java

Python

Python

Ruby

Ruby

REST

Visualizza i risultati pubblicati

Visualizza i risultati delle scansioni storiche

Console

gcloud

C#

C#

Vai

Go

Java

Java

Python

Python

Ruby

Utilizzare la qualità dei dati automatica