Depuis le 10 avril 2026, Dataplex Universal Catalog s'appelle désormais Knowledge Catalog. Les noms de l'API, de la bibliothèque cliente, de la CLI et d'IAM restent inchangés. Pour en savoir plus, consultez Présentation de Google Cloud Knowledge Catalog.

Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Créer des produits de données

Ce document s'adresse aux propriétaires de produits de données qui souhaitent créer et configurer des produits de données dans Knowledge Catalog (anciennement Dataplex Universal Catalog). Lorsque vous définissez ces ressources, assurez-vous que leurs ID respectent les consignes de dénomination des ressources Knowledge Catalog.

Pour en savoir plus sur l'architecture et les concepts clés des produits de données, consultez À propos des produits de données.

Avant de commencer

Avant de créer des produits de données, remplissez les conditions préalables suivantes.

Activer Gemini

La configuration de Gemini dans votre asset de données est une étape facultative, mais vivement recommandée avant de créer votre premier produit de données.

Par défaut, la création d'un produit de données nécessite de saisir manuellement les descriptions commerciales, les définitions techniques et la documentation d'intégration de vos éléments. Lorsque vous activez l'intégration de Gemini, Knowledge Catalog utilise l'assistance IA pour analyser automatiquement vos schémas et les résultats de l'analyse des données afin de générer les éléments suivants :

Documentation d'entreprise : génère des modèles de documentation et des descriptions claires pour votre produit de données et ses composants de données individuels.
Insights et exemples de requêtes : crée des exemples de requêtes prêts à l'emploi basés sur la mise en page du schéma de l'élément, ce qui permet aux consommateurs de données de commencer immédiatement à interroger le produit après approbation.

Si vous choisissez de ne pas activer Gemini, vous pouvez ignorer cette section. Toutefois, vous devez fournir manuellement toutes les métadonnées d'éléments et tous les modèles de requête lors de la création.

Pour en savoir plus sur l'activation de Gemini dans BigQuery, consultez Configurer Gemini dans BigQuery.

Activer les API

Activez les API Dataplex et BigQuery si elles ne le sont pas déjà.

Rôles requis pour activer les API

Pour activer des API, vous devez disposer de l'autorisation serviceusage.services.enable. Si vous avez créé le projet, vous disposez probablement déjà de cette autorisation via le rôle Propriétaire (roles/owner). Sinon, vous pouvez l'obtenir via le rôle Administrateur Service Usage (roles/serviceusage.serviceUsageAdmin). Découvrez comment attribuer des rôles.

Activer les API

Créer des éléments de données

Assurez-vous que vos éléments de données (par exemple, les ensembles de données, les tables et les vues BigQuery) sont créés et renseignés.

Pour en savoir plus sur la création d'éléments de données, consultez les documents suivants :

Configurer des identités

Identifiez ou créez les groupes Google ou les comptes de service que vous souhaitez configurer dans votre produit de données.

Facultatif : Configurer Looker (Google Cloud Core) pour les produits de données

Si vous prévoyez d'inclure des éléments Looker (Google Cloud Core) dans votre produit de données, procédez comme suit :

Assurez-vous que l'entrée de catalogue de la ressource Looker (Google Cloud Core) existe déjà dans Knowledge Catalog dans la même région que le produit de données. Pour en savoir plus, consultez Gérer les ressources Looker (Google Cloud Core) avec Knowledge Catalog.
Configurez Google OAuth et activez les groupes dupliqués dans votre instance Looker (Google Cloud Core) pour créer un groupe Looker en lecture seule pour votre groupe Google.
Attribuez des niveaux d'accès aux dossiers et des rôles Looker au groupe Looker mis en miroir.

Rôles requis

Cette section décrit les rôles IAM minimaux requis pour les sections principales suivantes :

Propriétaires de produits de données : utilisateurs qui créent, configurent et gèrent les produits de données et leurs éléments associés
Consommateurs de produits de données : utilisateurs qui recherchent, consultent et demandent l'accès aux produits de données publiés

Rôles requis pour les propriétaires de produits de données

Pour obtenir les autorisations nécessaires pour créer et gérer des produits de données, demandez à votre administrateur de vous accorder les rôles IAM suivants sur le projet :

Autorisations complètes pour créer, mettre à jour, supprimer, gérer les autorisations, et approuver ou refuser les demandes d'accès aux produits de données : Administrateur des produits de données Dataplex (roles/dataplex.dataProductsAdmin)
Mettre à jour et gérer les autorisations, et approuver ou refuser les demandes d'accès aux produits de données : Éditeur de produits de données Dataplex (roles/dataplex.dataProductsEditor)
Ajouter des aspects de métadonnées (tels que schema, overview, contacts et queries) : Propriétaire des entrées et des liens d'entrée Dataplex (roles/dataplex.entryOwner)
Rechercher et ajouter des éléments : Lecteur de catalogue Dataplex (roles/dataplex.catalogViewer)
Modifier les types d'aspects système (tels que overview, contact, contract et queries) : Éditeur de catalogue Dataplex (roles/dataplex.catalogEditor)
Créer ou récupérer des analyses de données d'insights pour la documentation automatisée et la génération d'insights : Administrateur Dataplex DataScan (roles/dataplex.dataScanAdmin)
Accéder aux métadonnées Looker (Google Cloud Core) dans Knowledge Catalog : Lecteur de schéma Looker (roles/looker.schemaViewer) sur le projet qui héberge l'instance Looker (Google Cloud Core)
Attribuez roles/looker.instanceUser au groupe Google du groupe d'accès : Administrateur de projet IAM (roles/resourcemanager.projectIamAdmin) sur le projet qui héberge l'instance Looker (Google Cloud Core)

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Ces rôles prédéfinis contiennent les autorisations requises pour créer et gérer des produits de données. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour créer et gérer des produits de données :

