A partir de 10 de abril de 2026, o Dataplex Universal Catalog será chamado de Knowledge Catalog. Os nomes da API, da biblioteca de cliente, da CLI e do IAM permanecem inalterados. Para mais informações, consulte Apresentação do Knowledge Catalog do Google Cloud.

Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Criar produtos de dados

Este documento é destinado a proprietários de produtos de dados que querem criar e configurar produtos de dados no Knowledge Catalog (antigo Dataplex Universal Catalog).

Para mais informações sobre a arquitetura e os conceitos principais dos produtos de dados, consulte Sobre produtos de dados.

Antes de começar

Antes de criar produtos de dados, atenda aos seguintes pré-requisitos.

Ativar o Gemini

Configurar o Gemini no seu recurso de dados é uma etapa opcional, mas altamente recomendada, antes de criar seu primeiro produto de dados.

Por padrão, a criação de um produto de dados exige que você insira manualmente descrições comerciais, definições técnicas e documentação de integração para seus recursos. Quando você ativa a integração do Gemini, o Knowledge Catalog usa a assistência de IA para analisar automaticamente seus esquemas e resultados da verificação de dados e gerar o seguinte:

Documentação comercial:gera modelos de documentação e descrições claras para seu produto de dados e os recursos de dados individuais.
Insights e exemplos de consultas:cria exemplos de consultas prontos para uso com base no layout do esquema do recurso, permitindo que os consumidores de dados comecem a consultar o produto imediatamente após a aprovação.

Se você não quiser ativar o Gemini, pule esta seção. No entanto, é necessário fornecer manualmente todos os metadados de recursos e modelos de consulta durante a criação.

Para mais informações sobre como ativar o Gemini no BigQuery, consulte Configurar o Gemini no BigQuery.

Ativar APIs

Ative as APIs Dataplex e BigQuery.

Funções necessárias para ativar APIs

Para ativar as APIs, é necessário ter o papel do IAM de administrador de uso do serviço (roles/serviceusage.serviceUsageAdmin), que contém a permissão serviceusage.services.enable. Saiba como conceder papéis.

Ativar as APIs

Criar recursos de dados

Verifique se os recursos de dados (por exemplo, conjuntos de dados, tabelas e visualizações do BigQuery) foram criados e preenchidos.

Para mais informações sobre como criar recursos de dados, consulte os documentos a seguir:

Configurar identidades

Identifique ou crie os Grupos do Google ou as contas de serviço que você quer configurar no seu produto de dados.

Funções exigidas

Esta seção descreve os papéis mínimos do IAM necessários para as seguintes seções principais:

Proprietários de produtos de dados: usuários que criam, configuram e gerenciam produtos de dados e os recursos associados a eles
Consumidores de produtos de dados: usuários que pesquisam, visualizam e solicitam acesso a produtos de dados publicados.

Funções necessárias para proprietários de produtos de dados

Para ter as permissões necessárias para criar e gerenciar produtos de dados, peça ao administrador para conceder a você os seguintes papéis do IAM no projeto:

Permissões completas para criar, atualizar, excluir, gerenciar permissões e aprovar ou rejeitar solicitações de acesso a produtos de dados: Administrador de produtos de dados do Dataplex (roles/dataplex.dataProductsAdmin)
Atualizar e gerenciar permissões, além de aprovar ou rejeitar solicitações de acesso a produtos de dados: Editor de produtos de dados do Dataplex (roles/dataplex.dataProductsEditor)
Adicione aspectos de metadados (como schema, overview, contacts e queries): Proprietário de entradas e links de entradas do Dataplex (roles/dataplex.entryOwner)
Pesquisar e adicionar recursos: Leitor do Dataplex Catalog (roles/dataplex.catalogViewer)
Editar tipos de aspectos do sistema (como overview, contact, contract e queries): Editor do catálogo do Dataplex (roles/dataplex.catalogEditor)
Crie ou recupere verificações de dados de insights para documentação automatizada e geração de insights: Administrador do DataScan Dataplex (roles/dataplex.dataScanAdmin)

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esses papéis predefinidos contêm as permissões necessárias para criar e gerenciar produtos de dados. Para acessar as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As seguintes permissões são necessárias para criar e gerenciar produtos de dados:

