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

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).

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 composant de données est une étape facultative, mais fortement recommandée avant de créer votre premier produit de données.

Par défaut, la création d'un produit de données vous oblige à saisir manuellement les descriptions métier, les définitions techniques et la documentation d'intégration pour vos composants. 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 en fonction de la mise en page du schéma de l'asset, ce qui permet aux consommateurs de données de commencer immédiatement à interroger le produit une fois qu'il est approuvé.

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

Rôles requis pour activer les API

Pour activer les API, vous avez besoin du rôle IAM Administrateur Service Usage (roles/serviceusage.serviceUsageAdmin), qui contient l'autorisation serviceusage.services.enable. Découvrez comment attribuer des rôles.

Activer les API

Créer des composants de données

Assurez-vous que vos composants 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 de composants 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.

Rôles requis

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

Propriétaires de produits de données : utilisateurs qui créent, configurent et gèrent les produits de données et leurs composants 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, modifier, supprimer et gérer les autorisations, ainsi que pour 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)
Ajoutez 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 composants : Lecteur de catalogue Dataplex (roles/dataplex.catalogViewer)
Modifier les types d'aspect 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 pour la documentation automatisée et la génération d'insights : Administrateur Dataplex DataScan (roles/dataplex.dataScanAdmin)

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éez un produit de données : dataplex.dataProducts.create
Répertorier les produits de données dans un projet : dataplex.dataProducts.list
Obtenir ou afficher un produit de données : dataplex.dataProducts.get
Modifiez un produit de données existant : dataplex.dataProducts.update
Supprimer un produit de données : dataplex.dataProducts.delete
Approuver une demande d'accès à un 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éez une demande d'accès au produit de données : dataplex.dataProducts.get
Créez un composant de données : dataplex.dataAssets.create
Répertorier les composants de données d'un produit de données : dataplex.dataAssets.list
Obtenir un élément de données : dataplex.dataAssets.get
Modifiez un composant de données existant : dataplex.dataAssets.update
Supprimer l'élément de données : dataplex.dataAssets.delete
Créez une analyse des données : dataplex.datascans.create
Répertoriez toutes les analyses de données : dataplex.datascans.list
Effectuer une analyse des 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 détectable. Pour ce faire, accordez aux consommateurs de produits 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 consiste à définir des informations de base telles que le nom unique du produit de données, sa description, la région dans laquelle il est créé et les coordonnées.
Facultatif : Ajouter des composants

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

Pour obtenir la liste des composants compatibles, consultez Composants 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 servent d'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

À cette étape, vous améliorez la gouvernance et la détectabilité 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 calendrier 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 : Ajoutez des informations supplémentaires.

Dans cette dernière phase, vous ajoutez une documentation en texte enrichi, comme des guides d'intégration des utilisateurs, des définitions métier et des exemples de requêtes, pour aider les consommateurs à interagir avec le produit de données immédiatement aprè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 à "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 : 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éé. Parcourez la page, puis sélectionnez le projet.
- Région : sélectionnez la région ou la multirégion dans laquelle 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 : indiquez 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 qui sont chargés d'approuver les demandes d'accès ou les modifications.
- Libellés : ajoutez des libellés 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 la ressource google_dataplex_data_product.

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

provider = google-beta
}

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 : ID unique de votre produit de données
DISPLAY_NAME : nom convivial pour 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"]

C#

Avant d'essayer cet exemple, suivez les instructions de configuration pour C# du 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 du 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 du 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 du 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 du 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 de 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 des approbateurs désignés, séparées par une virgule, qui sont responsables de l'approbation des demandes d'accès ou des 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 : ID unique de votre produit de données

Facultatif : Ajouter des composants

Vous pouvez ajouter différents composants 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 composants compatibles, consultez Composants compatibles.

Console

Dans le volet Ajouter des composants, cliquez sur + Ajouter.
Recherchez et sélectionnez les composants que vous souhaitez ajouter à votre produit de données. Les composants 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 composants en cliquant dessus.
Pour affiner les résultats de recherche, utilisez Filtres.
Après avoir sélectionné les composants, cliquez sur Ajouter.

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