Créer un produit de données : dataplex.dataProducts.create
Répertoriez les produits de données d'un projet : dataplex.dataProducts.list
Obtenir ou afficher un produit de données : dataplex.dataProducts.get
Modifier un produit de données existant : dataplex.dataProducts.update
Supprimer le produit de données : dataplex.dataProducts.delete
Approuver la demande d'accès au produit de données : dataplex.dataProducts.approve
Recherchez un produit de données à l'aide de Knowledge Catalog :
- dataplex.dataProducts.get
- dataplex.projects.search
Créer une demande d'accès au produit de données : dataplex.dataProducts.get
Créez un élément de données : dataplex.dataAssets.create
Répertoriez les éléments de données d'un produit de données : dataplex.dataAssets.list
Obtenir l'asset de données : dataplex.dataAssets.get
Modifier un asset de données existant : dataplex.dataAssets.update
Supprimer l'élément de données : dataplex.dataAssets.delete
Créez une analyse de données : dataplex.datascans.create
Répertorier toutes les analyses de données : dataplex.datascans.list
Obtenir une analyse de données : dataplex.datascans.get
Exécuter une analyse de données : dataplex.datascans.run
Modifiez le type d'aspect système overview : dataplex.entryGroups.useOverviewAspect
Modifiez le type d'aspect système refresh cadence : dataplex.entryGroups.useRefreshCadenceAspect
Modifiez le type d'aspect système queries : dataplex.entryGroups.useQueriesAspect

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés ou d'autres rôles prédéfinis.

Rôles requis pour les consommateurs de produits de données

Pour que les consommateurs de produits de données puissent rechercher, afficher et demander l'accès à des produits de données, vous devez, en tant que propriétaire de produits de données, vous assurer que le produit de données est visible. Pour ce faire, attribuez aux consommateurs du produit de données les rôles IAM suivants sur le produit de données :

Rechercher des produits de données et demander l'accès à ceux-ci : consommateur de produits de données Dataplex (dataplex.dataProductsConsumer) et lecteur de catalogue Dataplex (roles/dataplex.catalogViewer)
Accès en lecture seule pour afficher les définitions et les métadonnées des produits de données : lecteur de produits de données Dataplex (dataplex.dataProductsViewer)

Créer et configurer un produit de données

La création d'un produit de données implique les tâches générales suivantes :

Créer un produit de données

Cette étape initiale obligatoire nécessite de définir des détails essentiels, tels qu'un nom unique pour le produit de données, une description, la région dans laquelle le produit de données est créé et des coordonnées.
Facultatif : Ajouter des composants

Au cours de cette phase, vous sélectionnez les éléments à inclure dans le produit de données. Une contrainte essentielle est que les éléments doivent se trouver dans la même région que le produit de données lui-même. Vous pouvez ajouter jusqu'à 10 assets à la fois, avec un maximum de 50 assets par produit de données.

Pour obtenir la liste des assets compatibles, consultez Assets compatibles.
Facultatif : Configurer les groupes d'accès et les autorisations associées aux éléments

Dans cette phase facultative, vous simplifiez le contrôle des accès en créant des groupes d'accès. Ces groupes d'accès agissent comme des alias conviviaux (par exemple, Analyst ou Reader) pour les groupes Google et les comptes de service sous-jacents. Vous attribuez ensuite des autorisations en sélectionnant un rôle IAM spécifique et en le mappant à un groupe d'accès pour un élément spécifique.
Facultatif : Ajouter des détails sur le contrat et l'aspect

Au cours de cette phase, vous améliorez la gouvernance et la visibilité des données en associant des frameworks de métadonnées. Vous pouvez ajouter un contrat pour communiquer formellement la cadence d'actualisation de vos données, en spécifiant des paramètres tels que la fréquence d'actualisation, le moment et les seuils de variance. Vous pouvez également associer des aspects personnalisés pour fournir des métadonnées métier ou techniques supplémentaires pour votre produit de données.
Facultatif : Ajouter des détails supplémentaires

Dans cette dernière phase, vous ajoutez une documentation en texte enrichi, telle que des guides d'intégration des utilisateurs, des définitions d'entreprise et des exemples de requêtes, pour aider les consommateurs à interagir avec le produit de données dès son approbation.

Pour créer et configurer un produit de données, suivez les étapes décrites dans les sections suivantes :

Créer un produit de données

Console

Dans la console Google Cloud , accédez à la page Produits de données de Knowledge Catalog.

Accéder à la page "Produits de données"
Cliquez sur Créer.
Dans le volet Créer des produits de données, saisissez les informations suivantes :
- Nom du produit de données : saisissez un nom unique pour votre produit de données.
- ID du produit de données : il s'agit d'un identifiant unique généré automatiquement. Vous pouvez modifier ce champ.
- ID du projet : identifiant unique du projet dans lequel le produit de données est créé. Recherchez et sélectionnez le projet.
- Région : sélectionnez la région ou l'emplacement multirégional où le produit de données est créé.
- Icône du produit de données : parcourez et sélectionnez une icône pour identifier visuellement le produit de données. Cette opération est facultative.
- Description : saisissez une brève description du produit de données.
- Contacts : fournissez les coordonnées du point de contact pour les workflows de gouvernance et d'approbation :
  - Adresse e-mail du ou des propriétaires du produit de données : saisissez l'adresse e-mail des propriétaires du produit de données.
  - Adresse e-mail du ou des approbateurs du produit de données : saisissez l'adresse e-mail des approbateurs désignés chargés d'approuver les demandes d'accès ou les modifications.
- Étiquettes : ajoutez des étiquettes clé-valeur pour organiser vos ressources. Cette opération est facultative.
Cliquez sur Créer un produit de données.

Terraform

Pour créer un produit de données, utilisez les ressources google_dataplex_data_product et 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"
}

Remplacez les éléments suivants :

PROJECT_ID : ID de votre projet Google Cloud .
LOCATION : région dans laquelle vous souhaitez créer le produit de données.
DATA_PRODUCT_ID : identifiant unique de votre produit de données.
DISPLAY_NAME : nom convivial de votre produit de données.
DESCRIPTION : brève description du produit de données.
EMAIL_IDs : adresses e-mail des propriétaires du produit de données, séparées par une virgule (par exemple, ["user1@example.com", "user2@example.com"]).
APPROVER_EMAIL_IDs : adresses e-mail séparées par une virgule des approbateurs désignés chargés de valider les demandes d'accès ou les modifications pour ce produit de données.
ICON_BASE64_STRING : données d'image brutes encodées en base64 représentant le produit de données. La taille maximale est de 3 Mio. N'incluez pas le préfixe du schéma d'URL de données.
MEMBER : utilisateur, compte de service ou groupe recevant le rôle de consommateur (par exemple, group:all-analysts@example.com).

