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.

Creare prodotti di dati

Questo documento è rivolto ai proprietari di prodotti di dati che vogliono creare e configurare prodotti di dati in Knowledge Catalog (in precedenza Dataplex Universal Catalog). Quando definisci queste risorse, assicurati che i relativi ID rispettino le linee guida per la denominazione delle risorse di Knowledge Catalog.

Per ulteriori informazioni sull'architettura e sui concetti chiave dei prodotti di dati, consulta Informazioni sui prodotti di dati.

Prima di iniziare

Prima di creare prodotti di dati, completa i seguenti prerequisiti.

Abilita Gemini

La configurazione di Gemini nell'asset di dati è un passaggio facoltativo, ma vivamente consigliato prima di creare il primo prodotto di dati.

Per impostazione predefinita, la creazione di un prodotto di dati richiede l'inserimento manuale di descrizioni dell'attività, definizioni tecniche e documentazione di onboarding per gli asset. Quando attivi l'integrazione di Gemini, Knowledge Catalog sfrutta l'assistenza AI per analizzare automaticamente gli schemi e i risultati dell'analisi dei dati per generare quanto segue:

Documentazione aziendale: genera modelli di documentazione e descrizioni chiare per il tuo prodotto di dati e i singoli asset di dati.
Insight e query di esempio: crea query di esempio pronte all'uso in base al layout dello schema dell'asset, consentendo ai consumer di dati di iniziare immediatamente a eseguire query sul prodotto dopo l'approvazione.

Se scegli di non attivare Gemini, puoi saltare questa sezione. Tuttavia, devi fornire manualmente tutti i metadati degli asset e i modelli di query durante la creazione.

Per saperne di più sull'attivazione di Gemini in BigQuery, consulta Configura Gemini in BigQuery.

Abilita API

Abilita le API Dataplex e BigQuery, se non sono già abilitate.

Ruoli richiesti per abilitare le API

Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente disponi già di 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.

Abilita le API

Crea asset di dati

Assicurati che gli asset di dati (ad esempio set di dati, tabelle e viste BigQuery) siano creati e compilati.

Per saperne di più sulla creazione di asset di dati, consulta i seguenti documenti:

Configura le identità

Identifica o crea i gruppi Google o i service account che vuoi configurare nel tuo prodotto di dati.

(Facoltativo) Configura Looker (Google Cloud core) per i prodotti di dati

Se prevedi di includere asset di Looker (Google Cloud core) nel tuo prodotto di dati, completa i seguenti passaggi aggiuntivi:

Assicurati che la voce del catalogo per la risorsa Looker (Google Cloud core) esista già in Knowledge Catalog nella stessa regione del prodotto di dati. Per saperne di più, consulta Gestisci le risorse di Looker (Google Cloud core) con Knowledge Catalog.
Configura Google OAuth e attiva i gruppi con mirroring nella tua istanza di Looker (Google Cloud core) per creare un gruppo di Looker di sola lettura per il tuo gruppo Google.
Assegna livelli di accesso alle cartelle e ruoli di Looker al gruppo di Looker sottoposto a mirroring.

Ruoli obbligatori

Questa sezione descrive i ruoli IAM minimi richiesti per le seguenti sezioni principali:

Proprietari di prodotti dati: utenti che creano, configurano e gestiscono i prodotti dati e gli asset associati
Consumer di prodotti di dati: utenti che cercano, visualizzano e richiedono l'accesso ai prodotti di dati pubblicati

Ruoli obbligatori per i proprietari dei prodotti di dati

Per ottenere le autorizzazioni necessarie per creare e gestire i prodotti di dati, chiedi all'amministratore di concederti i seguenti ruoli IAM nel progetto:

Autorizzazioni complete per creare, aggiornare, eliminare, gestire le autorizzazioni e approvare o rifiutare le richieste di accesso per i prodotti di dati: Dataplex Data Products Admin (roles/dataplex.dataProductsAdmin)
Aggiorna e gestisci le autorizzazioni e approva o rifiuta le richieste di accesso ai prodotti di dati: Dataplex Data Products Editor (roles/dataplex.dataProductsEditor)
Aggiungi aspetti dei metadati (come schema, overview, contacts e queries): Dataplex Entry and EntryLink Owner (roles/dataplex.entryOwner)
Cerca e aggiungi asset annuncio: Dataplex Catalog Viewer (roles/dataplex.catalogViewer)
Modifica i tipi di aspetto di sistema (come overview, contact, contract e queries): Dataplex Catalog Editor (roles/dataplex.catalogEditor)
Crea o recupera le scansioni dei dati degli insight per la generazione automatica di documentazione e insight: Dataplex DataScan Admin (roles/dataplex.dataScanAdmin)
Accedi ai metadati di Looker (Google Cloud core) in Knowledge Catalog: Looker Schema Viewer (roles/looker.schemaViewer) - nel progetto che ospita l'istanza di Looker (Google Cloud core)
Concedi roles/looker.instanceUser al gruppo Google del gruppo di accesso: Amministratore IAM progetto (roles/resourcemanager.projectIamAdmin) - sul progetto che ospita l'istanza di Looker (Google Cloud core)

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 i prodotti di dati. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per creare e gestire i prodotti di dati sono necessarie le seguenti autorizzazioni:

Crea un prodotto di dati: dataplex.dataProducts.create
Elenca i prodotti di dati in un progetto: dataplex.dataProducts.list
Recupera o visualizza il prodotto di dati: dataplex.dataProducts.get
Modifica un prodotto di dati esistente: dataplex.dataProducts.update
Elimina il prodotto di dati: dataplex.dataProducts.delete
Approva la richiesta di accesso al prodotto di dati: dataplex.dataProducts.approve
Cerca un prodotto di dati utilizzando Knowledge Catalog:
- dataplex.dataProducts.get
- dataplex.projects.search
Crea una richiesta di accesso al prodotto di dati: dataplex.dataProducts.get
Crea un asset di dati: dataplex.dataAssets.create
Elenca gli asset di dati all'interno di un prodotto di dati: dataplex.dataAssets.list
Recupera l'asset di dati: dataplex.dataAssets.get
Modifica un asset di dati esistente: dataplex.dataAssets.update
Elimina l'asset di dati: dataplex.dataAssets.delete
Crea un'analisi dei dati: dataplex.datascans.create
Elenca tutte le analisi dei dati: dataplex.datascans.list
Ottieni un'analisi dei dati: dataplex.datascans.get
Esegui un'analisi dei dati: dataplex.datascans.run
Modifica il tipo di aspetto di sistema overview: dataplex.entryGroups.useOverviewAspect
Modifica il tipo di aspetto di sistema refresh cadence: dataplex.entryGroups.useRefreshCadenceAspect
Modifica il tipo di aspetto di sistema queries: dataplex.entryGroups.useQueriesAspect

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

Ruoli richiesti per i consumer di prodotti di dati

Affinché i consumer di prodotti di dati possano cercare, visualizzare e richiedere l'accesso ai prodotti di dati, in qualità di proprietario di un prodotto di dati devi assicurarti che il prodotto di dati sia rilevabile. Per farlo, concedi ai consumer del prodotto di dati i seguenti ruoli IAM sul prodotto di dati:

Cercare prodotti di dati e richiedere l'accesso: Dataplex Data Product Consumer (dataplex.dataProductsConsumer) e Dataplex Catalog Viewer (roles/dataplex.catalogViewer)
Accesso di sola lettura per visualizzare le definizioni e i metadati dei prodotti di dati: Dataplex Data Product Viewer (dataplex.dataProductsViewer)

Crea e configura un prodotto di dati

La creazione di un prodotto di dati prevede le seguenti attività di alto livello:

Crea un prodotto di dati

Questo passaggio iniziale obbligatorio richiede la definizione di dettagli fondamentali come un nome univoco del prodotto di dati, una descrizione, la regione in cui viene creato il prodotto di dati e i dati di contatto.
(Facoltativo) Aggiungi asset

In questa fase, selezioni gli asset da includere nel prodotto di dati. Un vincolo chiave è che gli asset devono trovarsi nella stessa regione del prodotto di dati stesso. Puoi aggiungere fino a 10 asset alla volta, con un massimo di 50 asset consentiti per prodotto di dati.

Per l'elenco degli asset supportati, consulta Asset supportati.
(Facoltativo) Configura i gruppi di accesso e le autorizzazioni per gli asset

In questa fase facoltativa, semplifichi controllo dell'accesso creando gruppi di accesso. Questi gruppi di accesso fungono da alias facili da usare (ad esempio, Analyst o Reader) per i gruppi Google e i service account sottostanti. Quindi, assegni le autorizzazioni selezionando un ruolo IAM specifico e mappandolo a un gruppo di accesso per un asset specifico.
(Facoltativo) Aggiungi dettagli del contratto e dell'aspetto

In questa fase, migliorerai la governance e la rilevabilità dei dati collegando i framework dei metadati. Puoi aggiungere un contratto per comunicare formalmente la cadenza di aggiornamento dei dati, specificando parametri come la frequenza di aggiornamento, la tempistica e le soglie di variazione. Puoi anche allegare aspetti personalizzati per fornire metadati aziendali o tecnici aggiuntivi per il tuo prodotto di dati.
(Facoltativo) Aggiungi ulteriori dettagli

In questa fase finale, aggiungi documentazione in formato RTF, come guide per l'onboarding degli utenti, definizioni aziendali e query di esempio, per aiutare i consumer a interagire con il prodotto di dati immediatamente dopo l'approvazione.

Per creare e configurare un prodotto di dati, completa i passaggi descritti nelle sezioni seguenti:

Crea un prodotto di dati

Console

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

Vai a Prodotti di dati
Fai clic su Crea.
Nel riquadro Crea prodotti di dati, inserisci i seguenti dettagli:
- Nome del prodotto di dati: inserisci un nome univoco per il prodotto di dati.
- ID prodotto di dati: si tratta di un identificatore univoco generato automaticamente. Questo campo è modificabile.
- ID progetto: l'identificatore univoco del progetto in cui viene creato il prodotto di dati. Sfoglia e seleziona il progetto.
- Regione: seleziona la regione o la multiregione in cui viene creato il prodotto di dati.
- Icona del prodotto di dati: sfoglia e seleziona un'icona per identificare visivamente il prodotto di dati. Questa opzione è facoltativa.
- Descrizione: inserisci una breve descrizione del prodotto di dati.
- Contatti: fornisci i dati di contatto per i workflow di governance e approvazione:
  - Indirizzo email dei proprietari del prodotto di dati: inserisci l'indirizzo email dei proprietari del prodotto di dati.
  - Indirizzo email degli approvatori del prodotto di dati:inserisci l'indirizzo email degli approvatori designati responsabili della firma delle richieste di accesso o delle modifiche.
- Etichette: aggiungi coppie chiave-valore per organizzare le risorse. Questo passaggio è facoltativo.
Fai clic su Crea prodotto di dati.

Terraform

Per creare un prodotto di dati, utilizza le risorse google_dataplex_data_product e IAM.

resource "google_dataplex_data_product" "default" {
  project         = "PROJECT_ID"
  location        = "LOCATION"
  data_product_id = "DATA_PRODUCT_ID"
  display_name    = "DISPLAY_NAME"
  description     = "DESCRIPTION"
  owner_emails    = ["EMAIL_IDs"]

  # Optional: Configures designated approvers for access requests
  access_approval_config {
    approver_emails = ["APPROVER_EMAIL_IDs"]
  }

  # Optional: Base64-encoded icon (Max 3.0MiB)
  icon = "ICON_BASE64_STRING"
}

resource "google_dataplex_data_product_iam_member" "consumer_binding" {
  project         = "PROJECT_ID"
  location        = "LOCATION"
  data_product_id = "DATA_PRODUCT_ID"
  role            = "roles/dataplex.dataProductsConsumer"
  member          = "MEMBER"
}

Sostituisci quanto segue:

PROJECT_ID: l'ID del tuo progetto Google Cloud .
LOCATION: la regione in cui vuoi creare il prodotto di dati.
DATA_PRODUCT_ID: un ID univoco per il tuo prodotto di dati.
DISPLAY_NAME: un nome facile da ricordare per il tuo prodotto di dati.
DESCRIPTION: una breve descrizione del prodotto di dati.
EMAIL_IDs: indirizzi email separati da virgole dei proprietari del prodotto di dati, ad esempio ["user1@example.com", "user2@example.com"].
APPROVER_EMAIL_IDs: indirizzi email separati da virgole degli approvatori designati responsabili della firma delle richieste di accesso o delle modifiche per questo prodotto di dati.
ICON_BASE64_STRING: i dati dell'immagine non elaborati codificati in base64 che rappresentano il prodotto di dati. La dimensione massima è 3,0 MiB. Non includere il prefisso dello schema URL dei dati.
MEMBER: l'utente, il account di servizio o il gruppo che riceve il ruolo Consumer (ad esempio group:all-analysts@example.com).

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 GeneratedDataProductServiceClientSnippets
{
    /// <summary>Snippet for CreateDataProduct</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 CreateDataProductRequestObject()
    {
        // Create client
        DataProductServiceClient dataProductServiceClient = DataProductServiceClient.Create();
        // Initialize request argument(s)
        CreateDataProductRequest request = new CreateDataProductRequest
        {
            ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
            DataProductId = "",
            DataProduct = new DataProduct(),
            ValidateOnly = false,
        };
        // Make the request
        Operation<DataProduct, OperationMetadata> response = dataProductServiceClient.CreateDataProduct(request);

        // Poll until the returned long-running operation is complete
        Operation<DataProduct, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        DataProduct 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<DataProduct, OperationMetadata> retrievedResponse = dataProductServiceClient.PollOnceCreateDataProduct(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            DataProduct 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.NewDataProductClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.CreateDataProductRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#CreateDataProductRequest.
	}
	op, err := c.CreateDataProduct(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.CreateDataProductRequest;
import com.google.cloud.dataplex.v1.DataProduct;
import com.google.cloud.dataplex.v1.DataProductServiceClient;
import com.google.cloud.dataplex.v1.LocationName;

public class SyncCreateDataProduct {

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

  public static void syncCreateDataProduct() 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 (DataProductServiceClient dataProductServiceClient = DataProductServiceClient.create()) {
      CreateDataProductRequest request =
          CreateDataProductRequest.newBuilder()
              .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
              .setDataProductId("dataProductId1437828576")
              .setDataProduct(DataProduct.newBuilder().build())
              .setValidateOnly(true)
              .build();
      DataProduct response = dataProductServiceClient.createDataProductAsync(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.

/**
 * 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 parent resource where this data product will be created.
 *  Format: projects/{project_id_or_number}/locations/{location_id}
 */
// const parent = 'abc123'
/**
 *  Optional. The ID of the data product to create.
 *  The ID must conform to RFC-1034 and contain only lower-case letters (a-z),
 *  numbers (0-9), or hyphens, with the first character a letter, the last a
 *  letter or a number, and a 63 character maximum. Characters outside of
 *  ASCII are not permitted.
 *  Valid format regex: `^[a-z]([a-z0-9-]{0,61}[a-z0-9])?$`
 *  If not provided, a system generated ID will be used.
 */
// const dataProductId = 'abc123'
/**
 *  Required. The data product to create.
 */
// const dataProduct = {}
/**
 *  Optional. Validates the request without actually creating the data product.
 *  Default: false.
 */
// const validateOnly = true

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

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

async function callCreateDataProduct() {
  // Construct request
  const request = {
    parent,
    dataProduct,
  };

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

callCreateDataProduct();

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_product():
    # Create a client
    client = dataplex_v1.DataProductServiceClient()

    # Initialize request argument(s)
    data_product = dataplex_v1.DataProduct()
    data_product.display_name = "display_name_value"
    data_product.owner_emails = ["owner_emails_value1", "owner_emails_value2"]

    request = dataplex_v1.CreateDataProductRequest(
        parent="parent_value",
        data_product=data_product,
    )

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

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

    response = operation.result()

    # Handle the response
    print(response)

REST

Per creare un prodotto di dati, utilizza il metodo dataProducts.create.

Ad esempio, invia la seguente richiesta POST:

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
-d '{"display_name": "DISPLAY_NAME", "owner_emails": ["EMAIL_IDs"], "access_approval_config": { "approver_emails": ["APPROVER_EMAIL_IDs"]} }' \
https://dataplex.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/dataProducts?data_product_id=DATA_PRODUCT_ID

Sostituisci quanto segue:

DISPLAY_NAME: un nome facile da usare per il tuo prodotto di dati
EMAIL_IDs: indirizzi email separati da virgole dei proprietari del prodotto di dati
APPROVER_EMAIL_IDs: indirizzi email separati da virgole degli approvatori designati responsabili della firma delle richieste di accesso o delle modifiche.
PROJECT_ID: l'ID del tuo progetto Google Cloud
LOCATION: la regione in cui vuoi creare il prodotto di dati
DATA_PRODUCT_ID: un ID univoco per il tuo prodotto di dati

(Facoltativo) Aggiungi asset

Puoi aggiungere al tuo prodotto di dati vari asset di dati, come tabelle BigQuery, viste, set di dati e modelli. Per l'elenco degli asset supportati, consulta Asset supportati.

Console

Nel riquadro Aggiungi asset, fai clic su +Aggiungi.
Cerca e seleziona gli asset che vuoi aggiungere al tuo prodotto di dati. Gli asset selezionati devono trovarsi nella stessa regione del prodotto di dati.

Se disponi delle autorizzazioni necessarie, puoi visualizzare i metadati degli asset facendo clic sull'asset.
Per perfezionare i risultati di ricerca, utilizza i filtri.
Dopo aver selezionato gli asset, fai clic su Aggiungi.

Nota: È possibile aggiungere fino a 10 risorse alla volta, con un massimo totale di 50 risorse consentite per prodotto dati.
Fai clic su Continua.

Terraform

Per aggiungere un asset di dati al tuo prodotto di dati, utilizza la risorsa google_dataplex_data_product_data_asset.

resource "google_dataplex_data_product_data_asset" "example_asset" {
project         = "PROJECT_ID"
location        = "LOCATION"
data_product_id = "DATA_PRODUCT_ID"
data_asset_id   = "DATA_ASSET_ID"
resource        = "RESOURCE_NAME"
}

Sostituisci quanto segue:

PROJECT_ID: l'ID del tuo progetto Google Cloud
LOCATION: la regione in cui si trova il prodotto di dati
DATA_PRODUCT_ID: l'ID del prodotto di dati
DATA_ASSET_ID: un ID univoco per questo asset di dati all'interno del prodotto di dati
RESOURCE_NAME: il nome completo della risorsa dell'asset di dati (ad esempio, //bigquery.googleapis.com/projects/PROJECT_ID/datasets/DATASET_ID/tables/TABLE_ID)

C#

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

public sealed partial class GeneratedDataProductServiceClientSnippets
{
    /// <summary>Snippet for CreateDataAsset</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 CreateDataAssetRequestObject()
    {
        // Create client
        DataProductServiceClient dataProductServiceClient = DataProductServiceClient.Create();
        // Initialize request argument(s)
        CreateDataAssetRequest request = new CreateDataAssetRequest
        {
            ParentAsDataProductName = DataProductName.FromProjectLocationDataProduct("[PROJECT]", "[LOCATION]", "[DATA_PRODUCT]"),
            DataAssetId = "",
            DataAsset = new DataAsset(),
            ValidateOnly = false,
        };
        // Make the request
        Operation<DataAsset, OperationMetadata> response = dataProductServiceClient.CreateDataAsset(request);

        // Poll until the returned long-running operation is complete
        Operation<DataAsset, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        DataAsset 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<DataAsset, OperationMetadata> retrievedResponse = dataProductServiceClient.PollOnceCreateDataAsset(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            DataAsset 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.NewDataProductClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.CreateDataAssetRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#CreateDataAssetRequest.
	}
	op, err := c.CreateDataAsset(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.CreateDataAssetRequest;
import com.google.cloud.dataplex.v1.DataAsset;
import com.google.cloud.dataplex.v1.DataProductName;
import com.google.cloud.dataplex.v1.DataProductServiceClient;

public class SyncCreateDataAsset {

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

  public static void syncCreateDataAsset() 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 (DataProductServiceClient dataProductServiceClient = DataProductServiceClient.create()) {
      CreateDataAssetRequest request =
          CreateDataAssetRequest.newBuilder()
              .setParent(DataProductName.of("[PROJECT]", "[LOCATION]", "[DATA_PRODUCT]").toString())
              .setDataAssetId("dataAssetId2108984609")
              .setDataAsset(DataAsset.newBuilder().build())
              .setValidateOnly(true)
              .build();
      DataAsset response = dataProductServiceClient.createDataAssetAsync(request).get();
    }
  }
}

Node.js

/**
 * 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 parent resource where this data asset will be created.
 *  Format:
 *  projects/{project_id_or_number}/locations/{location_id}/dataProducts/{data_product_id}
 */
// const parent = 'abc123'
/**
 *  Optional. The ID of the data asset to create.
 *  The ID must conform to RFC-1034 and contain only lower-case letters (a-z),
 *  numbers (0-9), or hyphens, with the first character a letter, the last a
 *  letter or a number, and a 63 character maximum. Characters outside of
 *  ASCII are not permitted.
 *  Valid format regex: `^[a-z]([a-z0-9-]{0,61}[a-z0-9])?$`
 *  If not provided, a system generated ID will be used.
 */
// const dataAssetId = 'abc123'
/**
 *  Required. The data asset to create.
 */
// const dataAsset = {}
/**
 *  Optional. Validates the request without actually creating the data asset.
 *  Defaults to false.
 */
// const validateOnly = true

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

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

async function callCreateDataAsset() {
  // Construct request
  const request = {
    parent,
    dataAsset,
  };

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

callCreateDataAsset();

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_asset():
    # Create a client
    client = dataplex_v1.DataProductServiceClient()

    # Initialize request argument(s)
    data_asset = dataplex_v1.DataAsset()
    data_asset.resource = "resource_value"

    request = dataplex_v1.CreateDataAssetRequest(
        parent="parent_value",
        data_asset=data_asset,
    )

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

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

    response = operation.result()

    # Handle the response
    print(response)

REST

Per aggiungere un asset di dati al tuo prodotto di dati, utilizza il metodo dataAssets.create.

Ad esempio, invia la seguente richiesta POST:

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
-d '{"resource": "RESOURCE_NAME"}' \
https://dataplex.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/dataProducts/DATA_PRODUCT_ID/dataAssets?data_asset_id=DATA_ASSET_ID

Sostituisci quanto segue:

RESOURCE_NAME: il nome completo della risorsa dell'asset di dati (ad esempio, //bigquery.googleapis.com/projects/PROJECT_ID/datasets/DATASET_ID/tables/TABLE_ID)
PROJECT_ID: l'ID del tuo progetto Google Cloud
LOCATION: la regione in cui si trova il prodotto di dati
DATA_PRODUCT_ID: l'ID del prodotto di dati
DATA_ASSET_ID: un ID univoco per questo asset di dati all'interno del prodotto di dati

(Facoltativo) Configura i gruppi di accesso e le autorizzazioni per gli asset

Nel riquadro Configura i gruppi di accesso e le autorizzazioni per gli asset, puoi creare gruppi di accesso e assegnare autorizzazioni agli asset.

Configura gruppi di accesso

Console

Fai clic su Aggiungi gruppo di accesso.
Nel campo Nome gruppo di accesso, inserisci un nome per il gruppo di accesso. Ad esempio, Analyst.
Nel campo Descrizione gruppo di accesso, inserisci una descrizione per il gruppo di accesso.
Nel campo Identificatore gruppo di accesso, inserisci l'indirizzo email di un gruppo Google che vuoi assegnare a questo gruppo di accesso.

I consumer del prodotto di dati che richiedono l'accesso per se stessi vengono aggiunti come membri al gruppo Google mappato.

Per saperne di più sulla creazione di gruppi Google, consulta Crea e gestisci gruppi Google nella console Google Cloud .
Nel campo Service account del gruppo di accesso, inserisci l'indirizzo email di un account di servizio che vuoi assegnare a questo gruppo di accesso.

Ai consumer del prodotto di dati che richiedono l'accesso per i propri service account viene concesso il ruolo IAM Creatore token account di servizio (roles/iam.serviceAccountTokenCreator) per simulare l'identità del service account del producer di dati mappato al gruppo di accesso.

Per ulteriori informazioni sulla creazione dei service account, consulta Crea service account.
(Facoltativo) Nel campo Ruolo predefinito, seleziona un ruolo IAM predefinito (ad esempio BigQuery Data Viewer) per questo gruppo di accesso. Questo ruolo viene concesso automaticamente su tutti gli asset supportati esistenti e appena aggiunti nel prodotto di dati, a meno che non venga eseguito l'override a livello di asset.
Fai clic su Fine.
Per aggiungere un altro gruppo di accesso, fai clic su Aggiungi gruppo di accesso e ripeti i passaggi.

Puoi aggiungere un massimo di tre gruppi di accesso per prodotto di dati.
Fai clic su Salva.

Terraform

Per definire i gruppi di accesso per il tuo prodotto di dati, utilizza il blocco nidificato access_groups all'interno della risorsa google_dataplex_data_product.

Ad esempio, utilizza la seguente configurazione:

resource "google_dataplex_data_product" "example_data_product" {
  project         = "PROJECT_ID"
  location        = "LOCATION"
  data_product_id = "DATA_PRODUCT_ID"
  display_name    = "DISPLAY_NAME"
  owner_emails    = ["EMAIL_IDs"]

  access_groups {
    id           = "analyst" # Internal identifier for configuration
    group_id     = "analyst" # Unique identifier of the access group, should be same as the 'id'
    display_name = "Business Analyst"
    description  = "Access group for regional analysts"
    principal {
      google_group = "analyst-team@example.com"
    }
  }

# Service account principal
  access_groups {
    id           = "scientist"
    group_id     = "scientist"
    display_name = "Data Scientist"
    principal {
      service_account = "SERVICE_ACCOUNT_EMAIL_ADDRESS"
    }
  }
}

Sostituisci quanto segue:

PROJECT_ID: l'ID del tuo progetto Google Cloud
LOCATION: la regione in cui si trova il prodotto di dati
DATA_PRODUCT_ID: un ID univoco per il prodotto di dati
DISPLAY_NAME: un nome facile da ricordare per il tuo prodotto di dati
EMAIL_IDs: indirizzi email separati da virgole dei proprietari del prodotto di dati, ad esempio ["user1@example.com", "user2@example.com"]
SERVICE_ACCOUNT_EMAIL_ADDRESS: l'indirizzo email del account di servizio

C#

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

public sealed partial class GeneratedDataProductServiceClientSnippets
{
    /// <summary>Snippet for UpdateDataProduct</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 UpdateDataProductRequestObject()
    {
        // Create client
        DataProductServiceClient dataProductServiceClient = DataProductServiceClient.Create();
        // Initialize request argument(s)
        UpdateDataProductRequest request = new UpdateDataProductRequest
        {
            DataProduct = new DataProduct(),
            UpdateMask = new FieldMask(),
            ValidateOnly = false,
        };
        // Make the request
        Operation<DataProduct, OperationMetadata> response = dataProductServiceClient.UpdateDataProduct(request);

        // Poll until the returned long-running operation is complete
        Operation<DataProduct, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        DataProduct 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<DataProduct, OperationMetadata> retrievedResponse = dataProductServiceClient.PollOnceUpdateDataProduct(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            DataProduct 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.NewDataProductClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.UpdateDataProductRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#UpdateDataProductRequest.
	}
	op, err := c.UpdateDataProduct(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.DataProduct;
import com.google.cloud.dataplex.v1.DataProductServiceClient;
import com.google.cloud.dataplex.v1.UpdateDataProductRequest;
import com.google.protobuf.FieldMask;

public class SyncUpdateDataProduct {

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

  public static void syncUpdateDataProduct() 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 (DataProductServiceClient dataProductServiceClient = DataProductServiceClient.create()) {
      UpdateDataProductRequest request =
          UpdateDataProductRequest.newBuilder()
              .setDataProduct(DataProduct.newBuilder().build())
              .setUpdateMask(FieldMask.newBuilder().build())
              .setValidateOnly(true)
              .build();
      DataProduct response = dataProductServiceClient.updateDataProductAsync(request).get();
    }
  }
}

Node.js

/**
 * 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 data product to update.
 *  The data product's `name` field is used to identify the data product to
 *  update.
 */
// const dataProduct = {}
/**
 *  Optional. The list of fields to update.
 *  If this is empty or not set, then all the fields will be updated.
 */
// const updateMask = {}
/**
 *  Optional. Validates the request without actually updating the data product.
 *  Default: false.
 */
// const validateOnly = true

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

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

async function callUpdateDataProduct() {
  // Construct request
  const request = {
    dataProduct,
  };

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

callUpdateDataProduct();

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_product():
    # Create a client
    client = dataplex_v1.DataProductServiceClient()

    # Initialize request argument(s)
    data_product = dataplex_v1.DataProduct()
    data_product.display_name = "display_name_value"
    data_product.owner_emails = ["owner_emails_value1", "owner_emails_value2"]

    request = dataplex_v1.UpdateDataProductRequest(
        data_product=data_product,
    )

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

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

    response = operation.result()

    # Handle the response
    print(response)

REST

Per configurare un gruppo di accesso per il prodotto di dati, utilizza il metodo dataProducts.patch.

Ad esempio, invia la seguente richiesta PATCH:

curl -X PATCH \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
-d '{"access_groups": ACCESS_GROUPS_MAP}' \
https://dataplex.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/dataProducts/DATA_PRODUCT_ID?update_mask="access_groups"

Sostituisci quanto segue:

ACCESS_GROUPS_MAP: un oggetto JSON che rappresenta una mappa in cui ogni chiave è un ID gruppo di accesso e il valore è un oggetto AccessGroup. Ad esempio:

{
"analyst": {
  "id": "analyst",
  "display_name": "Analyst access group",
  "description": "Access group for analysts",
  "principal":
    {
      "google_group": "analyst-team@example.com",
      "service_account": "analyst-svc@gserviceaccount.com"
    },
  "default_iam_role_config":
    {
      "role": "roles/bigquery.dataViewer"
    }
}
}

PROJECT_ID: l'ID del tuo progetto Google Cloud
LOCATION: la regione in cui si trova il prodotto di dati
DATA_PRODUCT_ID: l'ID del tuo prodotto di dati

Configura le autorizzazioni degli asset

Dopo aver configurato i gruppi di accesso, puoi configurare le autorizzazioni per gli asset nel prodotto di dati.

Se hai configurato un ruolo IAM predefinito per un gruppo di accesso, gli asset supportati ereditano automaticamente quel ruolo (indicato da un'etichetta Predefinito nella colonna Autorizzazioni). Puoi eseguire l'override del ruolo predefinito per asset specifici assegnando un ruolo diverso.

Console

Nella sezione Autorizzazioni asset, seleziona l'asset per cui vuoi configurare le autorizzazioni. Puoi selezionare e configurare le autorizzazioni per un massimo di 10 asset alla volta.
Fai clic su Configura le autorizzazioni.
Nel campo Seleziona gruppo di accesso, seleziona un gruppo di accesso.
Nel campo Assegna ruolo IAM, seleziona un ruolo IAM che vuoi assegnare al gruppo di accesso.

Ad esempio, se l'asset è una tabella BigQuery denominata Sales, se hai selezionato il gruppo di accesso Analyst e hai assegnato il ruolo BigQuery Metadata Viewer a questo gruppo di accesso, i consumer del prodotto di dati che fanno parte del gruppo di accesso Analyst hanno l'autorizzazione BigQuery Metadata Viewer sulla tabella Sales.

Puoi aggiungere più ruoli a un asset.
Fai clic su Configura. La colonna Autorizzazioni nella tabella degli asset mostra le autorizzazioni assegnate e lo stato della relativa configurazione per ogni gruppo di accesso:
- Applicato: il ruolo IAM (ereditato dal ruolo predefinito del gruppo di accesso o configurato specificamente per l'asset) è attivo sulla risorsa sottostante.
- Non riuscito: l'applicazione del ruolo IAM alla risorsa sottostante non è riuscita. Puoi trovare il motivo dettagliato dell'errore in Cloud Logging.
- Non supportato: l'applicazione delle autorizzazioni non è supportata per il tipo di risorsa di questo asset.
Per configurare le autorizzazioni per altri asset, ripeti i passaggi.
Fai clic su Continua.

Terraform

Assegna i ruoli IAM ai tuoi gruppi di accesso per asset specifici utilizzando il blocco access_group_configs nella risorsa google_dataplex_data_product_data_asset.

Ad esempio, utilizza la seguente configurazione:

resource "google_dataplex_data_product_data_asset" "example_data_asset" {
project         = "PROJECT_ID"
location        = "LOCATION"
data_product_id = "DATA_PRODUCT_ID"
data_asset_id   = "DATA_ASSET_ID"
resource        = "RESOURCE_NAME"

access_group_configs {
  access_group = "analyst" # Must match the 'id' defined in google_dataplex_data_product
  iam_roles    = ["roles/bigquery.dataViewer"]
}
}

Sostituisci quanto segue:

PROJECT_ID: l'ID del tuo progetto Google Cloud
LOCATION: la regione in cui si trova il prodotto di dati
DATA_PRODUCT_ID: l'ID del prodotto di dati
DATA_ASSET_ID: un ID univoco per questo asset di dati all'interno del prodotto di dati
RESOURCE_NAME: il nome completo della risorsa dell'asset di dati (ad esempio, //bigquery.googleapis.com/projects/PROJECT_ID/datasets/DATASET_ID/tables/TABLE_ID)

C#

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

public sealed partial class GeneratedDataProductServiceClientSnippets
{
    /// <summary>Snippet for UpdateDataAsset</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 UpdateDataAssetRequestObject()
    {
        // Create client
        DataProductServiceClient dataProductServiceClient = DataProductServiceClient.Create();
        // Initialize request argument(s)
        UpdateDataAssetRequest request = new UpdateDataAssetRequest
        {
            DataAsset = new DataAsset(),
            UpdateMask = new FieldMask(),
            ValidateOnly = false,
        };
        // Make the request
        Operation<DataAsset, OperationMetadata> response = dataProductServiceClient.UpdateDataAsset(request);

        // Poll until the returned long-running operation is complete
        Operation<DataAsset, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        DataAsset 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<DataAsset, OperationMetadata> retrievedResponse = dataProductServiceClient.PollOnceUpdateDataAsset(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            DataAsset 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.NewDataProductClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.UpdateDataAssetRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#UpdateDataAssetRequest.
	}
	op, err := c.UpdateDataAsset(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.DataAsset;
import com.google.cloud.dataplex.v1.DataProductServiceClient;
import com.google.cloud.dataplex.v1.UpdateDataAssetRequest;
import com.google.protobuf.FieldMask;

public class SyncUpdateDataAsset {

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

  public static void syncUpdateDataAsset() 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 (DataProductServiceClient dataProductServiceClient = DataProductServiceClient.create()) {
      UpdateDataAssetRequest request =
          UpdateDataAssetRequest.newBuilder()
              .setDataAsset(DataAsset.newBuilder().build())
              .setUpdateMask(FieldMask.newBuilder().build())
              .setValidateOnly(true)
              .build();
      DataAsset response = dataProductServiceClient.updateDataAssetAsync(request).get();
    }
  }
}

Node.js

/**
 * 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 data asset to update.
 *  The data asset's `name` field is used to identify the data asset to update.
 */
// const dataAsset = {}
/**
 *  Optional. The list of fields to update.
 *  If this is empty or not set, then all the fields will be updated.
 */
// const updateMask = {}
/**
 *  Optional. Validates the request without actually updating the data asset.
 *  Defaults to false.
 */
// const validateOnly = true

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

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

async function callUpdateDataAsset() {
  // Construct request
  const request = {
    dataAsset,
  };

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

callUpdateDataAsset();

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_asset():
    # Create a client
    client = dataplex_v1.DataProductServiceClient()

    # Initialize request argument(s)
    data_asset = dataplex_v1.DataAsset()
    data_asset.resource = "resource_value"

    request = dataplex_v1.UpdateDataAssetRequest(
        data_asset=data_asset,
    )

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

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

    response = operation.result()

    # Handle the response
    print(response)

REST

Per configurare le autorizzazioni per gli asset nel prodotto di dati, utilizza il metodo dataAssets.patch.

Ad esempio, invia la seguente richiesta PATCH:

curl -X PATCH \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
-d '{"access_group_configs": ACCESS_GROUP_CONFIGS_MAP}' \
https://dataplex.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/dataProducts/DATA_PRODUCT_ID/dataAssets/DATA_ASSET_ID?update_mask="access_group_configs"

Sostituisci quanto segue:

ACCESS_GROUP_CONFIGS_MAP: un oggetto JSON che rappresenta una mappa in cui ogni chiave è un ID gruppo di accesso e il valore è un oggetto AccessGroupConfig. Ad esempio:
```
{
"analyst": {
  iam_roles: ["roles/bigquery.dataViewer"]
  }
}
```
PROJECT_ID: l'ID del tuo progetto Google Cloud
LOCATION: la regione in cui si trova il prodotto di dati
DATA_PRODUCT_ID: l'ID del tuo prodotto di dati
DATA_ASSET_ID: l'ID dell'asset per cui vuoi configurare le autorizzazioni

(Facoltativo) Aggiungi dettagli del contratto e dell'aspetto

Puoi aggiungere contratti e aspetti per un prodotto di dati.

Aggiungi un contratto

Per stabilire un rapporto di fiducia tra produttori e consumatori di dati, puoi allegare un contratto al tuo prodotto di dati. Specificando parametri come l'ora di aggiornamento e le soglie, fornisci ai consumer il contesto necessario per capire quando i dati vengono aggiornati e se soddisfano i loro requisiti aziendali specifici.

Console

Nel riquadro Aggiungi dettagli del contratto e dell'aspetto, fai clic su Aggiungi contratto.
Nel campo Seleziona contratto, seleziona Refresh cadence.
Nel campo Frequenza, seleziona una pianificazione concordata per la frequenza con cui i dati vengono aggiornati o inviati, garantendo un flusso prevedibile dal producer di dati al consumer di dati. Ad esempio, Weekly.
Nel campo Tempo di aggiornamento, inserisci un tempo massimo accettabile per l'aggiornamento dei dati nell'origine e per la loro disponibilità per il consumer. Ad esempio, 23:00 PST.
Nel campo Soglia (in minuti), inserisci un limite misurabile in minuti per il ritardo accettabile nella pubblicazione dei dati. Ad esempio, inserisci 30 per impostare una soglia di 30 minuti.
(Facoltativo) Nel campo Pianificazione cron, inserisci un'espressione cron che definisce la pianificazione per la generazione e la pubblicazione dei dati nel formato: MINUTE HOUR DAY_OF_MONTH MONTH DAY_OF_WEEK

Di seguito sono riportati i valori accettati:
- MINUTE: 0-59
- HOUR: 0-23
- DAY_OF_MONTH: 1-31
- MONTH: 1-31 o JAN-DEC
- DAY_OF_WEEK: 0-6 o SUN-SAT
Ad esempio, 0 8 * * 1-5 viene eseguito alle 08:00 nei giorni feriali (lunedì-venerdì).
Fai clic su Salva.

REST

I contratti sono modellati come aspetti del prodotto di dati. Per aggiungere un contratto Refresh Cadence per un prodotto di dati, utilizza il metodo entries.patch.

Ad esempio, invia la seguente richiesta PATCH:

curl -X PATCH \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
-d \
'{
  "aspects": {
    "dataplex-types.global.refresh-cadence": {
      "aspectType": "projects/dataplex-types/locations/global/aspectTypes/refresh-cadence",
      "data": {
        "frequency": "REFRESH_FREQUENCY"
      }
    }
  }
}' \
"https://dataplex.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/entryGroups/@dataplex/entries/projects/DATA_PRODUCT_PROJECT_NUMBER/locations/DATA_PRODUCT_LOCATION/dataProducts/DATA_PRODUCT_ID?updateMask=aspects"

Sostituisci quanto segue:

REFRESH_FREQUENCY: la pianificazione concordata per la frequenza con cui i dati vengono aggiornati o forniti, garantendo un flusso prevedibile dal producer di dati al consumer di dati. Ad esempio: Weekly
PROJECT_ID: l'ID del progetto Google Cloud in cui viene effettuata la chiamata API
LOCATION: la regione dell'endpoint di servizio di Knowledge Catalog che stai chiamando (ad esempio us-central1)
DATA_PRODUCT_PROJECT_NUMBER: il numero di progetto in cui si trova la risorsa del prodotto di dati
DATA_PRODUCT_LOCATION: la località della risorsa del prodotto di dati
DATA_PRODUCT_ID: l'ID del tuo prodotto di dati

Terraform

I contratti sono modellati come aspetti del prodotto di dati. Per gestire un contratto, devi gestire la voce Knowledge Catalog sottostante. Poiché Terraform non rileva automaticamente gli aspetti esistenti, devi prima importare google_dataplex_entry.

Per importare la voce, utilizza il seguente comando:

terraform import google_dataplex_entry.data_product_metadata "projects/DATA_PRODUCT_PROJECT_NUMBER/locations/LOCATION/entryGroups/@dataplex/entries/projects/DATA_PRODUCT_PROJECT_NUMBER/locations/LOCATION/dataProducts/DATA_PRODUCT_ID"

Configurazione di Terraform:

resource "google_dataplex_entry" "data_product_metadata" {
project        = "DATA_PRODUCT_PROJECT_NUMBER"
location       = "LOCATION"
entry_group_id = "@dataplex"
entry_id       = "projects/DATA_PRODUCT_PROJECT_NUMBER/locations/LOCATION/dataProducts/DATA_PRODUCT_ID"
entry_type     = "projects/655216118709/locations/global/entryTypes/data-product"

aspects {
  aspect_key = "655216118709.global.refresh-cadence"
  aspect {
    data = jsonencode({
      frequency = "REFRESH_FREQUENCY"
    })
  }
}
}

Sostituisci quanto segue:

DATA_PRODUCT_PROJECT_NUMBER: il numero di progetto in cui si trova la risorsa del prodotto di dati
LOCATION: la regione dell'endpoint di servizio di Knowledge Catalog che stai chiamando (ad esempio us-central1)
DATA_PRODUCT_ID: l'ID del tuo prodotto di dati
REFRESH_FREQUENCY: la pianificazione concordata per la frequenza con cui i dati vengono aggiornati o forniti, garantendo un flusso prevedibile dal producer di dati al consumer di dati. Ad esempio: Weekly

Per informazioni generali sul processo di importazione, consulta la documentazione sull'importazione di Terraform.

Aggiungi aspetti

Utilizza gli aspetti per arricchire il tuo prodotto di dati con metadati strutturati e riutilizzabili. Questi modelli forniscono un modo standardizzato per i produttori di dati di comunicare la qualità e l'idoneità di un prodotto di dati, migliorando la governance e aiutando i consumatori a determinare se il prodotto soddisfa le loro esigenze aziendali.

Per aggiungere aspetti per il prodotto di dati, segui questi passaggi:

Console

Nel riquadro Aggiungi dettagli del contratto e dell'aspetto, fai clic su + Aggiungi aspetto.
Nel campo Seleziona tipo di aspetto, cerca e seleziona un tipo di aspetto dall'elenco. Ad esempio, Geo context.
Fai clic su Salva.

REST

Per aggiungere aspetti per un prodotto di dati, utilizza il metodo entries.patch.

Ad esempio, invia la seguente richiesta PATCH:

curl -X PATCH \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
-d \
'{
  "aspects": {
    "ASPECT_PROJECT_ID.ASPECT_LOCATION.ASPECT_NAME": {
      "aspectType": "projects/ASPECT_PROJECT_ID/locations/ASPECT_LOCATION/aspectTypes/ASPECT_NAME",
      "data": {}
    }
  }
}' \
"https://dataplex.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/entryGroups/@dataplex/entries/projects/DATA_PRODUCT_PROJECT_NUMBER/locations/DATA_PRODUCT_LOCATION/dataProducts/DATA_PRODUCT_ID?updateMask=aspects"

Sostituisci quanto segue:

ASPECT_PROJECT_ID: l'ID del tuo progetto Google Cloudin cui viene creato l'aspetto
ASPECT_LOCATION: la regione dell'endpoint del servizio Knowledge Catalog in cui viene creato l'aspetto (ad esempio, us-central1)
ASPECT_NAME: il nome dell'aspetto che vuoi collegare al prodotto di dati
PROJECT_ID: l'ID del progetto Google Cloud in cui viene effettuata la chiamata API
LOCATION: la regione dell'endpoint di servizio di Knowledge Catalog che stai chiamando (ad esempio us-central1)
DATA_PRODUCT_PROJECT_NUMBER: il numero di progetto in cui si trova la risorsa del prodotto di dati
DATA_PRODUCT_LOCATION: la località della risorsa del prodotto di dati
DATA_PRODUCT_ID: l'ID del tuo prodotto di dati

Terraform

Per gestire gli aspetti, devi gestire la voce di Knowledge Catalog sottostante. Poiché Terraform non rileva automaticamente gli aspetti esistenti, devi prima importare google_dataplex_entry.

Per importare la voce, utilizza il seguente comando:

terraform import google_dataplex_entry.data_product_metadata "projects/DATA_PRODUCT_PROJECT_NUMBER/locations/LOCATION/entryGroups/@dataplex/entries/projects/DATA_PRODUCT_PROJECT_NUMBER/locations/LOCATION/dataProducts/DATA_PRODUCT_ID"

Configurazione di Terraform:

resource "google_dataplex_entry" "data_product_metadata" {
project        = "DATA_PRODUCT_PROJECT_NUMBER"
location       = "LOCATION"
entry_group_id = "@dataplex"
entry_id       = "projects/DATA_PRODUCT_PROJECT_NUMBER/locations/LOCATION/dataProducts/DATA_PRODUCT_ID"
entry_type     = "projects/655216118709/locations/global/entryTypes/data-product"

aspects {
  aspect_key = "ASPECT_PROJECT_NUMBER.ASPECT_LOCATION.ASPECT_NAME"
  aspect {
    data = {}
  }
}
}

Sostituisci quanto segue:

DATA_PRODUCT_PROJECT_NUMBER: il numero di progetto in cui si trova la risorsa del prodotto di dati
LOCATION: la regione dell'endpoint di servizio di Knowledge Catalog che stai chiamando (ad esempio us-central1)
DATA_PRODUCT_ID: l'ID del tuo prodotto di dati
ASPECT_PROJECT_NUMBER: il numero di progetto Google Cloud in cui viene creato l'aspetto
ASPECT_LOCATION: la regione dell'endpoint del servizio Knowledge Catalog in cui viene creato l'aspetto (ad esempio, us-central1)
ASPECT_NAME: il nome dell'aspetto che vuoi collegare al prodotto di dati

Per informazioni generali sul processo di importazione, consulta la documentazione sull'importazione di Terraform.

(Facoltativo) Aggiungi ulteriori dettagli

Puoi aggiungere documentazione e query di esempio per il tuo prodotto di dati per fornire contesto essenziale, descrizioni della logica di business e guide dell'utente. In Knowledge Catalog, la documentazione viene gestita tramite l'aspetto di sistema overview.

Puoi creare questa documentazione manualmente o utilizzare gli insight sui dati di Knowledge Catalog per generarla automaticamente.

Aggiungi manualmente documentazione e query di esempio

Console

Per aggiungere la documentazione per il tuo prodotto di dati, segui questi passaggi:

Nel riquadro Aggiungi ulteriori dettagli, fai clic su Modifica accanto a Documentazione.
Digita i contenuti nell'editor di testo RTF.
Fai clic su Salva.

Per aggiungere query di esempio per il tuo prodotto di dati, segui questi passaggi:

Nel riquadro Aggiungi ulteriori dettagli, fai clic su Aggiungi query nella sezione Query consigliata.
Digita le query di esempio.
Fai clic su Salva.

Il prodotto di dati appena creato viene visualizzato nella pagina Prodotti di dati di Knowledge Catalog.

REST

La documentazione è modellata come aspetti del prodotto di dati. Per aggiungere la documentazione, utilizza il metodo entries.patch.

Ad esempio, invia la seguente richiesta PATCH:

curl -X PATCH \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
-d \
'{
  "aspects": {
    "dataplex-types.global.overview": {
      "aspectType": "projects/dataplex-types/locations/global/aspectTypes/overview",
      "data": {
        "content": "DOCUMENTATION"
      }
    }
  }
}' \
"https://dataplex.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/entryGroups/@dataplex/entries/projects/DATA_PRODUCT_PROJECT_NUMBER/locations/DATA_PRODUCT_LOCATION/dataProducts/DATA_PRODUCT_ID?updateMask=aspects"

Sostituisci quanto segue:

PROJECT_ID: l'ID del progetto Google Cloud in cui viene effettuata la chiamata API
LOCATION: la regione dell'endpoint di servizio di Knowledge Catalog che stai chiamando (ad esempio us-central1)
DATA_PRODUCT_PROJECT_NUMBER: il numero di progetto in cui si trova la risorsa del prodotto di dati
DATA_PRODUCT_LOCATION: la località della risorsa del prodotto di dati
DATA_PRODUCT_ID: l'ID del tuo prodotto di dati
DOCUMENTATION: i contenuti che vuoi collegare al prodotto di dati

Terraform

La documentazione è modellata come aspetti del prodotto di dati. Per gestire la documentazione, devi gestire la voce di Knowledge Catalog sottostante. Poiché Terraform non rileva automaticamente gli aspetti esistenti, devi prima importare google_dataplex_entry.

Per importare la voce, utilizza il seguente comando:

terraform import google_dataplex_entry.data_product_metadata "projects/DATA_PRODUCT_PROJECT_NUMBER/locations/LOCATION/entryGroups/@dataplex/entries/projects/DATA_PRODUCT_PROJECT_NUMBER/locations/LOCATION/dataProducts/DATA_PRODUCT_ID"

Configurazione di Terraform:

resource "google_dataplex_entry" "data_product_metadata" {
project        = "DATA_PRODUCT_PROJECT_NUMBER"
location       = "LOCATION"
entry_group_id = "@dataplex"
entry_id       = "projects/DATA_PRODUCT_PROJECT_NUMBER/locations/LOCATION/dataProducts/DATA_PRODUCT_ID"
entry_type     = "projects/655216118709/locations/global/entryTypes/data-product"

aspects {
  aspect_key = "655216118709.global.overview"
  aspect {
    data = jsonencode({
      content = "DOCUMENTATION"
    })
  }
}
}

Sostituisci quanto segue:

DATA_PRODUCT_PROJECT_NUMBER: il numero di progetto in cui si trova la risorsa del prodotto di dati
LOCATION: la regione dell'endpoint di servizio di Knowledge Catalog che stai chiamando (ad esempio us-central1)
DATA_PRODUCT_ID: l'ID del tuo prodotto di dati
DOCUMENTATION: i contenuti che vuoi collegare al prodotto di dati

Per informazioni generali sul processo di importazione, consulta la documentazione sull'importazione di Terraform.

Genera documentazione automatizzata e query di esempio utilizzando gli insight sui dati

Prima di generare la documentazione e le query di esempio utilizzando Gemini, completa i seguenti prerequisiti:

Abilita l'API Gemini for Google Cloud nel progetto in cui crei il prodotto di dati.
Concedi ruoli utente specifici per gli insight: chiedi all'amministratore di concedere alla tua identità i seguenti ruoli e autorizzazioni nel progetto del prodotto di dati:
- Genera e gestisci insight sui dati: Dataplex DataScan Editor (roles/dataplex.dataScanEditor) o Dataplex DataScan Administrator (roles/dataplex.dataScanAdmin) nel progetto in cui si trova il prodotto dati
- Visualizza gli insight generati: Dataplex DataScan DataViewer (roles/dataplex.dataScanDataViewer) sul progetto in cui si trova il prodotto di dati
Configura le autorizzazioni dell'agente di servizio tra progetti. Se gli asset di dati sottostanti si trovano in un progetto Google Cloud diverso dal progetto del prodotto di dati, devi concedere all'agente di servizio Knowledge Catalog (P4SA) l'accesso a questi asset:
1. Per generare o recuperare l'identificatore dell'agente di servizio per il progetto del prodotto di dati, esegui questo comando di Google Cloud CLI:
```
gcloud beta services identity create --service=dataplex.googleapis.com --project=DATA_PRODUCT_PROJECT_ID
```
  Sostituisci DATA_PRODUCT_PROJECT_ID con l'ID progettoGoogle Cloud in cui si trova il prodotto di dati.
2. In ogni progetto esterno in cui si trovano i tuoi asset, concedi all'agente di servizio del progetto del prodotto di dati i seguenti ruoli:
  - BigQuery Data Editor (roles/bigquery.dataEditor) sulle tabelle e sui set di dati sottostanti
  - BigQuery Studio Admin (roles/bigquery.studioAdmin) sul progetto asset

Per generare documentazione e query di esempio per il tuo prodotto di dati utilizzando gli insight sui dati, segui questi passaggi:

Nel riquadro Aggiungi ulteriori dettagli, nella barra Genera insight con Gemini, fai clic su Genera.

Attendi qualche minuto per il completamento del processo di generazione degli insight.
Per esaminare i contenuti generati, fai clic su Visualizza.
Valuta i contenuti generati:
- Se i contenuti sono corretti, fai clic su Salva. In questo modo, l'editor di testo RTF viene compilato con un modello di documentazione predefinito e vengono aggiunte query di esempio alla sezione Insight.
- Se i contenuti non soddisfano le aspettative, fai clic su Ignora.
Fai clic su Salva per finalizzare.

Passaggi successivi

Scopri di più sulla gestione dei prodotti di dati.
Scopri come cercare prodotti di dati.
In qualità di consumer di dati, scopri come richiedere l'accesso ai prodotti di dati.

Creare prodotti di dati Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Prima di iniziare

Abilita Gemini

Abilita API

Crea asset di dati

Configura le identità

(Facoltativo) Configura Looker (Google Cloud core) per i prodotti di dati

Ruoli obbligatori

Ruoli obbligatori per i proprietari dei prodotti di dati

Autorizzazioni obbligatorie

Ruoli richiesti per i consumer di prodotti di dati

Crea e configura un prodotto di dati

Crea un prodotto di dati

Console

Terraform

C#

C#

Vai

Go

Java

Java

Node.js

Node.js

Python

Python

REST

(Facoltativo) Aggiungi asset

Console

Terraform

C#

C#

Vai

Go

Java

Java

Node.js

Node.js

Python

Python

REST

(Facoltativo) Configura i gruppi di accesso e le autorizzazioni per gli asset

Configura gruppi di accesso

Console

Terraform

C#

C#

Vai

Go

Java

Java

Node.js

Node.js

Python

Python

REST

Configura le autorizzazioni degli asset

Console

Terraform

C#

C#

Vai

Go

Java

Java

Node.js

Node.js

Python

Python

REST

(Facoltativo) Aggiungi dettagli del contratto e dell'aspetto

Aggiungi un contratto

Console

REST

Terraform

Aggiungi aspetti

Console

REST

Terraform

(Facoltativo) Aggiungi ulteriori dettagli

Aggiungi manualmente documentazione e query di esempio

Creare prodotti di dati