Creare e utilizzare le analisi del profilo di dati

Knowledge Catalog (precedentemente Dataplex Universal Catalog) consente di identificare le caratteristiche statistiche comuni (valori comuni, distribuzione dei dati, conteggi null) delle colonne nelle tabelle BigQuery. Queste informazioni ti aiutano a comprendere e analizzare i tuoi dati in modo più efficace.

Per ulteriori informazioni sulle scansioni del profilo dati di Knowledge Catalog, consulta Informazioni sulla profilazione dei dati.

Prima di iniziare

Abilitare l'API Dataplex.

Ruoli richiesti per abilitare le API

Per abilitare le API, devi disporre del ruolo IAM Amministratore utilizzo dei servizi (roles/serviceusage.serviceUsageAdmin), che include l'autorizzazione serviceusage.services.enable. Scopri come concedere i ruoli.

Abilitare l'API

Ruoli e autorizzazioni richiesti

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

Ruoli utente e autorizzazioni

Per ottenere le autorizzazioni necessarie per creare e gestire le scansioni di profilazione dei dati, chiedi all'amministratore di concederti i seguenti ruoli IAM:

Crea, esegui, aggiorna ed elimina le analisi del profilo dati: Editor Dataplex DataScan (roles/dataplex.dataScanEditor) sul progetto contenente l'analisi dei dati
Visualizza i risultati, i job e la cronologia della scansione di profilazione dei dati: Dataplex DataScan Viewer (roles/dataplex.dataScanViewer) sul progetto contenente la scansione dei dati
Pubblica i risultati della scansione di profilazione dei dati in Knowledge Catalog: Dataplex Catalog Editor (roles/dataplex.catalogEditor) nel gruppo di voci @bigquery
Visualizza i risultati della scansione di profilazione dei dati pubblicati in BigQuery nella scheda Profilo dei dati: Visualizzatore dati BigQuery (roles/bigquery.dataViewer) nella tabella

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 creare e gestire le scansioni di profilazione dei dati. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per creare e gestire le scansioni di profilazione dei dati sono necessarie le seguenti autorizzazioni:

Crea, esegui, aggiorna ed elimina scansioni del profilo di dati:
- dataplex.datascans.create sul progetto
- dataplex.datascans.update sulla scansione dei dati
- dataplex.datascans.delete sulla scansione dei dati
- dataplex.datascans.run sulla scansione dei dati
- dataplex.datascans.get sulla scansione dei dati
- dataplex.datascans.list sul progetto
- dataplex.dataScanJobs.get nel job di scansione dei dati
- dataplex.dataScanJobs.list sulla scansione dei dati
Visualizza i risultati, i job e la cronologia della scansione di profilazione dei dati:
- dataplex.datascans.getData sulla scansione dei dati
- dataplex.datascans.list sul progetto
- dataplex.dataScanJobs.get nel job di scansione dei dati
- dataplex.dataScanJobs.list sulla scansione dei dati
Pubblica i risultati della scansione di profilazione dei dati in Knowledge Catalog:
- dataplex.entryGroups.useDataProfileAspect sul gruppo di voci
- bigquery.tables.update sul tavolo
- dataplex.entries.update all'inserimento
Visualizza i risultati del profilo di dati pubblicati per una tabella in BigQuery o Knowledge Catalog:
- bigquery.tables.get sul tavolo
- bigquery.tables.getData sul tavolo

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

Ruoli e autorizzazioni del account di servizio di Knowledge Catalog

Per assicurarti che il account di servizio Knowledge Catalog disponga delle autorizzazioni necessarie per eseguire scansioni dei profili dei dati ed esportare i risultati, chiedi all'amministratore di concedere i seguenti ruoli IAM al account di servizio Knowledge Catalog:

Esegui scansioni di profilazione dei dati sui dati BigQuery:
- Utente job BigQuery (roles/bigquery.jobUser) nel progetto che esegue la scansione
- Visualizzatore dati BigQuery (roles/bigquery.dataViewer) nelle tabelle sottoposte a scansione
Esegui scansioni di profilazione dei dati per le tabelle esterne BigQuery che utilizzano i dati di Cloud Storage:
- Storage Object Viewer (roles/storage.objectViewer) sul bucket Cloud Storage
- Storage Legacy Bucket Reader (roles/storage.legacyBucketReader) sul bucket Cloud Storage
Esporta i risultati della scansione di profilazione dei dati in una tabella BigQuery: Editor dati BigQuery (roles/bigquery.dataEditor) nella tabella

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 scansioni di profilazione dei dati ed esportare i risultati. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per eseguire le scansioni di profilazione dei dati ed esportare i risultati sono necessarie le seguenti autorizzazioni:

Esegui scansioni di profilazione dei dati sui dati BigQuery:
- bigquery.jobs.create sul progetto
- bigquery.tables.get sul tavolo
- bigquery.tables.getData sul tavolo
Esegui scansioni di profilazione dei dati per le tabelle esterne BigQuery che utilizzano i dati di Cloud Storage:
- storage.buckets.get sul bucket
- storage.objects.get sull'oggetto
Esporta i risultati della scansione di profilazione dei dati in una tabella BigQuery:
- bigquery.tables.create sul set di dati
- bigquery.tables.updateData sul tavolo

L'amministratore potrebbe anche essere in grado di concedere al account di servizio Knowledge Catalog queste autorizzazioni tramite ruoli personalizzati o altri ruoli predefiniti.

Se una tabella utilizza la sicurezza a livello di riga di BigQuery, Knowledge Catalog può analizzare solo le righe visibili all'account di servizio Knowledge Catalog. Per consentire a Knowledge Catalog di scansionare tutte le righe, aggiungi ilaccount di serviziot a un filtro delle righe in cui il predicato è TRUE.

Se una tabella utilizza la sicurezza a livello di colonna di BigQuery, Knowledge Catalog richiede l'accesso per analizzare le colonne protette. Per concedere l'accesso, assegna all'account di servizio Knowledge Catalog il ruolo Lettore granulare Data Catalog (roles/datacatalog.fineGrainedReader) per tutti i tag di policy utilizzati nella tabella. L'utente che crea o aggiorna una scansione dei dati deve disporre anche delle autorizzazioni per le colonne protette.

Concedi ruoli al account di servizio Knowledge Catalog

Per eseguire le scansioni di profilazione dei dati, Knowledge Catalog utilizza un account di servizio che richiede le autorizzazioni per eseguire i job BigQuery e leggere i dati delle tabelle BigQuery. Per concedere i ruoli richiesti, segui questi passaggi:

Ottieni l'indirizzo email del account di servizio di Knowledge Catalog. Se non hai creato una scansione del profilo di dati o della qualità dei dati in questo progetto, esegui il seguente comando gcloud per generare l'identità del servizio:
```
gcloud beta services identity create --service=dataplex.googleapis.com
```
Il comando restituisce l'email del account di servizio, che ha il seguente formato: service-PROJECT_ID@gcp-sa-dataplex.iam.gserviceaccount.com.

Se il account di servizio esiste già, puoi trovare la sua email visualizzando i principal con il nome Dataplex nella pagina IAM nella console Google Cloud .
Concedi all'account di servizio il ruolo Utente job BigQuery (roles/bigquery.jobUser) nel tuo progetto. Questo ruolo consente al account di servizio di eseguire job BigQuery per la scansione.
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member="serviceAccount:service-PROJECT_NUMBER@gcp-sa-dataplex.iam.gserviceaccount.com" \
    --role="roles/bigquery.jobUser"
```
Sostituisci quanto segue:
- PROJECT_ID: il tuo ID progetto Google Cloud .
- service-PROJECT_NUMBER@gcp-sa-dataplex.iam.gserviceaccount.com: l'indirizzo email del account di servizio Knowledge Catalog.
Concedi all'account di servizio il ruolo Visualizzatore dati BigQuery (roles/bigquery.dataViewer) per ogni tabella di cui vuoi creare il profilo. Questo ruolo concede l'accesso di sola lettura alle tabelle.
```
gcloud bigquery tables add-iam-policy-binding DATASET_ID.TABLE_ID \
    --member="serviceAccount:service-PROJECT_NUMBER@gcp-sa-dataplex.iam.gserviceaccount.com" \
    --role="roles/bigquery.dataViewer"