C#

Avant d'essayer cet exemple, suivez les instructions de configuration pour C# décrites dans le guide de démarrage rapide de Knowledge Catalog à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Knowledge Catalog pour C#.

Pour vous authentifier auprès de Knowledge Catalog, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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

Avant d'essayer cet exemple, suivez les instructions de configuration pour Go décrites dans le guide de démarrage rapide de Knowledge Catalog à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Knowledge Catalog pour Go.


//go:build examples

package main

import (
	"context"

	dataplex "cloud.google.com/go/dataplex/apiv1"
	dataplexpb "cloud.google.com/go/dataplex/apiv1/dataplexpb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := dataplex.NewDataProductClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.CreateDataProductRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#CreateDataProductRequest.
	}
	op, err := c.CreateDataProduct(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

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

Java

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java décrites dans le guide de démarrage rapide de Knowledge Catalog à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Knowledge Catalog pour Java.

import com.google.cloud.dataplex.v1.CreateDataProductRequest;
import com.google.cloud.dataplex.v1.DataProduct;
import com.google.cloud.dataplex.v1.DataProductServiceClient;
import com.google.cloud.dataplex.v1.LocationName;

public class SyncCreateDataProduct {

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

  public static void syncCreateDataProduct() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DataProductServiceClient dataProductServiceClient = DataProductServiceClient.create()) {
      CreateDataProductRequest request =
          CreateDataProductRequest.newBuilder()
              .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
              .setDataProductId("dataProductId1437828576")
              .setDataProduct(DataProduct.newBuilder().build())
              .setValidateOnly(true)
              .build();
      DataProduct response = dataProductServiceClient.createDataProductAsync(request).get();
    }
  }
}

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js décrites dans le guide de démarrage rapide de Knowledge Catalog à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Knowledge Catalog pour Node.js.

/**
 * This snippet has been automatically generated and should be regarded as a code template only.
 * It will require modifications to work.
 * It may require correct/in-range values for request initialization.
 * TODO(developer): Uncomment these variables before running the sample.
 */
/**
 *  Required. The parent resource where this data product will be created.
 *  Format: projects/{project_id_or_number}/locations/{location_id}
 */
// const parent = 'abc123'
/**
 *  Optional. The ID of the data product to create.
 *  The ID must conform to RFC-1034 and contain only lower-case letters (a-z),
 *  numbers (0-9), or hyphens, with the first character a letter, the last a
 *  letter or a number, and a 63 character maximum. Characters outside of
 *  ASCII are not permitted.
 *  Valid format regex: `^[a-z]([a-z0-9-]{0,61}[a-z0-9])?$`
 *  If not provided, a system generated ID will be used.
 */
// const dataProductId = 'abc123'
/**
 *  Required. The data product to create.
 */
// const dataProduct = {}
/**
 *  Optional. Validates the request without actually creating the data product.
 *  Default: false.
 */
// const validateOnly = true

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

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

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

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

callCreateDataProduct();

Python

Avant d'essayer cet exemple, suivez les instructions de configuration pour Python décrites dans le guide de démarrage rapide de Knowledge Catalog à l'aide des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Knowledge Catalog pour Python.

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_create_data_product():
    # Create a client
    client = dataplex_v1.DataProductServiceClient()

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

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

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

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

    response = operation.result()

    # Handle the response
    print(response)

REST

Pour créer un produit de données, utilisez la méthode dataProducts.create.

Par exemple, envoyez la requête POST suivante :

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

Remplacez les éléments suivants :

DISPLAY_NAME : nom convivial pour votre produit de données
EMAIL_IDs : adresses e-mail des propriétaires du produit de données, séparées par une virgule
APPROVER_EMAIL_IDs : adresses e-mail séparées par une virgule des approbateurs désignés chargés de valider les demandes d'accès ou les modifications.
PROJECT_ID : ID de votre projet Google Cloud
LOCATION : région dans laquelle vous souhaitez créer le produit de données
DATA_PRODUCT_ID : identifiant unique de votre produit de données

Facultatif : Ajouter des composants

Vous pouvez ajouter divers éléments de données, tels que des tables, des vues, des ensembles de données et des modèles BigQuery, à votre produit de données. Pour obtenir la liste des assets compatibles, consultez Assets compatibles.

Console

Dans le volet Ajouter des éléments, cliquez sur + Ajouter.
Recherchez et sélectionnez les éléments que vous souhaitez ajouter à votre produit de données. Les éléments que vous sélectionnez doivent se trouver dans la même région que le produit de données.

Si vous disposez des autorisations nécessaires, vous pouvez afficher les métadonnées des éléments en cliquant dessus.
Pour affiner les résultats de recherche, utilisez des filtres.
Après avoir sélectionné les assets, cliquez sur Ajouter.

Remarque : Vous pouvez ajouter jusqu'à 10 assets à la fois, avec un maximum de 50 assets par produit de données.
Cliquez sur Continuer.

Terraform

Pour ajouter un élément de données à votre produit de données, utilisez la ressource 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"
}

Remplacez les éléments suivants :

PROJECT_ID : ID de votre projet Google Cloud
LOCATION : région où se trouve le produit de données
DATA_PRODUCT_ID : ID du produit de données
DATA_ASSET_ID : identifiant unique de cet élément de données dans le produit de données
RESOURCE_NAME : nom complet de la ressource de l'élément de données (par exemple, //bigquery.googleapis.com/projects/PROJECT_ID/datasets/DATASET_ID/tables/TABLE_ID)

C#

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

