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.

O Google usa tecnologia de IA na tradução de conteúdos para seu idioma de preferência. As traduções com IA podem ter erros.

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). Ao definir esses recursos, verifique se os IDs deles seguem as diretrizes de nomenclatura de recursos do Knowledge Catalog.

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

Antes de começar

Antes de criar produtos de dados, conclua os pré-requisitos a seguir.

Ativar 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, para criar um produto de dados, é necessário inserir manualmente descrições de negócios, definições técnicas e documentação de integração para seus recursos. Ao ativar a integração com o Gemini, o Knowledge Catalog usa a assistência de IA para analisar automaticamente seus esquemas e resultados de verificação de dados para gerar o seguinte:

Documentação empresarial:gera modelos de documentação e descrições claras para seu produto de dados e os recursos de dados individuais dele.
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, você precisa 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, se ainda não estiverem ativadas.

Funções necessárias para ativar APIs

Para ativar APIs, você precisa da permissão serviceusage.services.enable. Se você criou o projeto, provavelmente já tem essa permissão pelo papel de proprietário (roles/owner). Caso contrário, é possível conseguir essa permissão pelo papel de administrador do Service Usage (roles/serviceusage.serviceUsageAdmin). 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 seguintes documentos:

Configurar identidades

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

Opcional: configurar o Looker (Google Cloud Core) para produtos de dados

Se você planeja incluir recursos do Looker (Google Cloud Core) no seu produto de dados, conclua as seguintes etapas adicionais:

Verifique se a entrada do catálogo para o recurso do Looker (Google Cloud Core) já existe no Knowledge Catalog na mesma região do produto de dados. Para mais informações, consulte Gerenciar recursos do Looker (Google Cloud Core) com o Knowledge Catalog.
Configure o OAuth do Google e ative os grupos espelhados na instância do Looker (Google Cloud Core) para criar um grupo do Looker somente leitura para seu Grupo do Google.
Atribua níveis de acesso à pasta e papéis do Looker ao grupo espelhado do Looker.

Funções exigidas

Nesta seção, descrevemos 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.

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

Para receber 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 e aprovar ou rejeitar solicitações de acesso a produtos de dados: Editor de produtos de dados do Dataplex (roles/dataplex.dataProductsEditor)
Adicionar 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 de anúncio: Leitor do Dataplex Catalog (roles/dataplex.catalogViewer)
Editar tipos de aspecto do sistema (como overview, contact, contract e queries): Editor do Catálogo do Dataplex (roles/dataplex.catalogEditor)
Criar ou recuperar verificações de dados de insights para documentação automatizada e geração de insights: Administrador do DataScan Dataplex (roles/dataplex.dataScanAdmin)
Acessar os metadados do Looker (Google Cloud Core) no Knowledge Catalog: Leitor de Esquemas do Looker (roles/looker.schemaViewer) no projeto que hospeda a instância do Looker (Google Cloud Core)
Conceda roles/looker.instanceUser ao grupo do Google do grupo de acesso: Administrador do IAM do projeto (roles/resourcemanager.projectIamAdmin) no projeto que hospeda a instância do Looker (Google Cloud Core)

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
Liste os produtos de dados em um projeto: dataplex.dataProducts.list
Acessar ou visualizar o produto de dados: dataplex.dataProducts.get
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
Criar 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
Receber recurso de dados: dataplex.dataAssets.get
Editar um recurso de dados: dataplex.dataAssets.update
Excluir recurso de dados: dataplex.dataAssets.delete
Crie uma verificação de dados: dataplex.datascans.create
Liste todas as verificações de dados: dataplex.datascans.list
Receber uma verificação de dados: dataplex.datascans.get
Executar 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 pesquisem, visualizem e solicitem acesso a produtos de dados, como proprietário de um produto de dados, você precisa garantir que ele seja detectável. Para fazer 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 Dataplex Catalog (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

Nesta etapa inicial obrigatória, é preciso definir detalhes essenciais, como um nome exclusivo para o produto de dados, uma descrição, a região em que o produto de dados é criado e detalhes de contato.
Opcional: adicionar recursos

Nessa 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. É possível adicionar até 10 recursos de cada vez, com um máximo de 50 recursos permitidos 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 atuam como aliases fáceis de usar (por exemplo, Analyst ou Reader) para os Grupos do Google e as contas de serviço. 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 facilidade de descoberta de dados anexando frameworks de metadados. É possível adicionar um contrato para comunicar formalmente sua cadência de atualização de dados, especificando parâmetros como frequência de atualização, tempo e limites de variação. Também é possível anexar aspectos personalizados para fornecer mais metadados comerciais ou técnicos para seu produto de dados.
Opcional: adicionar mais detalhes

Nesta fase final, você adiciona documentação de rich text, como guias de integração de usuários, definições de negócios e consultas de amostra, 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 do 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 o 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 é criado.
- Ícone do produto de dados: procure 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: forneça as informações do ponto de contato para fluxos de trabalho de governança e 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 aprovar 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 os recursos 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"
}