Crie um produto de dados: dataplex.dataProducts.create
Listar produtos de dados em um projeto: dataplex.dataProducts.list
Receber ou ver um produto de dados: dataplex.dataProducts.get
Para editar um produto de dados: dataplex.dataProducts.update
Excluir produto de dados: dataplex.dataProducts.delete
Aprovar solicitação de acesso ao produto de dados: dataplex.dataProducts.approve
Pesquise um produto de dados usando o Knowledge Catalog:
- dataplex.dataProducts.get
- dataplex.projects.search
Crie uma solicitação de acesso ao produto de dados: dataplex.dataProducts.get
Crie um recurso de dados: dataplex.dataAssets.create
Listar recursos de dados em um produto de dados: dataplex.dataAssets.list
Acessar recurso de dados: dataplex.dataAssets.get
Para editar um recurso de dados: dataplex.dataAssets.update
Excluir recurso de dados: dataplex.dataAssets.delete
Crie uma verificação de dados: dataplex.datascans.create
Listar todas as verificações de dados: dataplex.datascans.list
Receber uma verificação de dados: dataplex.datascans.get
Execute uma verificação de dados: dataplex.datascans.run
Edite o tipo de aspecto do sistema overview: dataplex.entryGroups.useOverviewAspect
Edite o tipo de aspecto do sistema refresh cadence: dataplex.entryGroups.useRefreshCadenceAspect
Edite o tipo de aspecto do sistema queries: dataplex.entryGroups.useQueriesAspect

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

Papéis necessários para consumidores de produtos de dados

Para que os consumidores de produtos de dados possam pesquisar, visualizar e solicitar acesso a produtos de dados, como proprietário de um produto de dados, você precisa garantir que ele seja detectável. Para isso, conceda aos consumidores do produto de dados os seguintes papéis do IAM no produto de dados:

Pesquisar produtos de dados e solicitar acesso a eles: Consumidor de produtos de dados do Dataplex (dataplex.dataProductsConsumer) e Leitor do catálogo do Dataplex (roles/dataplex.catalogViewer)
Acesso somente leitura para visualizar definições e metadados de produtos de dados: Leitor de produtos de dados do Dataplex (dataplex.dataProductsViewer)

Criar e configurar um produto de dados

A criação de um produto de dados envolve as seguintes tarefas de alto nível:

Criar um produto de dados

Essa etapa inicial obrigatória exige a definição de detalhes principais, como um nome e uma descrição exclusivos do produto de dados, a região em que ele é criado e os detalhes de contato.
Opcional: adicione recursos

Nesta fase, você seleciona os recursos que serão incluídos no produto de dados. Uma restrição importante é que os recursos precisam estar na mesma região que o produto de dados em si. É possível adicionar até 10 recursos de cada vez, com um máximo total de 50 recursos por produto de dados.

Para ver a lista de recursos compatíveis, consulte Recursos compatíveis.
Opcional: configurar grupos de acesso e permissões de recursos

Nesta fase opcional, você simplifica o controle de acesso criando grupos de acesso. Esses grupos de acesso funcionam como aliases fáceis de usar (por exemplo, Analyst ou Reader) para os Grupos do Google e contas de serviço subjacentes. Em seguida, atribua permissões selecionando um papel específico do IAM e mapeando-o para um grupo de acesso de um recurso específico.
Opcional: adicionar detalhes do contrato e do aspecto

Nesta fase, você melhora a governança e a capacidade de descoberta de dados anexando frameworks de metadados. Você pode adicionar um contrato para comunicar formalmente a cadência de atualização dos dados, especificando parâmetros como frequência, tempo e limites de variância. Também é possível anexar aspectos personalizados para fornecer mais metadados comerciais ou técnicos ao produto de dados.
Opcional: adicione mais detalhes

Nesta fase final, você adiciona documentação rich text, como guias de integração de usuários, definições comerciais e exemplos de consultas, para ajudar os consumidores a interagir com o produto de dados imediatamente após a aprovação.