public sealed partial class GeneratedDataProductServiceClientSnippets
{
    /// <summary>Snippet for CreateDataAsset</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void CreateDataAssetRequestObject()
    {
        // Create client
        DataProductServiceClient dataProductServiceClient = DataProductServiceClient.Create();
        // Initialize request argument(s)
        CreateDataAssetRequest request = new CreateDataAssetRequest
        {
            ParentAsDataProductName = DataProductName.FromProjectLocationDataProduct("[PROJECT]", "[LOCATION]", "[DATA_PRODUCT]"),
            DataAssetId = "",
            DataAsset = new DataAsset(),
            ValidateOnly = false,
        };
        // Make the request
        Operation<DataAsset, OperationMetadata> response = dataProductServiceClient.CreateDataAsset(request);

        // Poll until the returned long-running operation is complete
        Operation<DataAsset, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        DataAsset result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<DataAsset, OperationMetadata> retrievedResponse = dataProductServiceClient.PollOnceCreateDataAsset(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            DataAsset retrievedResult = retrievedResponse.Result;
        }
    }
}

Go


//go:build examples

package main

import (
	"context"

	dataplex "cloud.google.com/go/dataplex/apiv1"
	dataplexpb "cloud.google.com/go/dataplex/apiv1/dataplexpb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := dataplex.NewDataProductClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.CreateDataAssetRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#CreateDataAssetRequest.
	}
	op, err := c.CreateDataAsset(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

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

Java

import com.google.cloud.dataplex.v1.CreateDataAssetRequest;
import com.google.cloud.dataplex.v1.DataAsset;
import com.google.cloud.dataplex.v1.DataProductName;
import com.google.cloud.dataplex.v1.DataProductServiceClient;

public class SyncCreateDataAsset {

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

  public static void syncCreateDataAsset() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DataProductServiceClient dataProductServiceClient = DataProductServiceClient.create()) {
      CreateDataAssetRequest request =
          CreateDataAssetRequest.newBuilder()
              .setParent(DataProductName.of("[PROJECT]", "[LOCATION]", "[DATA_PRODUCT]").toString())
              .setDataAssetId("dataAssetId2108984609")
              .setDataAsset(DataAsset.newBuilder().build())
              .setValidateOnly(true)
              .build();
      DataAsset response = dataProductServiceClient.createDataAssetAsync(request).get();
    }
  }
}

Node.js

/**
 * This snippet has been automatically generated and should be regarded as a code template only.
 * It will require modifications to work.
 * It may require correct/in-range values for request initialization.
 * TODO(developer): Uncomment these variables before running the sample.
 */
/**
 *  Required. The parent resource where this data asset will be created.
 *  Format:
 *  projects/{project_id_or_number}/locations/{location_id}/dataProducts/{data_product_id}
 */
// const parent = 'abc123'
/**
 *  Optional. The ID of the data asset to create.
 *  The ID must conform to RFC-1034 and contain only lower-case letters (a-z),
 *  numbers (0-9), or hyphens, with the first character a letter, the last a
 *  letter or a number, and a 63 character maximum. Characters outside of
 *  ASCII are not permitted.
 *  Valid format regex: `^[a-z]([a-z0-9-]{0,61}[a-z0-9])?$`
 *  If not provided, a system generated ID will be used.
 */
// const dataAssetId = 'abc123'
/**
 *  Required. The data asset to create.
 */
// const dataAsset = {}
/**
 *  Optional. Validates the request without actually creating the data asset.
 *  Defaults to false.
 */
// const validateOnly = true

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

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

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

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

callCreateDataAsset();

Python

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_create_data_asset():
    # Create a client
    client = dataplex_v1.DataProductServiceClient()

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

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

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

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

    response = operation.result()

    # Handle the response
    print(response)

REST

Pour ajouter un asset de données à votre produit de données, utilisez la méthode dataAssets.create.

Par exemple, envoyez la requête POST suivante :

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

Remplacez les éléments suivants :

RESOURCE_NAME : nom complet de la ressource de l'élément de données (par exemple, //bigquery.googleapis.com/projects/PROJECT_ID/datasets/DATASET_ID/tables/TABLE_ID)
PROJECT_ID : ID de votre projet Google Cloud
LOCATION : région où se trouve le produit de données
DATA_PRODUCT_ID : ID du produit de données
DATA_ASSET_ID : identifiant unique de cet élément de données dans le produit de données

Facultatif : Configurer les groupes d'accès et les autorisations associées aux éléments

Dans le volet Configurer les groupes d'accès et les autorisations associées aux éléments, vous pouvez créer des groupes d'accès et attribuer des autorisations aux éléments.

Configurer les groupes d'accès

Console

Cliquez sur Ajouter un groupe d'accès.
Dans le champ Nom du groupe d'accès, saisissez un nom pour le groupe d'accès. Exemple :Analyst
Dans le champ Description du groupe d'accès, saisissez une description du groupe d'accès.
Dans le champ Identifiant du groupe d'accès, saisissez l'adresse e-mail d'un groupe Google que vous souhaitez attribuer à ce groupe d'accès.

Les consommateurs du produit de données qui demandent l'accès pour eux-mêmes sont ajoutés en tant que membres au groupe Google mappé.

Pour en savoir plus sur la création de groupes Google, consultez Créer et gérer des groupes Google dans la console Google Cloud .
Dans le champ Compte de service du groupe d'accès, saisissez l'adresse e-mail d'un compte de service que vous souhaitez attribuer à ce groupe d'accès.

Les consommateurs de produits de données qui demandent l'accès pour leurs comptes de service se voient attribuer le rôle IAM Créateur de jetons du compte de service (roles/iam.serviceAccountTokenCreator) pour emprunter l'identité du compte de service du producteur de données mappé au groupe d'accès.

Pour en savoir plus sur la création de comptes de service, consultez Créer des comptes de service.
Facultatif : Dans le champ Rôle par défaut, sélectionnez un rôle IAM par défaut (par exemple, BigQuery Data Viewer) pour ce groupe d'accès. Ce rôle est automatiquement accordé sur tous les éléments compatibles existants et nouvellement ajoutés dans le produit de données, sauf si vous le remplacez au niveau de l'élément.
Cliquez sur OK.
Pour ajouter un autre groupe d'accès, cliquez sur Ajouter un groupe d'accès et répétez la procédure.

Vous pouvez ajouter jusqu'à trois groupes d'accès par produit de données.
Cliquez sur Enregistrer.

Terraform

Pour définir des groupes d'accès pour votre produit de données, utilisez le bloc imbriqué access_groups dans la ressource google_dataplex_data_product.

Par exemple, utilisez la configuration suivante :

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