```
Sostituisci quanto segue:
- DATASET_ID: l'ID del set di dati contenente la tabella.
- TABLE_ID: l'ID della tabella da profilare.
- service-PROJECT_NUMBER@gcp-sa-dataplex.iam.gserviceaccount.com: l'indirizzo email del account di servizio Knowledge Catalog.

Configura l'identità di esecuzione

Per impostazione predefinita, le scansioni del profilo di dati vengono eseguite utilizzando l'agente di servizio Knowledge Catalog. Puoi ignorare questa impostazione per utilizzare un account di servizio personalizzato o le tue credenziali utente finale.

L'utilizzo di un'identità di esecuzione personalizzata modifica la modalità di fatturazione della scansione. 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 IAM aggiuntive:

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

Console

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

Nella sezione Identità di esecuzione, seleziona una delle seguenti opzioni:
- Service account Dataplex: il comportamento predefinito.
- Service account specifico: inserisci l'indirizzo email del account di servizio che vuoi utilizzare.
- Credenziali utente: utilizza le tue credenziali per eseguire la scansione.

Google Cloud CLI

Per utilizzare un account di servizio personalizzato, aggiungi l'oggetto JSON execution_identity con l'email del account di servizio al payload di creazione oppure passalo utilizzando i flag, se supportati dalla release di gcloud CLI.

Ad esempio, utilizzando l'API REST tramite curl con un payload JSON:

"execution_identity": {
  "service_account": {
     "email": "YOUR_SERVICE_ACCOUNT_EMAIL"
  }
}

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

"execution_identity": {
  "user_credential": {}
}

API

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

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

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

Crea una scansione di profilazione dei dati

Console

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

Vai a Profilazione e qualità dei dati
Fai clic su Crea scansione di profilazione dei dati.
(Facoltativo) Inserisci un Nome visualizzato.
Inserisci un ID. Consulta le convenzioni di denominazione delle risorse.
Facoltativo: inserisci una descrizione.
Nel campo Table (Tabella), fai clic su Sfoglia. Scegli la tabella da analizzare e fai clic su Seleziona.

Per le tabelle nei set di dati multiregionali, scegli una regione in cui creare la scansione dei dati.

Per sfogliare le tabelle organizzate all'interno dei lake Knowledge Catalog, fai clic su Sfoglia all'interno dei lake Knowledge Catalog.
Nella sezione Modalità, seleziona una delle seguenti opzioni:
- Standard: profila i tuoi dati con impostazioni di scansione personalizzabili. Si tratta della modalità predefinita.
- Leggera: fornisce insight rapidi con una scansione a bassa latenza e bassa fedeltà.
Se hai scelto la modalità Standard, configura le seguenti opzioni. Queste opzioni non vengono visualizzate quando selezioni la modalità Leggera.
1. Nel campo Ambito, scegli Incrementale o Tutti i dati.
  
  Se scegli Dati incrementali, nel campo Colonna timestamp, seleziona una colonna di tipo DATE o TIMESTAMP dalla tabella BigQuery. Knowledge Catalog utilizza questa colonna per identificare i nuovi record man mano che vengono aggiunti. Per le tabelle partizionate in base a una colonna di tipo DATE o TIMESTAMP, consigliamo di utilizzare questa colonna come colonna di partizionamento.
2. (Facoltativo) Per filtrare i dati, esegui una delle seguenti operazioni:
  - Per filtrare per righe, seleziona la casella di controllo Filtra righe. Inserisci un'espressione SQL valida che può essere utilizzata in una clausola WHERE nella sintassi GoogleSQL. Ad esempio: col1 >= 0.
    
    Il filtro può essere una combinazione di condizioni SQL su più colonne. Ad esempio: col1 >= 0 AND col2 < 10.
  - Per filtrare per colonne, seleziona la casella di controllo Filtra colonne.
  - Per includere colonne nella scansione di profilazione, fai clic su Sfoglia nel campo Includi colonne. Seleziona le colonne da includere, quindi fai clic su Seleziona.
  - Per escludere le colonne dalla scansione di profilazione, fai clic su Sfoglia nel campo Escludi colonne. Seleziona le colonne da escludere, quindi fai clic su Seleziona.
  Nota: puoi utilizzare Includi colonne, Escludi colonne o entrambi. Se utilizzi entrambi i campi, la scansione di profilazione dei dati seleziona prima le colonne in base all'input nel campo Includi colonne ed esclude poi le colonne in base all'input nel campo Escludi colonne.
3. Per applicare il campionamento alla scansione di profilazione dei dati, seleziona una percentuale di campionamento nell'elenco Dimensione campionamento. Scegli un valore percentuale compreso tra 0,0% e 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 0,1% e 1,0%, il profilo dei dati campiona tra 1 e 10 TB di dati.
  - Nei dati campionati devono essere presenti almeno 100 record per restituire un risultato.
  - Per le scansioni incrementali dei dati, la scansione di profilazione dei dati applica il campionamento all'ultimo incremento.
(Facoltativo) Pubblica i risultati della scansione di profilazione dei dati nelle pagine BigQuery e Knowledge Catalog della consoleGoogle Cloud per la tabella di origine. Seleziona la casella di controllo Pubblica i risultati in Knowledge Catalog.

Puoi visualizzare i risultati più recenti della scansione nella scheda Profilo dei dati nelle pagine BigQuery e Knowledge Catalog della tabella di origine. Per consentire agli utenti di accedere ai risultati della scansione di profilazione dei dati pubblicati, consulta la sezione Concedere l'accesso ai risultati della scansione di profilazione dei dati di questo documento.

L'opzione di pubblicazione potrebbe non essere disponibile nei seguenti casi:
- Non disponi delle autorizzazioni necessarie per la tabella.
- È impostata un'altra scansione di profilazione dei dati per pubblicare i risultati.
Nella sezione Pianificazione, scegli una delle seguenti opzioni:
- Ripeti: esegui la scansione di profilazione dei dati in base a una pianificazione: oraria, giornaliera, settimanale, mensile o personalizzata. Specifica la frequenza e l'ora di esecuzione della scansione. Se scegli l'opzione personalizzata, utilizza il formato cron per specificare la pianificazione.
- On demand: esegui la scansione di profilazione dei dati on demand.
- Esecuzione una tantum: esegui la scansione di profilazione dei dati una volta ora e rimuovila dopo il periodo di eliminazione automatica. Questa funzionalità è in anteprima.
  - Imposta l'eliminazione automatica dei risultati post-scansione: il tempo di eliminazione automatica definisce la durata per cui una scansione di profilazione dei dati rimane attiva dopo l'esecuzione. Una scansione di profilazione dei dati senza un orario di eliminazione automatica specificato viene rimossa automaticamente dopo 24 ore. Il tempo di eliminazione automatica può variare da 0 secondi (eliminazione immediata) a 365 giorni.
Fai clic su Continua.
(Facoltativo) Esporta i risultati della scansione in una tabella standard BigQuery. Nella sezione Esporta i risultati della scansione in una tabella BigQuery, esegui le seguenti operazioni:
1. Nel campo Seleziona set di dati BigQuery, fai clic su Sfoglia. Seleziona un set di dati BigQuery per archiviare i risultati della scansione di profilazione dei dati.
2. Nel campo Tabella BigQuery, specifica la tabella in cui archiviare i risultati della scansione di profilazione 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 automaticamente.
  
  Nota: puoi utilizzare la stessa tabella dei risultati per più analisi del profilo dei dati.
(Facoltativo) Aggiungi etichette. Le etichette sono coppie chiave-valore che consentono di raggruppare oggetti correlati fra loro o con altre risorse Google Cloud .
Per creare la scansione, fai clic su Crea.

Se imposti la pianificazione su on demand, puoi anche eseguire la scansione ora facendo clic su Esegui scansione.

gcloud

Per creare una scansione di profilazione dei dati, utilizza il comando gcloud dataplex datascans create data-profile.

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

gcloud dataplex datascans create data-profile DATASCAN \
--location=LOCATION \
--data-source-entity=DATA_SOURCE_ENTITY

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

gcloud dataplex datascans create data-profile DATASCAN \
--location=LOCATION \
--data-source-resource=DATA_SOURCE_RESOURCE

Sostituisci le seguenti variabili:

DATASCAN: Il nome della scansione di profilazione dei dati.
LOCATION: la regione Google Cloud in cui creare la scansione di profilazione dei dati.
DATA_SOURCE_ENTITY: l'entità Knowledge Catalog che contiene i dati per la scansione di profilazione 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 la scansione di profilazione 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;
        }
    }
}

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.


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

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.

# 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_create_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.CreateDataScanRequest(
        parent="parent_value",
        data_scan=data_scan,
        data_scan_id="data_scan_id_value",
    )

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

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

    response = operation.result()

    # Handle the response
    print(response)

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 una scansione di profilazione dei dati, utilizza il metodo dataScans.create.

Esporta schema tabella

Se vuoi esportare i risultati della scansione di profilazione dei dati in una tabella BigQuery esistente, assicurati che sia compatibile con lo schema della tabella seguente:

Nome colonna	Tipo di dati della colonna	Nome del campo secondario (se applicabile)	Tipo di dati del campo secondario	Modalità	Esempio
data_profile_scan	`struct/record`	`resource_name`	`string`	nullable	`//dataplex.googleapis.com/projects/test-project/locations/europe-west2/datascans/test-datascan`
		`project_id`	`string`	nullable	`test-project`
		`location`	`string`	nullable	`us-central1`
		`data_scan_id`	`string`	nullable	`test-datascan`