Para criar e configurar um produto de dados, siga as etapas nas seções abaixo:

Criar um produto de dados

Console

No console Google Cloud , acesse a página Produtos de dados do Knowledge Catalog.

Acessar Produtos de dados
Clique em Criar.
No painel Criar produtos de dados, insira os seguintes detalhes:
- Nome do produto de dados: insira um nome exclusivo para seu produto de dados.
- ID do produto de dados: é um identificador exclusivo gerado automaticamente. É possível editar esse campo.
- ID do projeto: um identificador exclusivo do projeto em que o produto de dados é criado. Procure e selecione o projeto.
- Região: selecione a região ou multirregião em que o produto de dados foi criado.
- Ícone do produto de dados: navegue e selecione um ícone para identificar visualmente o produto de dados. Isso é opcional.
- Descrição: insira uma breve descrição do produto de dados.
- Contatos: informe os dados de contato para governança e fluxos de trabalho de aprovação:
  - Endereço de e-mail do(s) proprietário(s) do produto de dados: insira o endereço de e-mail dos proprietários do produto de dados.
  - Endereço de e-mail do(s) aprovador(es) do produto de dados:insira o endereço de e-mail dos aprovadores designados responsáveis por assinar solicitações ou modificações de acesso.
- Rótulos: adicione rótulos de chave-valor para organizar seus recursos. Isso é opcional.
Clique em Criar produto de dados.

Terraform

Para criar um produto de dados, use o recurso google_dataplex_data_product.

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

provider = google-beta
}

Substitua:

PROJECT_ID: ID do projeto Google Cloud
LOCATION: a região em que você quer criar o produto de dados
DATA_PRODUCT_ID: um ID exclusivo para seu produto de dados
DISPLAY_NAME: um nome fácil de usar para seu produto de dados
DESCRIPTION: uma breve descrição do produto de dados
EMAIL_IDs: endereços de e-mail separados por vírgulas dos proprietários do produto de dados, por exemplo, ["user1@example.com", "user2@example.com"]

C#

Antes de testar esta amostra, siga as instruções de configuração do C# no Guia de início rápido do Knowledge Catalog: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Knowledge Catalog C#.

Para autenticar no Knowledge Catalog, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Go

Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido do Knowledge Catalog: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Knowledge Catalog Go.

Para autenticar no Knowledge Catalog, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.


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

Antes de testar esta amostra, siga as instruções de configuração do Java no Guia de início rápido do Knowledge Catalog: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Knowledge Catalog Java.

Para autenticar no Knowledge Catalog, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Antes de testar esta amostra, siga as instruções de configuração do Node.js no Guia de início rápido do Knowledge Catalog: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Knowledge Catalog Node.js.

Para autenticar no Knowledge Catalog, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do Knowledge Catalog: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Knowledge Catalog Python.

Para autenticar no Knowledge Catalog, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

# 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

Para criar um produto de dados, use o método dataProducts.create.

Por exemplo, envie a seguinte solicitação 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

Substitua:

DISPLAY_NAME: um nome fácil de usar para seu produto de dados
EMAIL_IDs: endereços de e-mail separados por vírgulas dos proprietários de produtos de dados
APPROVER_EMAIL_IDs: endereços de e-mail separados por vírgulas dos aprovadores designados responsáveis por assinar solicitações ou modificações de acesso.
PROJECT_ID: o ID do seu projeto Google Cloud
LOCATION: a região em que você quer criar o produto de dados
DATA_PRODUCT_ID: um ID exclusivo para seu produto de dados

Opcional: adicione recursos

É possível adicionar vários recursos de dados, como tabelas, visualizações, conjuntos de dados e modelos do BigQuery, ao seu produto de dados. Para conferir a lista de recursos compatíveis, consulte Recursos compatíveis.

Console

No painel Adicionar recursos, clique em +Adicionar.
Pesquise e selecione os recursos que você quer adicionar ao produto de dados. Os recursos selecionados precisam estar na mesma região que o produto de dados.