Remplacez les éléments suivants :

PROJECT_ID : ID de votre projet Google Cloud
LOCATION : région où se trouve le produit de données
DATA_PRODUCT_ID : identifiant unique du produit de données
DISPLAY_NAME : nom convivial pour votre produit de données
EMAIL_IDs : adresses e-mail des propriétaires du produit de données, séparées par une virgule, par exemple ["user1@example.com", "user2@example.com"]
SERVICE_ACCOUNT_EMAIL_ADDRESS : adresse e-mail du compte de service.

C#

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

public sealed partial class GeneratedDataProductServiceClientSnippets
{
    /// <summary>Snippet for UpdateDataProduct</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void UpdateDataProductRequestObject()
    {
        // Create client
        DataProductServiceClient dataProductServiceClient = DataProductServiceClient.Create();
        // Initialize request argument(s)
        UpdateDataProductRequest request = new UpdateDataProductRequest
        {
            DataProduct = new DataProduct(),
            UpdateMask = new FieldMask(),
            ValidateOnly = false,
        };
        // Make the request
        Operation<DataProduct, OperationMetadata> response = dataProductServiceClient.UpdateDataProduct(request);

        // Poll until the returned long-running operation is complete
        Operation<DataProduct, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        DataProduct result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<DataProduct, OperationMetadata> retrievedResponse = dataProductServiceClient.PollOnceUpdateDataProduct(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            DataProduct retrievedResult = retrievedResponse.Result;
        }
    }
}

Go


//go:build examples

package main

import (
	"context"

	dataplex "cloud.google.com/go/dataplex/apiv1"
	dataplexpb "cloud.google.com/go/dataplex/apiv1/dataplexpb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := dataplex.NewDataProductClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.UpdateDataProductRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#UpdateDataProductRequest.
	}
	op, err := c.UpdateDataProduct(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

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

Java

import com.google.cloud.dataplex.v1.DataProduct;
import com.google.cloud.dataplex.v1.DataProductServiceClient;
import com.google.cloud.dataplex.v1.UpdateDataProductRequest;
import com.google.protobuf.FieldMask;

public class SyncUpdateDataProduct {

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

  public static void syncUpdateDataProduct() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DataProductServiceClient dataProductServiceClient = DataProductServiceClient.create()) {
      UpdateDataProductRequest request =
          UpdateDataProductRequest.newBuilder()
              .setDataProduct(DataProduct.newBuilder().build())
              .setUpdateMask(FieldMask.newBuilder().build())
              .setValidateOnly(true)
              .build();
      DataProduct response = dataProductServiceClient.updateDataProductAsync(request).get();
    }
  }
}

Node.js

/**
 * This snippet has been automatically generated and should be regarded as a code template only.
 * It will require modifications to work.
 * It may require correct/in-range values for request initialization.
 * TODO(developer): Uncomment these variables before running the sample.
 */
/**
 *  Required. The data product to update.
 *  The data product's `name` field is used to identify the data product to
 *  update.
 */
// const dataProduct = {}
/**
 *  Optional. The list of fields to update.
 *  If this is empty or not set, then all the fields will be updated.
 */
// const updateMask = {}
/**
 *  Optional. Validates the request without actually updating the data product.
 *  Default: false.
 */
// const validateOnly = true

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

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

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

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

callUpdateDataProduct();

Python

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_update_data_product():
    # Create a client
    client = dataplex_v1.DataProductServiceClient()

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

    request = dataplex_v1.UpdateDataProductRequest(
        data_product=data_product,
    )

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

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

    response = operation.result()

    # Handle the response
    print(response)

REST

Pour configurer un groupe d'accès pour le produit de données, utilisez la méthode dataProducts.patch.

Par exemple, envoyez la requête PATCH suivante :

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"

Remplacez les éléments suivants :

ACCESS_GROUPS_MAP : objet JSON représentant un mappage où chaque clé est un ID de groupe d'accès et la valeur est un objet AccessGroup. Exemple :