Substitua:

PROJECT_ID: o ID do seu projeto do 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"].
APPROVER_EMAIL_IDs: endereços de e-mail separados por vírgulas dos aprovadores designados responsáveis por aprovar solicitações de acesso ou modificações para esse produto de dados.
ICON_BASE64_STRING: os dados brutos da imagem codificada em base64 que representam o produto de dados. O tamanho máximo é de 3,0 MiB. Não inclua o prefixo do esquema de URL de dados.
MEMBER: o usuário, a conta de serviço ou o grupo que recebe o papel de consumidor (por exemplo, group:all-analysts@example.com).

C#

Antes de testar este exemplo, 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 este exemplo, 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 este exemplo, 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 este exemplo, 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 este exemplo, 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 do produto de dados
APPROVER_EMAIL_IDs: endereços de e-mail separados por vírgulas dos aprovadores designados responsáveis por aprovar solicitações ou modificações de acesso.
PROJECT_ID: ID do seu projeto do 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: adicionar 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 ver 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 os Filtros.
Depois de selecionar os recursos, clique em Adicionar.

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

Terraform

Para adicionar um recurso de dados ao seu 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"
}

Substitua:

PROJECT_ID: ID do projeto do Google Cloud
LOCATION: a região em que o produto de dados está localizado.
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 do Google Cloud
LOCATION: a região em que o produto de dados está localizado.
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 a recursos.

Configurar grupos de acesso

Console

Clique em Adicionar grupo de acesso.
No campo Nome do grupo de acesso, insira um nome para o grupo de acesso. 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 solicitam acesso para si mesmos sã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 console do Google Cloud .
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 às contas de serviço deles recebem o papel do IAM de Criador de token de 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.
Opcional: no campo Papel padrão, selecione um papel padrão do IAM (por exemplo, BigQuery Data Viewer) para esse grupo de acesso. Esse papel é concedido automaticamente em todos os recursos compatíveis atuais e recém-adicionados no produto de dados, a menos que você o substitua no nível do recurso.
Clique em Concluído.
Para adicionar outro grupo de acesso, clique em Adicionar grupo de acesso e repita as etapas.

É possível adicionar até três grupos de acesso por produto de dados.
Clique em Salvar.

Terraform

Para definir grupos de acesso para seu 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"
    }
  }

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

Substitua:

PROJECT_ID: ID do projeto do 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írgula dos proprietários do produto de dados, por exemplo, ["user1@example.com", "user2@example.com"].
SERVICE_ACCOUNT_EMAIL_ADDRESS: o endereço de e-mail da conta de serviço.

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 para o 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"
    },
  "default_iam_role_config":
    {
      "role": "roles/bigquery.dataViewer"
    }
}
}

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

Configurar permissões de recursos

Depois de configurar os grupos de acesso, é possível configurar as permissões para os recursos no produto de dados.

Se você configurou um papel padrão do IAM para um grupo de acesso, os recursos compatíveis herdam automaticamente esse papel (indicado por um rótulo Padrão na coluna Permissões). É possível substituir a função padrão de recursos específicos atribuindo uma função diferente.