Se você tiver as permissões necessárias, clique no recurso para ver os metadados dele.
Para refinar os resultados da pesquisa, use Filtros.
Depois de selecionar os recursos, clique em Adicionar.

Observação: é possível adicionar até 10 recursos de cada vez, com um máximo total de 50 recursos permitidos por produto de dados.
Clique em Continuar.

Terraform

Para adicionar um recurso de dados ao produto de dados, use o recurso 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"

provider = google-beta
}

Substitua:

PROJECT_ID: ID do projeto Google Cloud
LOCATION: a região em que o produto de dados existe.
DATA_PRODUCT_ID: o ID do produto de dados
DATA_ASSET_ID: um ID exclusivo para esse recurso de dados no produto de dados.
RESOURCE_NAME: o nome completo do recurso do recurso de dados (por exemplo, //bigquery.googleapis.com/projects/PROJECT_ID/datasets/DATASET_ID/tables/TABLE_ID).

C#

Para autenticar no Knowledge Catalog, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Go

Para autenticar no Knowledge Catalog, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.


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

Para autenticar no Knowledge Catalog, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no Knowledge Catalog, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no Knowledge Catalog, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

# 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

Para adicionar um recurso de dados ao seu produto de dados, use o método dataAssets.create.

Por exemplo, envie a seguinte solicitação 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

Substitua:

RESOURCE_NAME: o nome completo do recurso do recurso de dados (por exemplo, //bigquery.googleapis.com/projects/PROJECT_ID/datasets/DATASET_ID/tables/TABLE_ID).
PROJECT_ID: ID do projeto Google Cloud
LOCATION: a região em que o produto de dados existe.
DATA_PRODUCT_ID: o ID do produto de dados
DATA_ASSET_ID: um ID exclusivo para esse recurso de dados no produto de dados.

Opcional: configurar grupos de acesso e permissões de recursos

No painel Configurar grupos de acesso e permissões de recursos, é possível criar grupos de acesso e atribuir permissões aos recursos.

Configurar grupos de acesso

Console

Clique em Adicionar grupo de acesso.
No campo Nome do grupo de acesso, digite um nome para o grupo. Por exemplo, Analyst.
No campo Descrição do grupo de acesso, insira uma descrição para o grupo de acesso.
No campo Identificador do grupo de acesso, insira o endereço de e-mail de um grupo do Google que você quer atribuir a esse grupo de acesso.

Os consumidores de produtos de dados que solicitarem acesso para si mesmos serão adicionados como membros ao Grupo do Google mapeado.

Para mais informações sobre como criar Grupos do Google, consulte Criar e gerenciar Grupos do Google no Google Cloud console.
No campo Conta de serviço do grupo de acesso, insira o endereço de e-mail de uma conta de serviço que você quer atribuir a esse grupo de acesso.

Os consumidores de produtos de dados que solicitam acesso para as contas de serviço deles recebem o papel do IAM de criador de tokens da conta de serviço (roles/iam.serviceAccountTokenCreator) para representar a conta de serviço do produtor de dados mapeada para o grupo de acesso.

Para mais informações sobre como criar contas de serviço, consulte Criar contas de serviço.
Clique em Concluído.
Para adicionar outro grupo de acesso, clique em Adicionar grupo de acesso e repita as etapas.

É possível adicionar no máximo três grupos de acesso por produto de dados.
Clique em Salvar.

Terraform

Para definir grupos de acesso ao produto de dados, use o bloco aninhado access_groups no recurso google_dataplex_data_product.

Por exemplo, use a seguinte configuração:

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

provider = google-beta
}

Substitua:

PROJECT_ID: ID do projeto Google Cloud
LOCATION: a região em que o produto de dados está localizado
DATA_PRODUCT_ID: um ID exclusivo para o produto de dados.
DISPLAY_NAME: um nome fácil de usar para seu produto de dados
EMAIL_IDs: endereços de e-mail separados por vírgulas dos proprietários do produto de dados, por exemplo, ["user1@example.com", "user2@example.com"]

C#

Para autenticar no Knowledge Catalog, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Go

Para autenticar no Knowledge Catalog, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.


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

Para autenticar no Knowledge Catalog, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no Knowledge Catalog, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no Knowledge Catalog, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

# 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

Para configurar um grupo de acesso ao produto de dados, use o método dataProducts.patch.

Por exemplo, envie a seguinte solicitação 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"

Substitua:

ACCESS_GROUPS_MAP: um objeto JSON que representa um mapa em que cada chave é um ID de grupo de acesso e o valor é um objeto AccessGroup. Exemplo:

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

PROJECT_ID: o ID do seu projeto Google Cloud
LOCATION: a região em que o produto de dados existe.
DATA_PRODUCT_ID: o ID do seu produto de dados

Configurar permissões de recursos

Depois de configurar os grupos de acesso, você pode configurar as permissões para os recursos no produto de dados.

Console

Na seção Permissões de recursos, selecione o recurso para o qual você quer configurar permissões. É possível selecionar e configurar permissões para até 10 recursos de cada vez.
Clique em Configurar permissões.
No campo Selecionar grupo de acesso, escolha um grupo.
No campo Atribuir papel do IAM, selecione um papel do IAM que você quer atribuir ao grupo de acesso.

Por exemplo, se o recurso for uma tabela do BigQuery chamada Sales, e se você tiver selecionado o grupo de acesso Analyst e atribuído a função BigQuery Metadata Viewer a esse grupo, os consumidores de produtos de dados que fazem parte do grupo de acesso Analyst terão permissão BigQuery Metadata Viewer na tabela Sales.

É possível adicionar várias funções a um recurso.
Clique em Configurar. O recurso agora mostra as permissões atribuídas.
Para configurar permissões para outros recursos, repita as etapas.
Clique em Continuar.

Terraform

Atribua papéis do IAM aos seus grupos de acesso para recursos específicos usando o bloco access_group_configs no recurso google_dataplex_data_product_data_asset.

Por exemplo, use a seguinte configuração:

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

provider = google-beta
}