data_source	`struct/record`	`resource_name`	`string`	nullable	Caso relativo all'entità: `//dataplex.googleapis.com/projects/test-project/locations/europe-west2/lakes/test-lake/zones/test-zone/entities/test-entity` Table case: `//bigquery.googleapis.com/projects/test-project/datasets/test-dataset/tables/test-table`
		`dataplex_entity_project_id`	`string`	nullable	`test-project`
		`dataplex_entity_project_number`	`integer`	nullable	`123456789012`
		`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	`dataplex-table`
		`table_project_number`	`int64`	nullable	`345678901234`
		`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_profile_job_id	`string`			nullable	`caeba234-cfde-4fca-9e5b-fe02a9812e38`
data_profile_job_configuration	`json`	`trigger`	`string`	nullable	`ondemand`/`schedule`
		`incremental`	`boolean`	nullable	`true`/`false`
		`sampling_percent`	`float`	nullable	(0-100) `20.0` (indica il 20%)
		`row_filter`	`string`	nullable	`col1 >= 0 AND col2 < 10`
		`column_filter`	`json`	nullable	`{"include_fields":["col1","col2"], "exclude_fields":["col3"]}`
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_rows_scanned	`integer`			nullable	`7500`
column_name	`string`			nullable	`column-1`
column_type	`string`			nullable	`string`
column_mode	`string`			nullable	`repeated`
percent_null	`float`			nullable	(0.0-100.0) `20.0` (indica il 20%)
percent_unique	`float`			nullable	(0.0-100.0) `92.5`
min_string_length	`integer`			nullable	(Valido solo se il tipo di colonna è stringa) `10`
max_string_length	`integer`			nullable	(Valido solo se il tipo di colonna è stringa) `4`
average_string_length	`float`			nullable	(Valido solo se il tipo di colonna è stringa) `7.2`
min_value	`float`			nullable	(Valido solo se il tipo di colonna è numerico: intero/float)
max_value	`float`			nullable	(Valido solo se il tipo di colonna è numerico: intero/float)
average_value	`float`			nullable	(Valido solo se il tipo di colonna è numerico: intero/float)
standard_deviation	`float`			nullable	(Valido solo se il tipo di colonna è numerico: intero/float)
quartile_lower	`integer`			nullable	(Valido solo se il tipo di colonna è numerico: intero/float)
quartile_median	`integer`			nullable	(Valido solo se il tipo di colonna è numerico: intero/float)
quartile_upper	`integer`			nullable	(Valido solo se il tipo di colonna è numerico: intero/float)
top_n	`struct/record - repeated`	`value`	`string`	nullable	`"4009"`
		`count`	`integer`	nullable	`20`
		`percent`	`float`	nullable	`10` (indica il 10%)