Terraform

Pour ajouter un composant 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"

provider = google-beta
}

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 : ID 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 : ID 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 composants

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

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

provider = google-beta
}

Remplacez les éléments suivants :

PROJECT_ID : ID de votre projet Google Cloud
LOCATION : région où existe le produit de données.
DATA_PRODUCT_ID : ID 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"]

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

PROJECT_ID : ID de votre projet Google Cloud
LOCATION : région où existe le produit de données
DATA_PRODUCT_ID : ID de votre produit de données

Configurer les autorisations sur les composants

Une fois que vous avez configuré les groupes d'accès, vous pouvez configurer les autorisations pour les composants du produit de données.

Console

Dans la section Autorisations des composants, sélectionnez le composant pour lequel vous souhaitez configurer les autorisations. Vous pouvez sélectionner et configurer les autorisations pour 10 composants 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 composant est une table BigQuery nommée Sales, que vous avez sélectionné le groupe d'accès Analyst et que vous lui avez attribué le rôle BigQuery Metadata Viewer, 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 attribuer plusieurs rôles à un composant.
Cliquez sur Configurer. Les autorisations attribuées à l'élément s'affichent.
Pour configurer les autorisations pour d'autres composants, répétez ces étapes.
Cliquez sur Continuer.

Terraform

Attribuez des rôles IAM à vos groupes d'accès pour des composants 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"]
}

provider = google-beta
}

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 : ID 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 composants 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ù existe le produit de données
DATA_PRODUCT_ID : ID de votre produit de données
DATA_ASSET_ID : ID du composant pour lequel vous souhaitez configurer les autorisations

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

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

Ajouter un contrat

Pour établir une base 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 le temps 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 un calendrier convenu pour la fréquence de mise à jour ou de livraison des données. Cela permet d'assurer un flux prévisible du producteur de données au consommateur de données. Exemple :Weekly
Dans le champ Heure d'actualisation, saisissez la durée maximale acceptable entre le moment où les données sont mises à jour à 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 livraison 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 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 du 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 diffusion 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 Google Cloud projet dans lequel 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 du produit de données. Pour gérer un contrat, vous devez gérer l'entrée Knowledge Catalog sous-jacente. Comme Terraform ne détecte 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"
    })
  }
}

provider = google-beta
}

Remplacez les éléments suivants :

DATA_PRODUCT_PROJECT_NUMBER : numéro du projet dans lequel se trouve la ressource du 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 commerciaux.

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 Google Cloud projet dans lequel 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 du 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. Étant donné que Terraform ne détecte pas automatiquement les aspects existants, vous devez d'abord importer le 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 = {}
  }
}

provider = google-beta
}

Remplacez les éléments suivants :

DATA_PRODUCT_PROJECT_NUMBER : numéro du projet dans lequel se trouve la ressource du 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 informations supplémentaires.

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

Vous pouvez créer cette documentation manuellement ou utiliser les insights sur les données 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 panneau Ajouter des informations supplémentaires, 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 à votre produit de données :

Dans le volet Ajouter des informations 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 Google Cloud projet dans lequel 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 du 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étecte 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"
    })
  }
}

provider = google-beta
}

Remplacez les éléments suivants :

DATA_PRODUCT_PROJECT_NUMBER : numéro du projet dans lequel se trouve la ressource du 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 de la documentation et des exemples de requêtes automatisés à l'aide d'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.
Attribuez 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ù réside le produit de données
Configurez les autorisations de l'agent de service inter-projets. Si vos composants 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 composants :
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 dans lequel réside votre produit de données.
2. Dans chaque projet externe où résident vos composants, accordez à 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 de l'élément

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

Dans le volet Ajouter des informations supplémentaires, sur 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 rempli 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 Annuler.
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 aux 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 composants de données

Configurer des identités

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 composants

Configurer les groupes d'accès

Console

Terraform

C#

C#

Go

Go

Java

Java

Node.js

Node.js

Python

Python

REST

Configurer les autorisations sur les 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 informations supplémentaires.

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

Console

Créer des produits de données