Substitua:

PROJECT_ID: ID do projeto Google Cloud
LOCATION: a região em que o produto de dados existe.
DATA_PRODUCT_ID: o ID do produto de dados
DATA_ASSET_ID: um ID exclusivo para esse recurso de dados no produto de dados.
RESOURCE_NAME: o nome completo do recurso do recurso de dados (por exemplo, //bigquery.googleapis.com/projects/PROJECT_ID/datasets/DATASET_ID/tables/TABLE_ID).

C#

Para autenticar no Knowledge Catalog, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Go

Para autenticar no Knowledge Catalog, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.


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

Para autenticar no Knowledge Catalog, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no Knowledge Catalog, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

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

Para autenticar no Knowledge Catalog, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

# 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

Para configurar permissões para os recursos no produto de dados, use o método dataAssets.patch.

Por exemplo, envie a seguinte solicitação 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"

Substitua:

ACCESS_GROUP_CONFIGS_MAP: um objeto JSON que representa um mapa em que cada chave é um ID de grupo de acesso e o valor é um objeto AccessGroupConfig. Exemplo:
```
{
"analyst": {
  iam_roles: ["roles/bigquery.dataViewer"]
  }
}
```
PROJECT_ID: o ID do seu projeto Google Cloud
LOCATION: a região em que o produto de dados existe.
DATA_PRODUCT_ID: o ID do seu produto de dados
DATA_ASSET_ID: o ID do recurso para o qual você quer configurar permissões.

Opcional: adicione detalhes do contrato e do aspecto

É possível adicionar contratos e aspectos a um produto de dados.

Adicionar um contrato

Para estabelecer uma base de confiança entre produtores e consumidores de dados, você pode anexar um contrato ao seu produto de dados. Ao especificar parâmetros como tempo de atualização e limites, você fornece aos consumidores o contexto necessário para entender quando os dados são atualizados e se atendem aos requisitos comerciais específicos.

Console

No painel Adicionar detalhes do contrato e do aspecto, clique em Adicionar contrato.
No campo Selecionar contrato, escolha Refresh cadence.
No campo Frequência, selecione uma programação acordada para a frequência com que os dados são atualizados ou entregues, garantindo um fluxo previsível do produtor ao consumidor de dados. Por exemplo, Weekly.
No campo Tempo de atualização, digite um tempo máximo aceitável entre a atualização dos dados na origem e a disponibilização para o consumidor. Por exemplo, 23:00 PST.
No campo Limite (em minutos), insira um limite mensurável em minutos para o atraso aceitável na entrega de dados. Por exemplo, insira 30 para definir um limite de 30 minutos.
Opcional: no campo Programação do cron, insira uma expressão cron que defina a programação para geração e entrega de dados no formato: MINUTE HOUR DAY_OF_MONTH MONTH DAY_OF_WEEK

Confira a seguir os valores aceitos:
- MINUTE: 0-59
- HOUR: 0-23
- DAY_OF_MONTH: 1-31
- MONTH: 1-31 ou JAN-DEC.
- DAY_OF_WEEK: 0-6 ou SUN-SAT.
Por exemplo, 0 8 * * 1-5 é executado às 8h nos dias úteis (de segunda a sexta-feira).
Clique em Salvar.

REST

Os contratos são modelados como aspectos no produto de dados. Para adicionar um contrato de Refresh Cadence a um produto de dados, use o método entries.patch.

Por exemplo, envie a seguinte solicitação 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"

Substitua:

REFRESH_FREQUENCY: o cronograma acordado de atualização ou entrega de dados, garantindo um fluxo previsível do produtor para o consumidor de dados. Por exemplo: Weekly
PROJECT_ID: o ID do seu Google Cloud projeto em que a chamada de API está sendo feita
LOCATION: a região do endpoint de serviço do Knowledge Catalog que você está chamando (por exemplo, us-central1)
DATA_PRODUCT_PROJECT_NUMBER: o número do projeto em que o recurso do produto de dados está localizado
DATA_PRODUCT_LOCATION: o local do recurso de produto de dados
DATA_PRODUCT_ID: o ID do seu produto de dados

Terraform

Os contratos são modelados como aspectos no produto de dados. Para gerenciar um contrato, é preciso gerenciar a entrada do Knowledge Catalog subjacente. Como o Terraform não descobre automaticamente os aspectos atuais, primeiro você precisa importar o google_dataplex_entry.

Para importar a entrada, use o seguinte 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"

Configuração do 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"
    })
  }
}