Configurazione dell'esportazione della tabella

Quando esegui l'esportazione nelle tabelle BigQueryExport, 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 BigQuery.
Se la tabella non esiste quando viene creata o aggiornata la scansione, Knowledge Catalog la crea per te.
Per impostazione predefinita, la tabella viene partizionata in base alla colonna job_start_time ogni giorno.
Se vuoi che la tabella sia partizionata in altre configurazioni o se non vuoi la partizione, ricrea la tabella con lo schema e le configurazioni richiesti e poi fornisci la tabella precreata come tabella dei risultati.
Assicurati che la tabella dei risultati si trovi nella stessa posizione della tabella di origine.
Se i controlli di servizio VPC sono configurati nel progetto, la tabella dei risultati deve trovarsi nello stesso perimetro dei controlli di servizio VPC della tabella di origine.
Se la tabella viene modificata durante la fase di esecuzione della scansione, il job in esecuzione corrente viene esportato nella tabella dei risultati precedente e la modifica della tabella ha effetto a partire dal job di scansione successivo.
Non modificare lo schema della tabella. Se hai bisogno di colonne personalizzate, crea una vista nella 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.

Crea più scansioni del profilo dati

Puoi configurare le scansioni di profilazione dei dati per più tabelle in un set di dati BigQuery contemporaneamente utilizzando la console Google Cloud .

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