{
"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 de votre projet Google Cloud
LOCATION : région où se trouve le produit de données
DATA_PRODUCT_ID : ID de votre produit de données

Configurer les autorisations des composants

Après avoir configuré les groupes d'accès, vous pouvez configurer les autorisations pour les éléments du produit de données.

Si vous avez configuré un rôle IAM par défaut pour un groupe d'accès, les éléments compatibles héritent automatiquement de ce rôle (indiqué par un libellé Par défaut dans la colonne Autorisations). Vous pouvez remplacer le rôle par défaut pour des éléments spécifiques en attribuant un autre rôle.

Console

Dans la section Autorisations des éléments, sélectionnez l'élément pour lequel vous souhaitez configurer des autorisations. Vous pouvez sélectionner et configurer les autorisations pour 10 assets maximum à la fois.
Cliquez sur Configurer les autorisations.
Dans le champ Sélectionner un groupe d'accès, sélectionnez un groupe d'accès.
Dans le champ Attribuer un rôle IAM, sélectionnez un rôle IAM que vous souhaitez attribuer au groupe d'accès.

Par exemple, si votre asset est une table BigQuery nommée Sales, que vous avez sélectionné le groupe d'accès Analyst et que vous avez attribué le rôle BigQuery Metadata Viewer à ce groupe d'accès, les consommateurs de produits de données qui font partie du groupe d'accès Analyst disposent de l'autorisation BigQuery Metadata Viewer sur la table Sales.

Vous pouvez ajouter plusieurs rôles à un élément.
Cliquez sur Configurer. La colonne Autorisations du tableau des éléments affiche les autorisations attribuées et leur état de configuration pour chaque groupe d'accès :
- Appliqué : le rôle IAM (hérité du rôle par défaut du groupe d'accès ou configuré spécifiquement pour l'élément) est actif sur la ressource sous-jacente.
- Échec : l'application du rôle IAM à la ressource sous-jacente a échoué. Vous trouverez la raison détaillée de l'échec dans Cloud Logging.
- Non compatible : l'application d'autorisations n'est pas compatible avec le type de ressource de cet élément.
Pour configurer les autorisations d'autres composants, répétez ces étapes.
Cliquez sur Continuer.

Terraform

Attribuez des rôles IAM à vos groupes d'accès pour des éléments spécifiques à l'aide du bloc access_group_configs dans la ressource google_dataplex_data_product_data_asset.

Par exemple, utilisez la configuration suivante :

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

Remplacez les éléments suivants :

PROJECT_ID : ID de votre projet Google Cloud
LOCATION : région où se trouve le produit de données
DATA_PRODUCT_ID : ID du produit de données
DATA_ASSET_ID : identifiant unique de cet élément de données dans le produit de données
RESOURCE_NAME : nom complet de la ressource de l'élément de données (par exemple, //bigquery.googleapis.com/projects/PROJECT_ID/datasets/DATASET_ID/tables/TABLE_ID)

C#

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

public sealed partial class GeneratedDataProductServiceClientSnippets
{
    /// <summary>Snippet for UpdateDataAsset</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public void UpdateDataAssetRequestObject()
    {
        // Create client
        DataProductServiceClient dataProductServiceClient = DataProductServiceClient.Create();
        // Initialize request argument(s)
        UpdateDataAssetRequest request = new UpdateDataAssetRequest
        {
            DataAsset = new DataAsset(),
            UpdateMask = new FieldMask(),
            ValidateOnly = false,
        };
        // Make the request
        Operation<DataAsset, OperationMetadata> response = dataProductServiceClient.UpdateDataAsset(request);

        // Poll until the returned long-running operation is complete
        Operation<DataAsset, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        DataAsset result = completedResponse.Result;

        // Or get the name of the operation
        string operationName = response.Name;
        // This name can be stored, then the long-running operation retrieved later by name
        Operation<DataAsset, OperationMetadata> retrievedResponse = dataProductServiceClient.PollOnceUpdateDataAsset(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            DataAsset retrievedResult = retrievedResponse.Result;
        }
    }
}

Go


//go:build examples

package main

import (
	"context"

	dataplex "cloud.google.com/go/dataplex/apiv1"
	dataplexpb "cloud.google.com/go/dataplex/apiv1/dataplexpb"
)

func main() {
	ctx := context.Background()
	// This snippet has been automatically generated and should be regarded as a code template only.
	// It will require modifications to work:
	// - It may require correct/in-range values for request initialization.
	// - It may require specifying regional endpoints when creating the service client as shown in:
	//   https://pkg.go.dev/cloud.google.com/go#hdr-Client_Options
	c, err := dataplex.NewDataProductClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.UpdateDataAssetRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#UpdateDataAssetRequest.
	}
	op, err := c.UpdateDataAsset(ctx, req)
	if err != nil {
		// TODO: Handle error.
	}

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

Java

import com.google.cloud.dataplex.v1.DataAsset;
import com.google.cloud.dataplex.v1.DataProductServiceClient;
import com.google.cloud.dataplex.v1.UpdateDataAssetRequest;
import com.google.protobuf.FieldMask;

public class SyncUpdateDataAsset {

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

  public static void syncUpdateDataAsset() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (DataProductServiceClient dataProductServiceClient = DataProductServiceClient.create()) {
      UpdateDataAssetRequest request =
          UpdateDataAssetRequest.newBuilder()
              .setDataAsset(DataAsset.newBuilder().build())
              .setUpdateMask(FieldMask.newBuilder().build())
              .setValidateOnly(true)
              .build();
      DataAsset response = dataProductServiceClient.updateDataAssetAsync(request).get();
    }
  }
}

Node.js

/**
 * This snippet has been automatically generated and should be regarded as a code template only.
 * It will require modifications to work.
 * It may require correct/in-range values for request initialization.
 * TODO(developer): Uncomment these variables before running the sample.
 */
/**
 *  Required. The data asset to update.
 *  The data asset's `name` field is used to identify the data asset to update.
 */
// const dataAsset = {}
/**
 *  Optional. The list of fields to update.
 *  If this is empty or not set, then all the fields will be updated.
 */
// const updateMask = {}
/**
 *  Optional. Validates the request without actually updating the data asset.
 *  Defaults to false.
 */
// const validateOnly = true

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

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

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

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

callUpdateDataAsset();

Python

# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.cloud import dataplex_v1


def sample_update_data_asset():
    # Create a client
    client = dataplex_v1.DataProductServiceClient()

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

    request = dataplex_v1.UpdateDataAssetRequest(
        data_asset=data_asset,
    )

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

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

    response = operation.result()

    # Handle the response
    print(response)

REST

Pour configurer les autorisations pour les éléments du produit de données, utilisez la méthode dataAssets.patch.

Par exemple, envoyez la requête PATCH suivante :

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"

Remplacez les éléments suivants :

ACCESS_GROUP_CONFIGS_MAP : objet JSON représentant un mappage où chaque clé est un ID de groupe d'accès et la valeur est un objet AccessGroupConfig. Exemple :
```
{
"analyst": {
  iam_roles: ["roles/bigquery.dataViewer"]
  }
}
```
PROJECT_ID : ID de votre projet Google Cloud
LOCATION : région où se trouve le produit de données
DATA_PRODUCT_ID : ID de votre produit de données
DATA_ASSET_ID : ID de l'élément pour lequel vous souhaitez configurer des autorisations.

Facultatif : Ajouter des détails sur le contrat et l'aspect

Vous pouvez ajouter des contrats et des aspects à un produit de données.

Ajouter un contrat

Pour établir une relation de confiance entre les producteurs et les consommateurs de données, vous pouvez associer un contrat à votre produit de données. En spécifiant des paramètres tels que l'heure d'actualisation et les seuils, vous fournissez aux consommateurs le contexte nécessaire pour comprendre quand les données sont mises à jour et si elles répondent à leurs exigences métier spécifiques.

Console