provider = google-beta
}

Substitua:

DATA_PRODUCT_PROJECT_NUMBER: o número do projeto em que o recurso do produto de dados está localizado
LOCATION: a região do endpoint de serviço do Knowledge Catalog que você está chamando (por exemplo, us-central1)
DATA_PRODUCT_ID: o ID do seu produto de dados
REFRESH_FREQUENCY: o cronograma acordado para a frequência com que os dados são atualizados ou entregues, garantindo um fluxo previsível do produtor ao consumidor de dados. Por exemplo: Weekly

Para informações gerais sobre o processo de importação, consulte a documentação de importação do Terraform.

Adicionar aspectos

Use aspectos para enriquecer seu produto de dados com metadados estruturados e reutilizáveis. Esses modelos oferecem uma maneira padronizada para os produtores de dados comunicarem a qualidade e a adequação de um produto de dados, melhorando a governança e ajudando os consumidores a determinar se o produto atende às necessidades comerciais deles.

Para adicionar aspectos ao produto de dados, siga estas etapas:

Console

No painel Adicionar detalhes do contrato e do aspecto, clique em + Adicionar aspecto.
No campo Selecionar tipo de aspecto, pesquise e selecione um tipo de aspecto na lista. Por exemplo, Geo context.
Clique em Salvar.

REST

Para adicionar aspectos a um produto de dados, use o método entries.patch.

Por exemplo, envie a seguinte solicitação 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"

Substitua:

ASPECT_PROJECT_ID: o ID do seu projeto Google Cloud em que o aspecto é criado
ASPECT_LOCATION: a região do endpoint de serviço do Knowledge Catalog em que o aspecto é criado (por exemplo, us-central1)
ASPECT_NAME: o nome do aspecto que você quer anexar ao produto de dados
PROJECT_ID: o ID do seu Google Cloud projeto em que a chamada de API está sendo feita
LOCATION: a região do endpoint de serviço do Knowledge Catalog que você está chamando (por exemplo, us-central1)
DATA_PRODUCT_PROJECT_NUMBER: o número do projeto em que o recurso do produto de dados está localizado
DATA_PRODUCT_LOCATION: o local do recurso de produto de dados
DATA_PRODUCT_ID: o ID do seu produto de dados

Terraform

Para gerenciar aspectos, você precisa gerenciar a entrada do Knowledge Catalog. Como o Terraform não descobre automaticamente os aspectos atuais, primeiro importe o google_dataplex_entry.

Para importar a entrada, use o seguinte 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"

Configuração do 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 = {}
  }
}

provider = google-beta
}

Substitua:

DATA_PRODUCT_PROJECT_NUMBER: o número do projeto em que o recurso do produto de dados está localizado
LOCATION: a região do endpoint de serviço do Knowledge Catalog que você está chamando (por exemplo, us-central1)
DATA_PRODUCT_ID: o ID do seu produto de dados
ASPECT_PROJECT_NUMBER: o número do projeto Google Cloud em que o aspecto é criado
ASPECT_LOCATION: a região do endpoint de serviço do Knowledge Catalog em que o aspecto é criado (por exemplo, us-central1)
ASPECT_NAME: o nome do aspecto que você quer anexar ao produto de dados

Para informações gerais sobre o processo de importação, consulte a documentação de importação do Terraform.

Opcional: adicione mais detalhes

Você pode adicionar documentação e exemplos de consultas ao seu produto de dados para fornecer contexto essencial, descrições de lógica de negócios e guias do usuário. No Knowledge Catalog, a documentação é gerenciada pelo aspecto overview do sistema.

É possível criar essa documentação manualmente ou usar os insights de dados do Knowledge Catalog para gerá-la automaticamente.

Adicionar manualmente documentação e exemplos de consultas

Console

Para adicionar documentação ao seu produto de dados, siga estas etapas:

No painel Adicionar mais detalhes, clique em Editar ao lado de Documentação.
Digite o conteúdo no editor de rich text.
Clique em Salvar.

Para adicionar consultas de amostra ao seu produto de dados, siga estas etapas:

No painel Adicionar mais detalhes, clique em Adicionar consultas na seção Recomendação de consulta.
Digite as consultas de exemplo.
Clique em Salvar.

O produto de dados recém-criado aparece na página Produtos de dados do Knowledge Catalog.

REST

A documentação é modelada como aspectos no produto de dados. Para adicionar documentação, use o método entries.patch.

Por exemplo, envie a seguinte solicitação 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"

Substitua:

PROJECT_ID: o ID do seu Google Cloud projeto em que a chamada de API está sendo feita
LOCATION: a região do endpoint de serviço do Knowledge Catalog que você está chamando (por exemplo, us-central1)
DATA_PRODUCT_PROJECT_NUMBER: o número do projeto em que o recurso do produto de dados está localizado
DATA_PRODUCT_LOCATION: o local do recurso de produto de dados
DATA_PRODUCT_ID: o ID do seu produto de dados
DOCUMENTATION: o conteúdo que você quer anexar ao produto de dados

Terraform

A documentação é modelada como aspectos no produto de dados. Para gerenciar a documentação, é preciso gerenciar a entrada do Knowledge Catalog subjacente. Como o Terraform não descobre automaticamente os aspectos atuais, primeiro você precisa importar o google_dataplex_entry.

Para importar a entrada, use o seguinte 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"

Configuração do 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"
    })
  }
}

provider = google-beta
}

Substitua:

DATA_PRODUCT_PROJECT_NUMBER: o número do projeto em que o recurso do produto de dados está localizado
LOCATION: a região do endpoint de serviço do Knowledge Catalog que você está chamando (por exemplo, us-central1)
DATA_PRODUCT_ID: o ID do seu produto de dados
DOCUMENTATION: o conteúdo que você quer anexar ao produto de dados