Console

Na seção Permissões de recursos, selecione o recurso para o qual você quer configurar as 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, se você tiver selecionado o grupo de acesso Analyst e atribuído o papel BigQuery Metadata Viewer a esse grupo de acesso, 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ários papéis a um recurso.
Clique em Configurar. A coluna Permissões na tabela de recursos mostra as permissões atribuídas e o estado de configuração de cada grupo de acesso:
- Aplicado: o papel do IAM (herdado do papel padrão do grupo de acesso ou configurado especificamente para o recurso) está ativo no recurso subjacente.
- Falha: falha ao aplicar o papel do IAM ao recurso subjacente. O motivo detalhado da falha está no Cloud Logging.
- Não compatível: não é possível aplicar permissões ao tipo de recurso desse recurso.
Para configurar permissões para outros recursos, repita as etapas.
Clique em Continuar.

Terraform

Atribua papéis do IAM aos 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"]
}
}

Substitua:

PROJECT_ID: ID do projeto do Google Cloud
LOCATION: a região em que o produto de dados está localizado.
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 as permissões dos 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: ID do seu projeto do Google Cloud
LOCATION: a região em que o produto de dados está localizado.
DATA_PRODUCT_ID: o ID do produto de dados
DATA_ASSET_ID: o ID do recurso para o qual você quer configurar permissões

Opcional: adicionar 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, é possível 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 eles atendem aos requisitos de negócios 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 para o consumidor de dados. Por exemplo, Weekly.
No campo Tempo de atualização, insira um tempo máximo aceitável para que os dados sejam atualizados na origem e disponibilizados 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

Os valores aceitos são:
- 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 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: a programação acordada para a frequência com que os dados são atualizados ou entregues, garantindo um fluxo previsível do produtor para o consumidor de dados. Por exemplo: Weekly
PROJECT_ID: o ID do projeto do Google Cloud 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 do produto de dados
DATA_PRODUCT_ID: o ID do produto de dados

Terraform

Os contratos são modelados como aspectos no produto de dados. Para gerenciar um contrato, é necessário 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"
    })
  }
}
}

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 produto de dados
REFRESH_FREQUENCY: a programação acordada para a frequência com que os dados são atualizados ou entregues, garantindo um fluxo previsível do produtor para o 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 de negócios 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 projeto do 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 projeto do Google Cloud 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 do produto de dados
DATA_PRODUCT_ID: o ID do produto de dados

Terraform

Para gerenciar aspectos, é necessário gerenciar a entrada do Knowledge Catalog subjacente. Como o Terraform não descobre automaticamente os aspectos existentes, primeiro é necessário 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 = "ASPECT_PROJECT_NUMBER.ASPECT_LOCATION.ASPECT_NAME"
  aspect {
    data = {}
  }
}
}

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 produto de dados
ASPECT_PROJECT_NUMBER: o número do projeto do 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

É possível adicionar documentação e exemplos de consultas para 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 do sistema overview.

É 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 projeto do Google Cloud 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 do produto de dados
DATA_PRODUCT_ID: o ID do 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, é necessário 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"
    })
  }
}
}

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 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 amostra usando insights de dados

Antes de gerar documentação e consultas de amostra usando o Gemini, atenda aos seguintes pré-requisitos:

Ative a API Gemini para Google Cloud no projeto em que você cria o produto de dados.
Conceder papéis de usuário específicos de insights: peça ao administrador para conceder à sua identidade os seguintes papéis e permissões no projeto de 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á
Configurar permissões de 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 Knowledge Catalog (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 projeto doGoogle Cloud em que o produto de dados está.
2. Em cada projeto externo em que seus recursos estão, 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 nos 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 Ver.
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 finalizar.

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 Gemini

Ativar APIs

Criar recursos de dados

Configurar identidades

Opcional: configurar o Looker (Google Cloud Core) para produtos de dados

Funções exigidas

Papéis necessários 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: adicionar 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: adicionar 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

Criar produtos de dados