Dans le volet Ajouter des détails sur le contrat et l'aspect, cliquez sur Ajouter un contrat.
Dans le champ Sélectionner un contrat, sélectionnez Refresh cadence.
Dans le champ Fréquence, sélectionnez une planification convenue pour la fréquence de mise à jour ou de diffusion des données, afin de garantir un flux prévisible du producteur de données au consommateur de données. Exemple :Weekly
Dans le champ Refresh time (Délai d'actualisation), saisissez un délai maximal acceptable entre le moment où les données sont mises à jour au niveau de leur source et celui où elles deviennent disponibles pour le consommateur. Exemple :23:00 PST
Dans le champ Seuil (en minutes), saisissez une limite mesurable en minutes pour le délai acceptable de diffusion des données. Par exemple, saisissez 30 pour définir un seuil de 30 minutes.
Facultatif : Dans le champ Programmation Cron, saisissez une expression Cron qui définit la programmation de la génération et de la diffusion des données au format suivant : MINUTE HOUR DAY_OF_MONTH MONTH DAY_OF_WEEK

Les valeurs acceptées sont les suivantes :
- 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
Par exemple, 0 8 * * 1-5 s'exécute à 8h en semaine (du lundi au vendredi).
Cliquez sur Enregistrer.

REST

Les contrats sont modélisés en tant qu'aspects sur le produit de données. Pour ajouter un contrat Refresh Cadence à un produit de données, utilisez la méthode entries.patch.

Par exemple, envoyez la requête PATCH suivante :

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"

Remplacez les éléments suivants :

REFRESH_FREQUENCY : calendrier convenu pour la fréquence de mise à jour ou de livraison des données, garantissant un flux prévisible du producteur de données au consommateur de données. Par exemple : Weekly
PROJECT_ID : ID de votre projet Google Cloud où l'appel d'API est effectué
LOCATION : région du point de terminaison du service Knowledge Catalog que vous appelez (par exemple, us-central1)
DATA_PRODUCT_PROJECT_NUMBER : numéro du projet dans lequel se trouve la ressource de produit de données
DATA_PRODUCT_LOCATION : emplacement de la ressource de produit de données
DATA_PRODUCT_ID : ID de votre produit de données

Terraform

Les contrats sont modélisés en tant qu'aspects sur le produit de données. Pour gérer un contrat, vous devez gérer l'entrée Knowledge Catalog sous-jacente. Comme Terraform ne découvre pas automatiquement les aspects existants, vous devez d'abord importer google_dataplex_entry.

Pour importer l'entrée, utilisez la commande suivante :

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"

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

Remplacez les éléments suivants :

DATA_PRODUCT_PROJECT_NUMBER : numéro du projet dans lequel se trouve la ressource de produit de données
LOCATION : région du point de terminaison du service Knowledge Catalog que vous appelez (par exemple, us-central1)
DATA_PRODUCT_ID : ID de votre produit de données
REFRESH_FREQUENCY : calendrier convenu pour la fréquence de mise à jour ou de diffusion des données, garantissant un flux prévisible du producteur de données au consommateur de données. Par exemple : Weekly

Pour obtenir des informations générales sur le processus d'importation, consultez la documentation sur l'importation Terraform.

Ajouter des aspects

Utilisez des aspects pour enrichir votre produit de données avec des métadonnées structurées et réutilisables. Ces modèles permettent aux producteurs de données de communiquer de manière standardisée sur la qualité et l'adéquation d'un produit de données, ce qui améliore la gouvernance et aide les consommateurs à déterminer si le produit répond à leurs besoins métier.

Pour ajouter des aspects au produit de données, procédez comme suit :

Console

Dans le volet Ajouter des détails sur le contrat et l'aspect, cliquez sur + Ajouter un aspect.
Dans le champ Sélectionner un type d'aspect, recherchez et sélectionnez un type d'aspect dans la liste. Exemple :Geo context
Cliquez sur Enregistrer.

REST

Pour ajouter des aspects à un produit de données, utilisez la méthode entries.patch.

Par exemple, envoyez la requête PATCH suivante :

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"

Remplacez les éléments suivants :

ASPECT_PROJECT_ID : ID de votre projet Google Clouddans lequel l'aspect est créé
ASPECT_LOCATION : région du point de terminaison du service Knowledge Catalog où l'aspect est créé (par exemple, us-central1)
ASPECT_NAME : nom de l'aspect que vous souhaitez associer au produit de données
PROJECT_ID : ID de votre projet Google Cloud où l'appel d'API est effectué
LOCATION : région du point de terminaison du service Knowledge Catalog que vous appelez (par exemple, us-central1)
DATA_PRODUCT_PROJECT_NUMBER : numéro du projet dans lequel se trouve la ressource de produit de données
DATA_PRODUCT_LOCATION : emplacement de la ressource de produit de données
DATA_PRODUCT_ID : ID de votre produit de données

Terraform

Pour gérer les aspects, vous devez gérer l'entrée Knowledge Catalog sous-jacente. Comme Terraform ne découvre pas automatiquement les aspects existants, vous devez d'abord importer google_dataplex_entry.

Pour importer l'entrée, utilisez la commande suivante :

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"

Configuration 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 = {}
  }
}
}

Remplacez les éléments suivants :

DATA_PRODUCT_PROJECT_NUMBER : numéro du projet dans lequel se trouve la ressource de produit de données
LOCATION : région du point de terminaison du service Knowledge Catalog que vous appelez (par exemple, us-central1)
DATA_PRODUCT_ID : ID de votre produit de données
ASPECT_PROJECT_NUMBER : numéro du projet Google Cloud dans lequel l'aspect est créé.
ASPECT_LOCATION : région du point de terminaison du service Knowledge Catalog où l'aspect est créé (par exemple, us-central1)
ASPECT_NAME : nom de l'aspect que vous souhaitez associer au produit de données

Pour obtenir des informations générales sur le processus d'importation, consultez la documentation sur l'importation Terraform.

Facultatif : ajoutez des détails supplémentaires

Vous pouvez ajouter de la documentation et des exemples de requêtes pour votre produit de données afin de fournir un contexte essentiel, des descriptions de la logique métier et des guides de l'utilisateur. Dans Knowledge Catalog, la documentation est gérée via l'aspect système overview.

Vous pouvez créer cette documentation manuellement ou utiliser les insights sur les données de Knowledge Catalog pour la générer automatiquement.

Ajouter manuellement de la documentation et des exemples de requêtes

Console

Pour ajouter de la documentation à votre produit de données, procédez comme suit :

Dans le volet Ajouter des détails, cliquez sur Modifier à côté de Documentation.
Saisissez le contenu dans l'éditeur de texte enrichi.
Cliquez sur Enregistrer.