Para informações gerais sobre o processo de importação, consulte a documentação de importação do Terraform.

Gerar documentação automatizada e consultas de exemplo usando insights de dados

Antes de gerar documentação e consultas de exemplo usando o Gemini, conclua os seguintes pré-requisitos:

Ative a API Gemini para Google Cloud no projeto em que você cria o produto de dados.
Conceda papéis de usuário específicos para insights: peça ao administrador para conceder à sua identidade os seguintes papéis e permissões no projeto do produto de dados:
- Gerar e gerenciar insights de dados: editor do DataScan Dataplex (roles/dataplex.dataScanEditor) ou administrador do DataScan Dataplex (roles/dataplex.dataScanAdmin) no projeto em que o produto de dados reside
- Ver insights gerados: Leitor de dados do DataScan Dataplex (roles/dataplex.dataScanDataViewer) no projeto em que o produto de dados está localizado
Configure permissões do agente de serviço entre projetos. Se os recursos de dados subjacentes estiverem em um projeto do Google Cloud diferente do projeto do produto de dados, conceda ao agente de serviço do catálogo do Knowledge (P4SA) acesso a esses recursos:
1. Para gerar ou recuperar o identificador do agente de serviço do projeto do produto de dados, execute o seguinte comando da Google Cloud CLI:
```
gcloud beta services identity create --service=dataplex.googleapis.com --project=DATA_PRODUCT_PROJECT_ID
```
  Substitua DATA_PRODUCT_PROJECT_ID pelo ID do projetoGoogle Cloud em que seu produto de dados está localizado.
2. Em cada projeto externo em que seus recursos estão localizados, conceda ao agente de serviço do projeto de produto de dados os seguintes papéis:
  - Editor de dados do BigQuery (roles/bigquery.dataEditor) nas tabelas e conjuntos de dados subjacentes
  - Administrador do BigQuery Studio (roles/bigquery.studioAdmin) no projeto do recurso

Para gerar documentação e consultas de amostra para seu produto de dados usando insights de dados, siga estas etapas:

No painel Adicionar mais detalhes, na barra Gerar insights com o Gemini, clique em Gerar.

Aguarde alguns minutos até que o processo de geração de insights seja concluído.
Para revisar o conteúdo gerado, clique em Visualizar.
Avalie o conteúdo gerado:
- Se o conteúdo estiver correto, clique em Salvar. Isso preenche o editor de rich text com um modelo de documentação predefinido e adiciona consultas de amostra à seção Insights.
- Se o conteúdo não atender às expectativas, clique em Descartar.
Clique em Salvar para concluir.

A seguir

Saiba mais sobre como gerenciar produtos de dados.
Saiba como pesquisar produtos de dados.
Como consumidor de dados, saiba como solicitar acesso a produtos de dados.

Criar produtos de dados Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Antes de começar

Ativar o Gemini

Ativar APIs

Criar recursos de dados

Configurar identidades

Funções exigidas

Funções necessárias para proprietários de produtos de dados

Permissões necessárias

Papéis necessários para consumidores de produtos de dados

Criar e configurar um produto de dados

Criar um produto de dados

Console

Terraform

C#

C#

Go

Go

Java

Java

Node.js

Node.js

Python

Python

REST

Opcional: adicione recursos

Console

Terraform

C#

C#

Go

Go

Java

Java

Node.js

Node.js

Python

Python

REST

Opcional: configurar grupos de acesso e permissões de recursos

Configurar grupos de acesso

Console

Terraform

C#

C#

Go

Go

Java

Java

Node.js

Node.js

Python

Python

REST

Configurar permissões de recursos

Console

Terraform

C#

C#

Go

Go

Java

Java

Node.js

Node.js

Python

Python

REST

Opcional: adicione detalhes do contrato e do aspecto

Adicionar um contrato

Console

REST

Terraform

Adicionar aspectos

Console

REST

Terraform

Opcional: adicione mais detalhes

Adicionar manualmente documentação e exemplos de consultas

Console

Criar produtos de dados