Vai a Profilazione e qualità dei dati
Fai clic su Crea scansione di profilazione dei dati.
Seleziona l'opzione Più scansioni di profilazione dei dati.
Inserisci un prefisso ID. Knowledge Catalog genera automaticamente gli ID scansione utilizzando il prefisso fornito e i suffissi unici.
Inserisci una Descrizione per tutte le scansioni del profilo dati.
Nel campo Set di dati, fai clic su Sfoglia. Seleziona un set di dati da cui scegliere le tabelle. Fai clic su Seleziona.
Se il set di dati è multiregionale, seleziona una regione in cui creare le scansioni del profilo dati.
Nella sezione Modalità, scegli una delle seguenti opzioni:
- Standard: profila i tuoi dati con impostazioni di scansione personalizzabili. Si tratta della modalità predefinita.
- Leggera: fornisce informazioni rapide con una scansione a bassa latenza e bassa fedeltà. Questa funzionalità è in anteprima.
Se hai scelto la modalità Standard, configura le seguenti impostazioni per le scansioni. Queste impostazioni non vengono visualizzate quando è selezionata la modalità Leggera.
1. Nel campo Ambito, scegli Incrementale o Tutti i dati.
  
  Se scegli i dati incrementali, puoi selezionare solo le tabelle partizionate in base a una colonna di tipo DATE o TIMESTAMP.
2. Per applicare il campionamento alle scansioni del profilo dati, seleziona una percentuale di campionamento nell'elenco Dimensione campionamento.
  
  Scegli una percentuale compresa tra 0,0% e 100,0% con un massimo di tre cifre decimali.
(Facoltativo) Pubblica i risultati della scansione di profilazione dei dati nelle pagine BigQuery e Knowledge Catalog della consoleGoogle Cloud per la tabella di origine. Seleziona la casella di controllo Pubblica i risultati in Knowledge Catalog.

Puoi visualizzare i risultati più recenti della scansione nella scheda Profilo 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 Concedere l'accesso ai risultati della scansione del profilo di dati di questo documento.

Nota: devi scegliere tabelle per cui non è stata ancora pubblicata alcuna scansione dei risultati.
Nella sezione Pianificazione, scegli una delle seguenti opzioni:
- Ripeti: esegui le scansioni del profilo dei dati in base a una pianificazione: oraria, giornaliera, settimanale, mensile o personalizzata. Specifica la frequenza di esecuzione delle scansioni e l'ora. Se scegli l'opzione personalizzata, utilizza il formato cron per specificare la pianificazione.
- On demand: esegui le scansioni di profilazione dei dati on demand.
  - Esecuzione una tantum: esegui la scansione di profilazione dei dati una volta ora e rimuovi la scansione dopo il periodo di eliminazione automatica. Questa funzionalità è in anteprima.
    - Imposta l'eliminazione automatica dei risultati post-scansione: il tempo di eliminazione automatica definisce la durata per cui una scansione di profilazione dei dati rimane attiva dopo l'esecuzione. Una scansione di profilazione dei dati senza un'ora di eliminazione automatica specificata viene rimossa automaticamente dopo 24 ore. Il tempo di eliminazione automatica può variare da 0 secondi (eliminazione immediata) a 365 giorni.
Fai clic su Continua.
Nel campo Scegli tabelle, fai clic su Sfoglia. Scegli una o più tabelle da scansionare, quindi fai clic su Seleziona.
Fai clic su Continua.
(Facoltativo) Esporta i risultati della scansione in una tabella standard BigQuery. Nella sezione Esporta i risultati della scansione in una tabella BigQuery, esegui le seguenti operazioni:
1. Nel campo Seleziona set di dati BigQuery, fai clic su Sfoglia. Seleziona un set di dati BigQuery per archiviare i risultati della scansione di profilazione dei dati.
2. Nel campo Tabella BigQuery, specifica la tabella in cui archiviare i risultati della scansione di profilazione 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 automaticamente.
  
  Knowledge Catalog utilizza la stessa tabella dei risultati per tutte le analisi del profilo dei dati.
(Facoltativo) Aggiungi etichette. Le etichette sono coppie chiave-valore che consentono di raggruppare oggetti correlati fra loro o con altre risorse Google Cloud .
Per creare le scansioni, fai clic su Crea.

Se imposti la pianificazione su on demand, puoi anche eseguire le scansioni ora facendo clic su Esegui scansione.

Esegui una scansione di profilazione dei dati

Console

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

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

gcloud

Per eseguire una scansione di profilazione dei dati, utilizza il comando gcloud dataplex datascans run:

gcloud dataplex datascans run DATASCAN \
--location=LOCATION

Sostituisci le seguenti variabili:

DATASCAN: Il nome della scansione di profilazione dei dati.
LOCATION: la regione Google Cloud in cui è stata creata la scansione di profilazione 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);
    }
}

Go


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 di profilazione dei dati, utilizza il metodo dataScans.run.

Visualizzare i risultati della scansione di profilazione dei dati