Pour ajouter des exemples de requêtes pour votre produit de données, procédez comme suit :

Dans le volet Ajouter des détails supplémentaires, cliquez sur Ajouter des requêtes dans la section Recommandation de requête.
Saisissez les exemples de requêtes.
Cliquez sur Enregistrer.

Le produit de données que vous venez de créer s'affiche sur la page Produits de données de Knowledge Catalog.

REST

La documentation est modélisée sous forme d'aspects sur le produit de données. Pour ajouter de la documentation, utilisez la méthode entries.patch.

Par exemple, envoyez la requête PATCH suivante :

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"

Remplacez les éléments suivants :

PROJECT_ID : ID de votre projet Google Cloud où l'appel d'API est effectué
LOCATION : région du point de terminaison du service Knowledge Catalog que vous appelez (par exemple, us-central1)
DATA_PRODUCT_PROJECT_NUMBER : numéro du projet dans lequel se trouve la ressource de produit de données
DATA_PRODUCT_LOCATION : emplacement de la ressource de produit de données
DATA_PRODUCT_ID : ID de votre produit de données
DOCUMENTATION : contenu que vous souhaitez associer au produit de données

Terraform

La documentation est modélisée sous forme d'aspects sur le produit de données. Pour gérer la documentation, vous devez gérer l'entrée Knowledge Catalog sous-jacente. Comme Terraform ne découvre pas automatiquement les aspects existants, vous devez d'abord importer google_dataplex_entry.

Pour importer l'entrée, utilisez la commande suivante :

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"

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

Remplacez les éléments suivants :

DATA_PRODUCT_PROJECT_NUMBER : numéro du projet dans lequel se trouve la ressource de produit de données
LOCATION : région du point de terminaison du service Knowledge Catalog que vous appelez (par exemple, us-central1)
DATA_PRODUCT_ID : ID de votre produit de données
DOCUMENTATION : contenu que vous souhaitez associer au produit de données

Pour obtenir des informations générales sur le processus d'importation, consultez la documentation sur l'importation Terraform.

Générer automatiquement de la documentation et des exemples de requêtes à l'aide des insights sur les données

Avant de générer de la documentation et des exemples de requêtes à l'aide de Gemini, remplissez les conditions préalables suivantes :

Activez l'API Gemini pour Google Cloud dans le projet où vous créez le produit de données.
Attribuer des rôles utilisateur spécifiques aux insights : demandez à votre administrateur d'attribuer à votre identité les rôles et autorisations suivants sur le projet de produit de données :
- Générer et gérer des insights sur les données : éditeur Dataplex DataScan (roles/dataplex.dataScanEditor) ou administrateur Dataplex DataScan (roles/dataplex.dataScanAdmin) sur le projet où réside le produit de données
- Afficher les insights générés : lecteur de données Dataplex DataScan (roles/dataplex.dataScanDataViewer) sur le projet où se trouve le produit de données
Configurez les autorisations de l'agent de service multiprojet. Si vos éléments de données sous-jacents résident dans un projet Google Cloud différent de celui de votre produit de données, vous devez accorder à l'agent de service Knowledge Catalog (P4SA) l'accès à ces éléments :
1. Pour générer ou récupérer l'identifiant de l'agent de service pour votre projet de produit de données, exécutez la commande Google Cloud CLI suivante :
```
gcloud beta services identity create --service=dataplex.googleapis.com --project=DATA_PRODUCT_PROJECT_ID
```
  Remplacez DATA_PRODUCT_PROJECT_ID par l'ID du projetGoogle Cloud où se trouve votre produit de données.
2. Dans chaque projet externe où résident vos éléments, attribuez à l'agent de service du projet de produit de données les rôles suivants :
  - Éditeur de données BigQuery (roles/bigquery.dataEditor) sur les tables et ensembles de données sous-jacents
  - Administrateur BigQuery Studio (roles/bigquery.studioAdmin) sur le projet d'asset

Pour générer de la documentation et des exemples de requêtes pour votre produit de données à l'aide des insights sur les données, procédez comme suit :

Dans le volet Ajouter des détails, dans la barre Générer des insights avec Gemini, cliquez sur Générer.

Attendez quelques minutes que le processus de génération d'insights se termine.
Pour examiner le contenu généré, cliquez sur Afficher.
Évaluez le contenu généré :
- Si le contenu est exact, cliquez sur Enregistrer. L'éditeur de texte enrichi est alors renseigné avec un modèle de documentation prédéfini, et des exemples de requêtes sont ajoutés à la section Insights.
- Si le contenu ne répond pas à vos attentes, cliquez sur Supprimer.
Cliquez sur Enregistrer pour finaliser.

Étapes suivantes

En savoir plus sur la gestion des produits de données
Découvrez comment rechercher des produits de données.
En tant que consommateur de données, découvrez comment demander l'accès à des produits de données.

Créer des produits de données Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Avant de commencer

Activer Gemini

Activer les API

Créer des éléments de données

Configurer des identités

Facultatif : Configurer Looker (Google Cloud Core) pour les produits de données

Rôles requis

Rôles requis pour les propriétaires de produits de données

Autorisations requises

Rôles requis pour les consommateurs de produits de données

Créer et configurer un produit de données

Créer un produit de données

Console

Terraform

C#

C#

Go

Go

Java

Java

Node.js

Node.js

Python

Python

REST

Facultatif : Ajouter des composants

Console

Terraform

C#

C#

Go

Go

Java

Java

Node.js

Node.js

Python

Python

REST

Facultatif : Configurer les groupes d'accès et les autorisations associées aux éléments

Configurer les groupes d'accès

Console

Terraform

C#

C#

Go

Go

Java

Java

Node.js

Node.js

Python

Python

REST

Configurer les autorisations des composants

Console

Terraform

C#

C#

Go

Go

Java

Java

Node.js

Node.js

Python

Python

REST

Facultatif : Ajouter des détails sur le contrat et l'aspect

Ajouter un contrat

Console

REST

Terraform

Ajouter des aspects

Console

REST

Terraform

Facultatif : ajoutez des détails supplémentaires

Ajouter manuellement de la documentation et des exemples de requêtes

Créer des produits de données