Console

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

Vai a Profilazione e qualità dei dati
Fai clic sul nome di una scansione di profilazione dei dati.
- La sezione Panoramica mostra informazioni sui job più recenti, tra cui la data di esecuzione della scansione, il numero di record della tabella scansionati e lo stato del job.
- La sezione Configurazione della scansione di profilazione dei dati mostra i dettagli della scansione.
Per visualizzare informazioni dettagliate su un job, ad esempio le colonne della tabella scansionata, le statistiche sulle colonne trovate nella scansione e i log del job, fai clic sulla scheda Cronologia job. Quindi, fai clic su un ID job.

gcloud

Per visualizzare i risultati di un job di scansione di profilazione 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 di profilazione dei dati.
LOCATION: la regione Google Cloud in cui è stata creata la scansione di profilazione dei dati.
DATASCAN: il nome della scansione di profilazione 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);
    }
}

Go


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 di profilazione dei dati, utilizza il metodo dataScans.get.

Visualizzare i risultati pubblicati

Se i risultati della scansione di profilazione dei dati vengono pubblicati nelle pagine BigQuery e Knowledge Catalog della console Google Cloud , puoi visualizzare i risultati più recenti della scansione nella scheda Profilo di dati della tabella di origine.

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

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

Vengono visualizzati gli ultimi risultati pubblicati.

Nota: i risultati pubblicati potrebbero non essere disponibili se viene eseguita una scansione per la prima volta.

Visualizza il job di scansione di profilazione dei dati più recente

Console

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

Vai a Profilazione e qualità dei dati
Fai clic sul nome di una scansione di profilazione dei dati.
Fai clic sulla scheda Risultati del job più recente.

La scheda Risultati del job più recente, quando è presente almeno un'esecuzione completata correttamente, fornisce informazioni sul job più recente. Elenca le colonne e le statistiche della tabella scansionata relative alle colonne trovate nella scansione.

gcloud

Per visualizzare la scansione di profilazione dei dati riuscita più recente, utilizza il comando gcloud dataplex datascans describe:

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

Sostituisci le seguenti variabili:

DATASCAN: il nome della scansione di profilazione dei dati per visualizzare il job più recente.
LOCATION: la Google Cloud regione in cui è stata creata la scansione di profilazione dei dati.
--view=FULL: per visualizzare il risultato del job di scansione, specifica FULL.

REST

Per visualizzare il job di scansione più recente, utilizza il metodo dataScans.get.

Visualizzare i risultati storici delle scansioni

Knowledge Catalog salva la cronologia delle scansioni di profilazione dei dati degli ultimi 300 job o dell'ultimo anno, a seconda di quale evento si è verificato prima.

Console

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

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

La scheda Cronologia job fornisce informazioni sui job precedenti, ad esempio il numero di record scansionati in ogni job, lo stato del job e l'ora in cui è stato eseguito il job.
Per visualizzare informazioni dettagliate su un job, fai clic su uno qualsiasi dei job nella colonna ID job.

gcloud

Per visualizzare i job di scansione di profilazione 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 Google Cloud regione in cui è stata creata la scansione di profilazione dei dati.
DATASCAN: il nome della scansione di profilazione dei dati per visualizzare i job.

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

Go


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 di profilazione dei dati storici, utilizza il metodo dataScans.jobs.list.

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

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

Vai a Profilazione e qualità dei dati
Fai clic sulla scansione di profilazione 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 e poi conferma quando richiesto.

Gestire le scansioni del profilo di dati per una tabella specifica

I passaggi descritti in questo documento mostrano come gestire le scansioni dei profili 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 le scansioni dei profili dei dati quando lavori con una tabella specifica. Nella console Google Cloud , nella pagina Knowledge Catalog per la tabella, utilizza la scheda Profilo dei dati. Segui questi passaggi:

Nella console Google Cloud , vai alla pagina Ricerca del catalogo delle conoscenze.

Vai a Cerca

Cerca e seleziona la tabella.
Fai clic sulla scheda Profilo dei dati.
A seconda che la tabella abbia una scansione di profilazione dei dati i cui risultati sono pubblicati, puoi lavorare con le scansioni di profilazione dei dati della tabella nei seguenti modi:
- I risultati della scansione di profilazione dei dati sono pubblicati: nella pagina vengono visualizzati i risultati dell'ultima scansione pubblicata.
  
  Per gestire le scansioni del profilo di dati per questa tabella, fai clic su Scansione del profilo di dati e poi scegli una delle seguenti opzioni:
  - Crea nuova scansione: crea una nuova scansione di profilazione dei dati. Per saperne di più, consulta la sezione Crea una scansione di profilazione dei dati di questo documento. Quando crei una scansione dalla pagina dei dettagli di una tabella, la tabella è preselezionata.
  - Esegui ora: esegui la scansione.
  - Modifica configurazione di scansione: modifica le impostazioni, tra cui il nome visualizzato, i filtri, le dimensioni del campionamento e la pianificazione.
  - Gestisci autorizzazioni della scansione: controlla chi può accedere ai risultati della scansione. Per saperne di più, consulta la sezione Concedere l'accesso ai risultati della scansione di profilazione dei dati di questo documento.
  - Visualizza risultati cronologici: visualizza informazioni dettagliate sui job di scansione di profilazione dei dati precedenti. Per saperne di più, consulta le sezioni Visualizzare i risultati della scansione di profilazione dei dati e Visualizzare i risultati delle scansioni storiche di questo documento.
  - Visualizza tutte le scansioni: visualizza un elenco delle scansioni di profilazione dei dati che si applicano a questa tabella.
- I risultati della scansione di profilazione dei dati non vengono pubblicati: fai clic sul menu accanto a Profilo dati rapido e seleziona una delle seguenti opzioni:
  - Personalizza la profilazione dei dati: crea una nuova scansione di profilazione dei dati. Per saperne di più, consulta la sezione Creare una scansione di profilazione dei dati di questo documento. Quando crei una scansione dalla pagina dei dettagli di una tabella, la tabella è preselezionata.
  - Visualizza profili precedenti: visualizza un elenco delle scansioni del profilo di dati che si applicano a questa tabella.

Aggiorna una scansione di profilazione dei dati

Console

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

Vai a Profilazione e qualità dei dati
Fai clic sul nome di una scansione di profilazione dei dati.
Fai clic su Modifica e poi modifica i valori.
Fai clic su Salva.

gcloud

Per aggiornare una scansione di profilazione dei dati, utilizza il comando gcloud dataplex datascans update data-profile:

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

Sostituisci le seguenti variabili:

DATASCAN: il nome della scansione di profilazione dei dati da aggiornare.
LOCATION: la Google Cloud regione in cui è stata creata la scansione di profilazione dei dati.
DESCRIPTION: La nuova descrizione della scansione del profilo 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;
        }
    }
}

Go


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 una scansione di profilazione dei dati, utilizza il metodo dataScans.patch.

Eliminare una scansione di profilazione dei dati

Console

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

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 di profilazione dei dati, utilizza il comando gcloud dataplex datascans delete:

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

Sostituisci le seguenti variabili:

DATASCAN: il nome della scansione di profilazione dei dati da eliminare.
LOCATION: la Google Cloud regione in cui è stata creata la scansione di profilazione dei dati.

REST

Per eliminare una scansione di profilazione dei dati, utilizza il metodo dataScans.delete.

Passaggi successivi

Scopri come esplorare i dati generando insight.
Scopri di più sulla profilazione dei dati.
Scopri di più sulla qualità dei dati automatica.
Scopri come utilizzare la qualità dei dati automatica.

Creare e utilizzare le analisi del profilo di dati 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

Concedi ruoli al account di servizio Knowledge Catalog

Configura l'identità di esecuzione

Autorizzazioni richieste per le identità di esecuzione personalizzate

Console

Google Cloud CLI

API

Crea una scansione di profilazione dei dati

Console

gcloud

C#

C#

Go

Go

Java

Java

Python

Python

Ruby

Ruby

REST

Esporta schema tabella

Configurazione dell'esportazione della tabella

Crea più scansioni del profilo dati

Esegui una scansione di profilazione dei dati

Console

gcloud

C#

C#

Go

Go

Java

Java

Python

Python

Ruby

Ruby

REST

Visualizzare i risultati della scansione di profilazione dei dati

Console

gcloud

C#

C#

Go

Go

Java

Java

Python

Python

Ruby

Ruby

REST

Visualizzare i risultati pubblicati

Visualizza il job di scansione di profilazione dei dati più recente

Console

gcloud

REST

Visualizzare i risultati storici delle scansioni

Console

gcloud

C#

C#

Go

Go

Java

Java

Python

Python

Ruby

Ruby

REST

Concedere l'accesso ai risultati della scansione di profilazione dei dati

Gestire le scansioni del profilo di dati per una tabella specifica

Aggiorna una scansione di profilazione dei dati

Creare e utilizzare le analisi del profilo di dati