Rechercher les problèmes de qualité des données

Ce document explique comment utiliser BigQuery et Dataplex Universal Catalog pour vous assurer que les données répondent à vos attentes en termes de qualité. La qualité automatique des données de Dataplex Universal Catalog vous permet de définir et d'évaluer la qualité des données de vos tables BigQuery. Vous pouvez automatiser l'analyse des données, les valider par rapport à des règles définies et enregistrer des alertes si vos données ne répondent pas aux exigences de qualité.

Pour en savoir plus sur la qualité automatique des données, consultez la présentation de la qualité automatique des données.

Avant de commencer

Enable the Dataplex API.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the API
Facultatif : si vous souhaitez que Dataplex Universal Catalog génère des recommandations pour les règles de qualité des données en fonction des résultats d'une analyse de profilage des données, créez et exécutez l'analyse de profilage des données.

Rôles requis

Pour exécuter une analyse de la qualité des données sur une table BigQuery, vous devez disposer de l'autorisation de lire la table BigQuery et de créer un job BigQuery dans le projet utilisé pour analyser la table.

Remarque : Dataplex Universal Catalog ne crée pas de job BigQuery dans votre projet. Toutefois, vous avez besoin de cette autorisation pour créer un job DryRun afin de vérifier les autorisations pour la table.
Si la table BigQuery et l'analyse de la qualité des données se trouvent dans des projets différents, vous devez attribuer au compte de service Dataplex Universal Catalog du projet contenant l'analyse de la qualité des données l'autorisation de lecture pour la table BigQuery correspondante.

Remarque : Si vous n'avez créé aucune analyse de la qualité des données ni aucune analyse de profilage des données, ou si vous ne disposez d'aucun lac Dataplex Universal Catalog dans ce projet, créez un identifiant de service en exécutant la commande suivante : gcloud beta services identity create --service=dataplex.googleapis.com. Cette commande renvoie un identifiant de service Dataplex Universal Catalog s'il existe.
Si les règles de qualité des données font référence à d'autres tables, le compte de service du projet d'analyse doit disposer des autorisations de lecture sur ces mêmes tables.
Pour obtenir les autorisations nécessaires pour exporter les résultats de l'analyse vers une table BigQuery, demandez à votre administrateur d'accorder au compte de service Dataplex Universal Catalog le rôle IAM Éditeur de données BigQuery (roles/bigquery.dataEditor) sur l'ensemble de données et la table de résultats. Ces rôles comportent les autorisations suivantes :
- bigquery.datasets.get
- bigquery.tables.create
- bigquery.tables.get
- bigquery.tables.getData
- bigquery.tables.update
- bigquery.tables.updateData
Si les données BigQuery sont organisées dans un lac Dataplex Universal Catalog, accordez au compte de service Dataplex Universal Catalog les rôles IAM Lecteur de métadonnées Dataplex (roles/dataplex.metadataReader) et Lecteur Dataplex (roles/dataplex.viewer). Sinon, vous devez disposer de toutes les autorisations suivantes :
- dataplex.lakes.list
- dataplex.lakes.get
- dataplex.zones.list
- dataplex.zones.get
- dataplex.entities.list
- dataplex.entities.get
- dataplex.operations.get
Si vous analysez une table externe BigQuery à partir de Cloud Storage, accordez au compte de service Dataplex Universal Catalog le rôle Lecteur d'objets Storage (roles/storage.objectViewer) pour le bucket. Vous pouvez également attribuer les autorisations suivantes au compte de service Dataplex Universal Catalog :
- storage.buckets.get
- storage.objects.get
Si vous souhaitez publier les résultats de l'analyse de la qualité des données en tant que métadonnées Dataplex Universal Catalog, vous devez disposer du rôle IAM Éditeur de données BigQuery (roles/bigquery.dataEditor) pour la table et de l'autorisation dataplex.entryGroups.useDataQualityScorecardAspect sur le groupe d'entrées @bigquery au même emplacement que la table. Vous pouvez également vous voir attribuer le rôle Éditeur de catalogue Dataplex (roles/dataplex.catalogEditor) pour le groupe d'entrées @bigquery au même emplacement que la table.

Sinon, vous devez disposer de toutes les autorisations suivantes :
- bigquery.tables.update sur la table
- dataplex.entryGroups.useDataQualityScorecardAspect sur le groupe d'entrées @bigquery
Ou de toutes les autorisations suivantes :
- dataplex.entries.update sur le groupe d'entrées @bigquery
- dataplex.entryGroups.useDataQualityScorecardAspect sur le groupe d'entrées @bigquery
Si vous devez accéder à des colonnes protégées par des règles d'accès BigQuery au niveau des colonnes, attribuez les autorisations correspondantes au compte de service Dataplex Universal Catalog. L'utilisateur qui crée ou met à jour une analyse des données doit également disposer des autorisations pour les colonnes.
Si des règles d'accès BigQuery au niveau des lignes sont activées pour une table, vous ne pouvez analyser que les lignes visibles par le compte de service Dataplex Universal Catalog. Notez que les droits d'accès de chaque utilisateur ne sont pas évalués pour les règles au niveau des lignes.

Rôles requis pour l'analyse des données

Pour utiliser la qualité des données automatique, demandez à votre administrateur de vous accorder l'un des rôles IAM suivants :

Accès complet aux ressources DataScan : administrateur Dataplex DataScan (roles/dataplex.dataScanAdmin)
Pour créer des ressources DataScan : créateur Dataplex DataScan (roles/dataplex.dataScanCreator) sur le projet
Accès en écriture aux ressources DataScan : éditeur Dataplex DataScan (roles/dataplex.dataScanEditor)
Accès en lecture aux ressources DataScan, à l'exception des règles et des résultats : lecteur Dataplex DataScan (roles/dataplex.dataScanViewer)
Accès en lecture aux ressources DataScan, y compris les règles et les résultats : lecteur de données Dataplex DataScan (roles/dataplex.dataScanDataViewer)

Le tableau suivant liste les autorisations DataScan :

Nom de l'autorisation	Accorde l'autorisation d'effectuer les opérations suivantes :
`dataplex.datascans.create`	Créer un `DataScan`
`dataplex.datascans.delete`	Supprimer un `DataScan`
`dataplex.datascans.get`	Afficher les métadonnées opérationnelles telles que l'ID ou le calendrier, mais pas les résultats ni les règles
`dataplex.datascans.getData`	Afficher les détails du `DataScan`, y compris les règles et les résultats
`dataplex.datascans.list`	Lister les analyses `DataScan`
`dataplex.datascans.run`	Exécuter un `DataScan`
`dataplex.datascans.update`	Mettre à jour la description d'une analyse `DataScan`
`dataplex.datascans.getIamPolicy`	Afficher les autorisations IAM actuelles sur l'analyse
`dataplex.datascans.setIamPolicy`	Définir les autorisations IAM sur l'analyse

Créer une analyse de qualité des données

Console

Dans la console Google Cloud , sur la page Curation des métadonnées de BigQuery, accédez à l'onglet Qualité et profilage des données.

Accéder à la page "Qualité et profilage des données"
Cliquez sur Créer une analyse de la qualité des données.
Dans la fenêtre Définir l'analyse, renseignez les champs suivants :
1. Facultatif : Saisissez un nom à afficher.
2. Saisissez un ID. Consultez les conventions d'attribution de noms pour les ressources.
3. Facultatif : Saisissez une description.
4. Dans le champ Table, cliquez sur Parcourir. Choisissez la table à analyser, puis cliquez sur Sélectionner. Seules les tables BigQuery standards sont acceptées.
  
  Pour les tables des ensembles de données multirégionaux, choisissez une région dans laquelle créer l'analyse de données.
  
  Pour parcourir les tables organisées dans les lacs Dataplex Universal Catalog, cliquez sur Parcourir les lacs Dataplex.
5. Dans le champ Champ d'application, sélectionnez Incrémentiel ou Intégralité des données.
  - Si vous choisissez Incrémentiel : dans le champ Colonne de code temporel, sélectionnez une colonne de type DATE ou TIMESTAMP dans votre table BigQuery qui augmente à mesure que de nouveaux enregistrements sont ajoutés et qui permet d'identifier de nouveaux enregistrements. Il peut s'agir d'une colonne qui partitionne la table.
6. Pour filtrer vos données, cochez la case Filtrer les lignes. Fournissez un filtre de ligne constitué d'une expression SQL valide pouvant être utilisée dans une clause WHERE en syntaxe GoogleSQL. Exemple : col1 >= 0. Le filtre peut être une combinaison de plusieurs conditions de colonne. Par exemple, col1 >= 0 AND col2 < 10.
7. Pour échantillonner vos données, sélectionnez un pourcentage d'échantillonnage dans la liste Taille d'échantillonnage. Choisissez un pourcentage compris entre 0,0 et 100,0 %, avec un maximum de trois chiffres après la virgule. Pour les ensembles de données plus volumineux, choisissez un pourcentage d'échantillonnage plus faible. Par exemple, pour une table de 1 Po, si vous saisissez une valeur comprise entre 0,1 et 1 %, l'analyse de la qualité des données échantillonne entre 1 et 10 To de données. Pour les analyses de données incrémentielles, l'analyse de la qualité des données applique l'échantillonnage au dernier incrément.
8. Pour publier les résultats de l'analyse de la qualité des données en tant que métadonnées Dataplex Universal Catalog, cochez la case Publier les résultats dans Dataplex Catalog.
  
  Vous pouvez consulter les derniers résultats de l'analyse dans l'onglet Qualité des données des pages BigQuery et Dataplex Universal Catalog pour la table source. Pour permettre aux utilisateurs d'accéder aux résultats d'analyse publiés, consultez la section Accorder l'accès aux résultats d'analyse de la qualité des données de ce document.
9. Dans la section Planification, choisissez l'une des options suivantes :
  - Répétition : exécutez l'analyse de la qualité des données selon une planification horaire, quotidienne, hebdomadaire, mensuelle ou personnalisée. Spécifiez la fréquence et l'heure d'exécution de l'analyse. Si vous choisissez "Personnalisée", utilisez le format cron pour spécifier la planification.
  - À la demande : exécutez l'analyse de la qualité des données à la demande.
  - Ponctuelle : exécutez l'analyse de la qualité des données une seule fois maintenant, puis supprimez-la après la période de durée de vie.
  - Durée de vie : la durée de vie est le laps de temps entre l'exécution et la suppression de l'analyse. Une analyse de la qualité des données sans durée de vie spécifiée est automatiquement supprimée 24 heures après son exécution. La durée de vie peut être comprise entre 0 seconde (suppression immédiate) et 365 jours.
10. Cliquez sur Continuer.
Dans la fenêtre Règles sur la qualité des données, définissez les règles à configurer pour cette analyse de la qualité des données.
1. Cliquez sur Ajouter des règles, puis sélectionnez l'une des options suivantes.
  - Recommandations basées sur les profils : créez des règles à partir des recommandations basées sur une analyse de profilage des données existante.
    1. Sélectionner des colonnes : sélectionnez les colonnes pour lesquelles vous souhaitez obtenir des règles recommandées.
    2. Sélectionner un projet d'analyse : si l'analyse de profilage des données se trouve dans un projet différent de celui dans lequel vous créez l'analyse de la qualité des données, sélectionnez le projet à partir duquel extraire les analyses de profilage.
    3. Sélectionner des résultats de profil : sélectionnez un ou plusieurs résultats de profil, puis cliquez sur OK. Une liste de règles suggérées s'affiche. Vous pouvez l'utiliser comme point de départ.
    4. Cochez les cases correspondant aux règles que vous souhaitez ajouter, puis cliquez sur Sélectionner. Une fois sélectionnées, les règles sont ajoutées à votre liste de règles actuelle. Vous pouvez ensuite modifier les règles.
  - Types de règles intégrés : créez des règles à partir de règles prédéfinies. Consultez la liste des règles prédéfinies.
    1. Sélectionner des colonnes : sélectionnez les colonnes pour lesquelles vous souhaitez sélectionner des règles.
    2. Choisir les types de règles : sélectionnez les types de règles que vous souhaitez choisir, puis cliquez sur OK. Les types de règles qui s'affichent dépendent des colonnes que vous avez sélectionnées.
    3. Cochez les cases correspondant aux règles que vous souhaitez ajouter, puis cliquez sur Sélectionner. Une fois sélectionnées, les règles sont ajoutées à votre liste de règles actuelle. Vous pouvez ensuite modifier les règles.
  - Règle de vérification des lignes SQL : créez une règle SQL personnalisée à appliquer à chaque ligne.
    1. Dans Dimension, choisissez une dimension.
    2. Dans Seuil de réussite, choisissez le pourcentage d'enregistrements qui doivent réussir le contrôle.
    3. Dans Nom de la colonne, sélectionnez une colonne.
    4. Dans le champ Fournissez une expression SQL, saisissez une expression SQL qui renvoie la valeur booléenne true (succès) ou false (échec). Pour en savoir plus, consultez Types de règles SQL personnalisées compatibles et les exemples de la section Définir des règles de qualité des données.
    5. Cliquez sur Ajouter.
  - Règle de vérification des agrégations SQL : créez une règle de condition de table SQL personnalisée.
    1. Dans Dimension, choisissez une dimension.
    2. Dans Nom de la colonne, sélectionnez une colonne.
    3. Dans le champ Fournissez une expression SQL, saisissez une expression SQL qui renvoie la valeur booléenne true (succès) ou false (échec). Pour en savoir plus, consultez Types de règles SQL personnalisées compatibles et les exemples de la section Définir des règles de qualité des données.
    4. Cliquez sur Ajouter.
  - Règle d'assertion SQL : créez une règle d'assertion SQL personnalisée pour vérifier si les données sont dans un état non valide.
    1. Dans Dimension, choisissez une dimension.
    2. Facultatif : dans Nom de la colonne, sélectionnez une colonne.
    3. Dans le champ Fournissez une instruction SQL, saisissez une instruction SQL qui renvoie les lignes correspondant à l'état non valide. Si des lignes sont renvoyées, cette règle échoue. Omettez le point-virgule de fin de l'instruction SQL. Pour en savoir plus, consultez Types de règles SQL personnalisées compatibles et les exemples de la section Définir des règles de qualité des données.
    4. Cliquez sur Ajouter.
2. Facultatif : Pour toute règle de qualité des données, vous pouvez attribuer un nom personnalisé à utiliser pour la surveillance et les alertes, ainsi qu'une description. Pour ce faire, modifiez une règle et spécifiez les informations suivantes :
  - Nom de la règle : saisissez un nom de règle personnalisé de 63 caractères maximum. Le nom de la règle peut inclure des lettres (a-z, A-Z), des chiffres (0-9) et des traits d'union (-). Il doit commencer par une lettre et se terminer par un chiffre ou une lettre.
  - Description : saisissez une description de la règle de 1 024 caractères maximum.
3. Répétez les étapes précédentes pour ajouter d'autres règles à l'analyse de la qualité des données. Lorsque vous avez terminé, cliquez sur Continuer.
Facultatif : Exportez les résultats de l'analyse vers une table BigQuery standard. Dans la section Exporter les résultats d'analyse dans une table BigQuery, procédez comme suit :
1. Dans le champ Sélectionnez un ensemble de données BigQuery, cliquez sur Parcourir. Sélectionnez un ensemble de données BigQuery dans lequel stocker les résultats de l'analyse de la qualité des données.
2. Dans le champ Table BigQuery, spécifiez la table dans laquelle stocker les résultats de l'analyse de la qualité des données. Si vous utilisez une table existante, assurez-vous qu'elle est compatible avec le schéma de la table d'exportation. Si la table spécifiée n'existe pas, Dataplex Universal Catalog la crée pour vous.
  
  Remarque : Vous pouvez utiliser la même table de résultats pour plusieurs analyses de qualité des données.
Facultatif : Ajoutez des étiquettes. Les étiquettes sont des paires clé/valeur qui vous permettent de regrouper des objets associés ou de les combiner à d'autres Google Cloud ressources.
Facultatif : Configurez des rapports de notification par e-mail pour informer les utilisateurs de l'état et des résultats d'un job d'analyse de la qualité des données. Dans la section Rapport de notification, cliquez sur Ajouter un ID d'adresse e-mail et saisissez jusqu'à cinq adresses e-mail. Sélectionnez ensuite les scénarios pour lesquels vous souhaitez envoyer des rapports :
- Niveau de qualité (<=) : envoie un rapport lorsqu'un job réussit avec un niveau de qualité des données inférieur au niveau cible spécifié. Saisissez un score de qualité cible compris entre 0 et 100.
- Échecs de jobs : envoie un rapport en cas d'échec du job lui-même, quels que soient les résultats de la qualité des données.
- Achèvement de jobs (réussite ou échec) : envoie un rapport à la fin du job, quels que soient les résultats de la qualité des données.
Cliquez sur Créer.

Une fois l'analyse créée, vous pouvez l'exécuter à tout moment en cliquant sur Exécuter maintenant.

gcloud

Pour créer une analyse de la qualité des données, utilisez la commande gcloud dataplex datascans create data-quality.

Si les données source sont organisées dans un lac Dataplex Universal Catalog, incluez l'indicateur --data-source-entity :

gcloud dataplex datascans create data-quality DATASCAN \
    --location=LOCATION \
    --data-quality-spec-file=DATA_QUALITY_SPEC_FILE \
    --data-source-entity=DATA_SOURCE_ENTITY

Si les données source ne sont pas organisées dans un lac Dataplex Universal Catalog, incluez l'indicateur --data-source-resource :

gcloud dataplex datascans create data-quality DATASCAN \
    --location=LOCATION \
    --data-quality-spec-file=DATA_QUALITY_SPEC_FILE \
    --data-source-resource=DATA_SOURCE_RESOURCE

Remplacez les variables suivantes :

DATASCAN : nom de l'analyse de la qualité des données.
LOCATION : région Google Cloud dans laquelle créer l'analyse de la qualité des données.
DATA_QUALITY_SPEC_FILE : chemin d'accès au fichier JSON ou YAML contenant les spécifications de l'analyse de la qualité des données. Il peut s'agir d'un fichier local ou d'un chemin d'accès Cloud Storage avec le préfixe gs://. Utilisez ce fichier pour spécifier les règles de qualité des données pour l'analyse. Vous pouvez également spécifier des informations supplémentaires dans ce fichier, telles que des filtres, un pourcentage d'échantillonnage et des actions post-analyse (par exemple, l'exportation vers BigQuery ou l'envoi de rapports de notification par e-mail). Consultez la documentation sur la représentation JSON et l'exemple de représentation YAML.
DATA_SOURCE_ENTITY : entité Dataplex Universal Catalog contenant les données pour l'analyse de la qualité des données. Exemple : projects/test-project/locations/test-location/lakes/test-lake/zones/test-zone/entities/test-entity.
DATA_SOURCE_RESOURCE : nom de la ressource contenant les données pour l'analyse de la qualité des données. Exemple : //bigquery.googleapis.com/projects/test-project/datasets/test-dataset/tables/test-table.

C#

Pour vous authentifier auprès de BigQuery, configurez le service 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 GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for CreateDataScan</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 CreateDataScanRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        CreateDataScanRequest request = new CreateDataScanRequest
        {
            ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
            DataScan = new DataScan(),
            DataScanId = "",
            ValidateOnly = false,
        };
        // Make the request
        Operation<DataScan, OperationMetadata> response = dataScanServiceClient.CreateDataScan(request);

        // Poll until the returned long-running operation is complete
        Operation<DataScan, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        DataScan 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<DataScan, OperationMetadata> retrievedResponse = dataScanServiceClient.PollOnceCreateDataScan(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            DataScan retrievedResult = retrievedResponse.Result;
        }
    }
}

Go


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.NewDataScanClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

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

public class SyncCreateDataScan {

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

  public static void syncCreateDataScan() 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 (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      CreateDataScanRequest request =
          CreateDataScanRequest.newBuilder()
              .setParent(LocationName.of("[PROJECT]", "[LOCATION]").toString())
              .setDataScan(DataScan.newBuilder().build())
              .setDataScanId("dataScanId1260787906")
              .setValidateOnly(true)
              .build();
      DataScan response = dataScanServiceClient.createDataScanAsync(request).get();
    }
  }
}

Node.js

// Copyright 2026 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// ** This file is automatically generated by gapic-generator-typescript. **
// ** https://github.com/googleapis/gapic-generator-typescript **
// ** All changes to this file may be overwritten. **



'use strict';

function main(parent, dataScan, dataScanId) {
  /**
   * 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 resource name of the parent location:
   *  `projects/{project}/locations/{location_id}`
   *  where `project` refers to a *project_id* or *project_number* and
   *  `location_id` refers to a Google Cloud region.
   */
  // const parent = 'abc123'
  /**
   *  Required. DataScan resource.
   */
  // const dataScan = {}
  /**
   *  Required. DataScan identifier.
   *  * Must contain only lowercase letters, numbers and hyphens.
   *  * Must start with a letter.
   *  * Must end with a number or a letter.
   *  * Must be between 1-63 characters.
   *  * Must be unique within the customer project / location.
   */
  // const dataScanId = 'abc123'
  /**
   *  Optional. Only validate the request, but do not perform mutations.
   *  The default is `false`.
   */
  // const validateOnly = true

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

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

  async function callCreateDataScan() {
    // Construct request
    const request = {
      parent,
      dataScan,
      dataScanId,
    };

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

  callCreateDataScan();
}

process.on('unhandledRejection', err => {
  console.error(err.message);
  process.exitCode = 1;
});
main(...process.argv.slice(2));

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

    # Initialize request argument(s)
    data_scan = dataplex_v1.DataScan()
    data_scan.data_quality_spec.rules.dimension = "dimension_value"
    data_scan.data.entity = "entity_value"

    request = dataplex_v1.CreateDataScanRequest(
        parent="parent_value",
        data_scan=data_scan,
        data_scan_id="data_scan_id_value",
    )

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

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

    response = operation.result()

    # Handle the response
    print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the create_data_scan call in the DataScanService service
#
# 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/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::DataScanService::Client#create_data_scan.
#
def create_data_scan
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::CreateDataScanRequest.new

  # Call the create_data_scan method.
  result = client.create_data_scan request

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

REST

Pour créer une analyse de la qualité des données, utilisez la méthode dataScans.create.

La requête suivante crée une analyse ponctuelle de la qualité des données :

POST https://dataplex.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/dataScans?data_scan_id=DATASCAN_ID

{
"data": {
  "resource": "//bigquery.googleapis.com/projects/PROJECT_ID/datasets/DATASET_ID/tables/TABLE_ID"
},
"type": "DATA_QUALITY",
"executionSpec": {
  "trigger": {
    "oneTime": {
      "ttl_after_scan_completion": "120s"
    }
  }
},
"dataQualitySpec": {
  "rules": [
    {
      "nonNullExpectation": {},
      "column": "COLUMN_NAME",
      "dimension": "DIMENSION",
      "threshold": 1
    }
  ]
}
}

Remplacez les éléments suivants :

PROJECT_ID : ID de votre projet
LOCATION : région dans laquelle créer l'analyse de la qualité des données.
DATASCAN_ID : ID de l'analyse de la qualité des données.
DATASET_ID : ID de l'ensemble de données BigQuery.
TABLE_ID : ID de la table BigQuery.
COLUMN_NAME : nom de la colonne pour la règle.
DIMENSION : dimension de la règle, par exemple VALIDITY.

Si vous souhaitez créer des règles pour l'analyse de la qualité des données à l'aide de recommandations de règles basées sur les résultats d'une analyse de profilage des données, obtenez les recommandations en appelant la méthode dataScans.jobs.generateDataQualityRules sur l'analyse de profilage des données.

Remarque : Si votre table BigQuery est configurée avec l'option Demander un filtre de partitionnement définie sur true, utilisez la colonne de partition BigQuery comme filtre de ligne ou colonne de code temporel pour l'analyse de la qualité des données.

Exécuter une analyse de la qualité des données

Console

Dans la console Google Cloud , sur la page Curation des métadonnées de BigQuery, accédez à l'onglet Qualité et profilage des données.

Accéder à la page "Qualité et profilage des données"
Cliquez sur l'analyse de la qualité des données à exécuter.
Cliquez sur Exécuter maintenant.

gcloud

Pour exécuter une analyse de la qualité des données, utilisez la commande gcloud dataplex datascans run :

gcloud dataplex datascans run DATASCAN \
--location=LOCATION \

Remplacez les variables suivantes :

LOCATION : région Google Cloud dans laquelle l'analyse de la qualité des données a été créée.
DATASCAN : nom de l'analyse de la qualité des données.

C#

using Google.Cloud.Dataplex.V1;

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for RunDataScan</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 RunDataScanRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        RunDataScanRequest request = new RunDataScanRequest
        {
            DataScanName = DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
        };
        // Make the request
        RunDataScanResponse response = dataScanServiceClient.RunDataScan(request);
    }
}

Go


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.NewDataScanClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

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

Java

import com.google.cloud.dataplex.v1.DataScanName;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.RunDataScanRequest;
import com.google.cloud.dataplex.v1.RunDataScanResponse;

public class SyncRunDataScan {

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

  public static void syncRunDataScan() 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 (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      RunDataScanRequest request =
          RunDataScanRequest.newBuilder()
              .setName(DataScanName.of("[PROJECT]", "[LOCATION]", "[DATASCAN]").toString())
              .build();
      RunDataScanResponse response = dataScanServiceClient.runDataScan(request);
    }
  }
}

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

    # Initialize request argument(s)
    request = dataplex_v1.RunDataScanRequest(
        name="name_value",
    )

    # Make the request
    response = client.run_data_scan(request=request)

    # Handle the response
    print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the run_data_scan call in the DataScanService service
#
# 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/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::DataScanService::Client#run_data_scan.
#
def run_data_scan
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::RunDataScanRequest.new

  # Call the run_data_scan method.
  result = client.run_data_scan request

  # The returned object is of type Google::Cloud::Dataplex::V1::RunDataScanResponse.
  p result
end

REST

Pour exécuter une analyse de la qualité des données, utilisez la méthode dataScans.run :

Afficher les résultats d'analyse de qualité des données

Console

Dans la console Google Cloud , sur la page Curation des métadonnées de BigQuery, accédez à l'onglet Qualité et profilage des données.

Accéder à la page "Qualité et profilage des données"
Cliquez sur le nom d'une analyse de la qualité des données.
- La section Présentation affiche des informations sur les jobs les plus récents, y compris la date d'exécution de l'analyse, le nombre d'enregistrements analysés dans chaque job, si tous les contrôles de qualité des données ont réussi, et s'il y a eu des échecs, le nombre de contrôles de qualité des données qui ont échoué.
- La section Configuration de l'analyse de la qualité des données affiche des informations sur l'analyse.
Pour afficher des informations détaillées sur un job, comme les scores de qualité des données qui indiquent le pourcentage de règles réussies, les règles qui ont échoué et les journaux de job, cliquez sur l'onglet Historique des jobs. Cliquez ensuite sur un ID de job.

gcloud

Pour afficher les résultats d'un job d'analyse de la qualité des données, utilisez la commande gcloud dataplex datascans jobs describe :

gcloud dataplex datascans jobs describe JOB \
--location=LOCATION \
--datascan=DATASCAN \
--view=FULL

Remplacez les variables suivantes :

JOB : ID du job d'analyse de la qualité des données.
LOCATION : région Google Cloud dans laquelle l'analyse de la qualité des données a été créée.
DATASCAN : nom de l'analyse de la qualité des données à laquelle appartient le job.
--view=FULL : pour afficher le résultat du job d'analyse, spécifiez FULL.

C#

using Google.Cloud.Dataplex.V1;

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for GetDataScan</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 GetDataScanRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        GetDataScanRequest request = new GetDataScanRequest
        {
            DataScanName = DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
            View = GetDataScanRequest.Types.DataScanView.Unspecified,
        };
        // Make the request
        DataScan response = dataScanServiceClient.GetDataScan(request);
    }
}

Go


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.NewDataScanClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

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

Java

import com.google.cloud.dataplex.v1.DataScan;
import com.google.cloud.dataplex.v1.DataScanName;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.GetDataScanRequest;

public class SyncGetDataScan {

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

  public static void syncGetDataScan() 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 (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      GetDataScanRequest request =
          GetDataScanRequest.newBuilder()
              .setName(DataScanName.of("[PROJECT]", "[LOCATION]", "[DATASCAN]").toString())
              .build();
      DataScan response = dataScanServiceClient.getDataScan(request);
    }
  }
}

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

    # Initialize request argument(s)
    request = dataplex_v1.GetDataScanRequest(
        name="name_value",
    )

    # Make the request
    response = client.get_data_scan(request=request)

    # Handle the response
    print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the get_data_scan call in the DataScanService service
#
# 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/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::DataScanService::Client#get_data_scan.
#
def get_data_scan
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::GetDataScanRequest.new

  # Call the get_data_scan method.
  result = client.get_data_scan request

  # The returned object is of type Google::Cloud::Dataplex::V1::DataScan.
  p result
end

REST

Pour afficher les résultats d'une analyse de la qualité des données, utilisez la méthode dataScans.get.

Afficher les résultats publiés

Si les résultats de l'analyse de la qualité des données sont publiés en tant que métadonnées Dataplex Universal Catalog, vous pouvez consulter les derniers résultats de l'analyse sur les pages BigQuery et Dataplex Universal Catalog de la consoleGoogle Cloud , dans l'onglet Qualité des données de la table source.

Dans la console Google Cloud , accédez à la page BigQuery.

Accéder à BigQuery
Dans le volet de gauche, cliquez sur Explorateur :

Si le volet de gauche n'apparaît pas, cliquez sur Développer le volet de gauche pour l'ouvrir.
Dans le volet Explorateur, cliquez sur Ensembles de données, puis sur votre ensemble de données.
Cliquez sur Présentation > Tables, puis sélectionnez la table dont vous souhaitez consulter les résultats de l'analyse de la qualité des données.
Cliquez sur l'onglet Qualité des données.

Les derniers résultats publiés s'affichent.

Remarque : Les résultats publiés peuvent ne pas être disponibles si une analyse est en cours d'exécution pour la première fois.

Afficher l'historique des résultats d'analyse

Dataplex Universal Catalog enregistre l'historique des analyses de la qualité des données des 300 derniers jobs ou de l'année écoulée, selon la première échéance.

Console

Dans la console Google Cloud , sur la page Curation des métadonnées de BigQuery, accédez à l'onglet Qualité et profilage des données.

Accéder à la page "Qualité et profilage des données"
Cliquez sur le nom d'une analyse de la qualité des données.
Cliquez sur l'onglet Historique des jobs.

L'onglet Historique des jobs fournit des informations sur les jobs passés, comme le nombre d'enregistrements analysés dans chaque job, l'état du job, l'heure à laquelle le job a été exécuté, et la réussite ou l'échec de chaque règle.
Pour afficher des informations détaillées sur un job, cliquez sur l'un des jobs de la colonne Job ID.

gcloud

Pour afficher l'historique des jobs d'analyse de qualité des données, utilisez la commande gcloud dataplex datascans jobs list :

gcloud dataplex datascans jobs list \
--location=LOCATION \
--datascan=DATASCAN \

Remplacez les variables suivantes :

LOCATION : région Google Cloud dans laquelle l'analyse de la qualité des données a été créée.
DATASCAN : nom de l'analyse de la qualité des données pour laquelle afficher les jobs historiques.

C#

using Google.Api.Gax;
using Google.Cloud.Dataplex.V1;
using System;

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for ListDataScanJobs</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 ListDataScanJobsRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        ListDataScanJobsRequest request = new ListDataScanJobsRequest
        {
            ParentAsDataScanName = DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
            Filter = "",
        };
        // Make the request
        PagedEnumerable<ListDataScanJobsResponse, DataScanJob> response = dataScanServiceClient.ListDataScanJobs(request);

        // Iterate over all response items, lazily performing RPCs as required
        foreach (DataScanJob item in response)
        {
            // Do something with each item
            Console.WriteLine(item);
        }

        // Or iterate over pages (of server-defined size), performing one RPC per page
        foreach (ListDataScanJobsResponse page in response.AsRawResponses())
        {
            // Do something with each page of items
            Console.WriteLine("A page of results:");
            foreach (DataScanJob item in page)
            {
                // Do something with each item
                Console.WriteLine(item);
            }
        }

        // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
        int pageSize = 10;
        Page<DataScanJob> singlePage = response.ReadPage(pageSize);
        // Do something with the page of items
        Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
        foreach (DataScanJob item in singlePage)
        {
            // Do something with each item
            Console.WriteLine(item);
        }
        // Store the pageToken, for when the next page is required.
        string nextPageToken = singlePage.NextPageToken;
    }
}

Go


package main

import (
	"context"

	dataplex "cloud.google.com/go/dataplex/apiv1"
	dataplexpb "cloud.google.com/go/dataplex/apiv1/dataplexpb"
	"google.golang.org/api/iterator"
)

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.NewDataScanClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

	req := &dataplexpb.ListDataScanJobsRequest{
		// TODO: Fill request struct fields.
		// See https://pkg.go.dev/cloud.google.com/go/dataplex/apiv1/dataplexpb#ListDataScanJobsRequest.
	}
	it := c.ListDataScanJobs(ctx, req)
	for {
		resp, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			// TODO: Handle error.
		}
		// TODO: Use resp.
		_ = resp

		// If you need to access the underlying RPC response,
		// you can do so by casting the `Response` as below.
		// Otherwise, remove this line. Only populated after
		// first call to Next(). Not safe for concurrent access.
		_ = it.Response.(*dataplexpb.ListDataScanJobsResponse)
	}
}

Java

import com.google.cloud.dataplex.v1.DataScanJob;
import com.google.cloud.dataplex.v1.DataScanName;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.ListDataScanJobsRequest;

public class SyncListDataScanJobs {

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

  public static void syncListDataScanJobs() 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 (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      ListDataScanJobsRequest request =
          ListDataScanJobsRequest.newBuilder()
              .setParent(DataScanName.of("[PROJECT]", "[LOCATION]", "[DATASCAN]").toString())
              .setPageSize(883849137)
              .setPageToken("pageToken873572522")
              .setFilter("filter-1274492040")
              .build();
      for (DataScanJob element : dataScanServiceClient.listDataScanJobs(request).iterateAll()) {
        // doThingsWith(element);
      }
    }
  }
}

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

    # Initialize request argument(s)
    request = dataplex_v1.ListDataScanJobsRequest(
        parent="parent_value",
    )

    # Make the request
    page_result = client.list_data_scan_jobs(request=request)

    # Handle the response
    for response in page_result:
        print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the list_data_scan_jobs call in the DataScanService service
#
# 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/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::DataScanService::Client#list_data_scan_jobs.
#
def list_data_scan_jobs
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::ListDataScanJobsRequest.new

  # Call the list_data_scan_jobs method.
  result = client.list_data_scan_jobs request

  # The returned object is of type Gapic::PagedEnumerable. You can iterate
  # over elements, and API calls will be issued to fetch pages as needed.
  result.each do |item|
    # Each element is of type ::Google::Cloud::Dataplex::V1::DataScanJob.
    p item
  end
end

REST

Pour afficher l'historique des jobs d'analyse de la qualité des données, utilisez la méthode dataScans.jobs.list.

Accorder l'accès aux résultats d'analyse de la qualité des données

Pour permettre aux utilisateurs de votre organisation d'afficher les résultats d'analyse, procédez comme suit :

Dans la console Google Cloud , sur la page Curation des métadonnées de BigQuery, accédez à l'onglet Qualité et profilage des données.

Accéder à la page "Qualité et profilage des données"
Cliquez sur l'analyse de la qualité des données dont vous souhaitez partager les résultats.
Cliquez sur l'onglet Autorisations.
Procédez comme suit :
- Pour accorder l'accès à un compte principal, cliquez sur Accorder l'accès. Accordez le rôle Lecteur de données Dataplex DataScan au compte principal associé.
- Pour supprimer l'accès d'un compte principal, sélectionnez le compte principal pour lequel vous souhaitez supprimer le rôle Lecteur de données Dataplex DataScan. Cliquez sur > Supprimer l'accès, puis confirmez lorsque vous y êtes invité.

Résoudre un échec de qualité des données

Vous pouvez définir des alertes pour les échecs de qualité des données à l'aide des journaux dans Cloud Logging. Pour en savoir plus, y compris sur les exemples de requêtes, consultez Définir des alertes dans Cloud Logging.

Pour chaque job avec des règles au niveau des lignes qui échouent, Dataplex Universal Catalog fournit une requête permettant d'obtenir les enregistrements ayant échoué. Exécutez cette requête pour afficher les enregistrements qui ne correspondaient pas à votre règle.

Console

Dans la console Google Cloud , sur la page Curation des métadonnées de BigQuery, accédez à l'onglet Qualité et profilage des données.

Accéder à la page "Qualité et profilage des données"
Cliquez sur le nom de l'analyse de la qualité des données dont vous souhaitez résoudre les enregistrements ayant échoué.
Cliquez sur l'onglet Historique des jobs.
Cliquez sur l'ID du job qui a identifié des échecs de qualité des données.
Dans la fenêtre des résultats du job qui s'ouvre, dans la section Règles, recherchez la colonne Requête d'obtention des enregistrements ayant échoué. Cliquez sur Copier la requête dans le presse-papiers pour la règle ayant échoué.
Exécutez la requête dans BigQuery pour afficher les enregistrements qui ont entraîné l'échec du job.

gcloud

Non compatible

REST

Pour obtenir le job qui a identifié des échecs de qualité des données, utilisez la méthode dataScans.get.

Dans l'objet de réponse, le champ failingRowsQuery affiche la requête.
Exécutez la requête dans BigQuery pour afficher les enregistrements qui ont entraîné l'échec du job.

Gérer les analyses de qualité des données pour une table spécifique

Les étapes décrites dans ce document expliquent comment gérer les analyses de qualité des données dans votre projet à l'aide de la page Curation des métadonnées > Profilage et qualité des données de BigQuery dans la consoleGoogle Cloud .

Vous pouvez également créer et gérer des analyses de la qualité des données lorsque vous travaillez avec une table spécifique. Dans la console Google Cloud , sur la page BigQuery de la table, utilisez l'onglet Qualité des données. Procédez comme suit :

Dans la console Google Cloud , accédez à la page BigQuery.

Accéder à BigQuery

Dans le volet Explorateur (à gauche), cliquez sur Ensembles de données, puis sur votre ensemble de données. Cliquez sur Présentation > Tables, puis sélectionnez la table dont vous souhaitez consulter les résultats de l'analyse de la qualité des données.
Cliquez sur l'onglet Qualité des données.
Selon que la table dispose ou non d'une analyse de la qualité des données dont les résultats sont publiés en tant que métadonnées Dataplex Universal Catalog, vous pouvez travailler avec les analyses de la qualité des données de la table de différentes manières :
- Les résultats de l'analyse de la qualité des données sont publiés : les derniers résultats de l'analyse s'affichent sur la page.
  
  Pour gérer les analyses de la qualité des données pour cette table, cliquez sur Analyse de la qualité des données, puis sélectionnez l'une des options suivantes :
  - Créer une analyse : créez une analyse de la qualité des données. Pour en savoir plus, consultez la section Créer une analyse de la qualité des données de ce document. Lorsque vous créez une analyse à partir de la page d'informations d'une table, celle-ci est présélectionnée.
  - Exécuter : exécutez l'analyse.
  - Modifier la configuration de l'analyse : modifiez les paramètres, y compris le nom à afficher, les filtres et la planification.
    
    Pour modifier les règles sur la qualité des données, cliquez sur l'onglet Qualité des données, puis sur l'onglet Règles. Cliquez sur Modifier les règles. Modifiez les règles, puis cliquez sur Enregistrer.
  - Gérer les autorisations d'analyse : contrôlez qui peut accéder aux résultats de l'analyse. Pour en savoir plus, consultez la section Accorder l'accès aux résultats de l'analyse de la qualité des données de ce document.
  - Afficher l'historique des résultats : affichez des informations détaillées sur les jobs d'analyse de la qualité des données précédents. Pour en savoir plus, consultez les sections Afficher les résultats d'analyse de la qualité des données et Afficher l'historique des résultats d'analyse de ce document.
  - Afficher toutes les analyses : affichez la liste des analyses de qualité des données qui s'appliquent à cette table.
- Les résultats de l'analyse de la qualité des données ne sont pas publiés : sélectionnez l'une des options ci-dessous.
  - Créer une analyse de la qualité des données : créez une analyse de la qualité des données. Pour en savoir plus, consultez la section Créer une analyse de la qualité des données de ce document. Lorsque vous créez une analyse à partir de la page d'informations d'une table, celle-ci est présélectionnée.
  - Afficher les analyses existantes : affichez la liste des analyses de qualité des données qui s'appliquent à cette table.

Afficher les analyses de qualité des données pour une table

Pour afficher les analyses de qualité des données qui s'appliquent à une table spécifique, procédez comme suit :

Dans la console Google Cloud , sur la page Curation des métadonnées de BigQuery, accédez à l'onglet Qualité et profilage des données.

Accéder à la page "Qualité et profilage des données"
Filtrez la liste par nom de table et type d'analyse.

Mettre à jour une analyse de la qualité des données

Vous pouvez modifier différents paramètres d'une analyse de la qualité des données existante, comme le nom à afficher, les filtres, la planification et les règles de qualité des données.

Console

Dans la console Google Cloud , sur la page Curation des métadonnées de BigQuery, accédez à l'onglet Qualité et profilage des données.

Accéder à la page "Qualité et profilage des données"
Cliquez sur le nom d'une analyse de la qualité des données.
Pour modifier les paramètres, y compris le nom à afficher, les filtres et la planification, cliquez sur Modifier. Modifiez les valeurs, puis cliquez sur Enregistrer.
Pour modifier les règles sur la qualité des données, cliquez sur l'onglet Règles actuelles sur la page des détails de l'analyse. Cliquez sur Modifier les règles. Modifiez les règles, puis cliquez sur Enregistrer.

gcloud

Pour modifier la description d'une analyse de la qualité des données, utilisez la commande gcloud dataplex datascans update data-quality :

gcloud dataplex datascans update data-quality DATASCAN \
--location=LOCATION \
--description=DESCRIPTION

Remplacez les éléments suivants :

DATASCAN : nom de l'analyse de la qualité des données à mettre à jour.
LOCATION : région Google Cloud dans laquelle l'analyse de la qualité des données a été créée.
DESCRIPTION : nouvelle description de l'analyse de la qualité des données.

C#

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

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for UpdateDataScan</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 UpdateDataScanRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        UpdateDataScanRequest request = new UpdateDataScanRequest
        {
            DataScan = new DataScan(),
            UpdateMask = new FieldMask(),
            ValidateOnly = false,
        };
        // Make the request
        Operation<DataScan, OperationMetadata> response = dataScanServiceClient.UpdateDataScan(request);

        // Poll until the returned long-running operation is complete
        Operation<DataScan, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        DataScan 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<DataScan, OperationMetadata> retrievedResponse = dataScanServiceClient.PollOnceUpdateDataScan(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            DataScan retrievedResult = retrievedResponse.Result;
        }
    }
}

Go


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.NewDataScanClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

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

public class SyncUpdateDataScan {

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

  public static void syncUpdateDataScan() 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 (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      UpdateDataScanRequest request =
          UpdateDataScanRequest.newBuilder()
              .setDataScan(DataScan.newBuilder().build())
              .setUpdateMask(FieldMask.newBuilder().build())
              .setValidateOnly(true)
              .build();
      DataScan response = dataScanServiceClient.updateDataScanAsync(request).get();
    }
  }
}

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

    # Initialize request argument(s)
    data_scan = dataplex_v1.DataScan()
    data_scan.data_quality_spec.rules.dimension = "dimension_value"
    data_scan.data.entity = "entity_value"

    request = dataplex_v1.UpdateDataScanRequest(
        data_scan=data_scan,
    )

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

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

    response = operation.result()

    # Handle the response
    print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the update_data_scan call in the DataScanService service
#
# 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/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::DataScanService::Client#update_data_scan.
#
def update_data_scan
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::UpdateDataScanRequest.new

  # Call the update_data_scan method.
  result = client.update_data_scan request

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

REST

Pour modifier une analyse de la qualité des données, utilisez la méthode dataScans.patch.

Supprimer une analyse de la qualité des données

Console

Dans la console Google Cloud , sur la page Curation des métadonnées de BigQuery, accédez à l'onglet Qualité et profilage des données.

Accéder à la page "Qualité et profilage des données"
Cliquez sur l'analyse que vous souhaitez supprimer.
Cliquez sur Supprimer, puis confirmez l'opération lorsque vous y êtes invité.

gcloud

Pour supprimer une analyse de la qualité des données, utilisez la commande gcloud dataplex datascans delete :

gcloud dataplex datascans delete DATASCAN \
--location=LOCATION \
--async

Remplacez les variables suivantes :

DATASCAN : nom de l'analyse de la qualité des données à supprimer.
LOCATION : région Google Cloud dans laquelle l'analyse de la qualité des données a été créée.

C#

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

public sealed partial class GeneratedDataScanServiceClientSnippets
{
    /// <summary>Snippet for DeleteDataScan</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 DeleteDataScanRequestObject()
    {
        // Create client
        DataScanServiceClient dataScanServiceClient = DataScanServiceClient.Create();
        // Initialize request argument(s)
        DeleteDataScanRequest request = new DeleteDataScanRequest
        {
            DataScanName = DataScanName.FromProjectLocationDataScan("[PROJECT]", "[LOCATION]", "[DATASCAN]"),
            Force = false,
        };
        // Make the request
        Operation<Empty, OperationMetadata> response = dataScanServiceClient.DeleteDataScan(request);

        // Poll until the returned long-running operation is complete
        Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
        // Retrieve the operation result
        Empty 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<Empty, OperationMetadata> retrievedResponse = dataScanServiceClient.PollOnceDeleteDataScan(operationName);
        // Check if the retrieved long-running operation has completed
        if (retrievedResponse.IsCompleted)
        {
            // If it has completed, then access the result
            Empty retrievedResult = retrievedResponse.Result;
        }
    }
}

Go


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.NewDataScanClient(ctx)
	if err != nil {
		// TODO: Handle error.
	}
	defer c.Close()

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

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

Java

import com.google.cloud.dataplex.v1.DataScanName;
import com.google.cloud.dataplex.v1.DataScanServiceClient;
import com.google.cloud.dataplex.v1.DeleteDataScanRequest;
import com.google.protobuf.Empty;

public class SyncDeleteDataScan {

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

  public static void syncDeleteDataScan() 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 (DataScanServiceClient dataScanServiceClient = DataScanServiceClient.create()) {
      DeleteDataScanRequest request =
          DeleteDataScanRequest.newBuilder()
              .setName(DataScanName.of("[PROJECT]", "[LOCATION]", "[DATASCAN]").toString())
              .setForce(true)
              .build();
      dataScanServiceClient.deleteDataScanAsync(request).get();
    }
  }
}

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

    # Initialize request argument(s)
    request = dataplex_v1.DeleteDataScanRequest(
        name="name_value",
    )

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

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

    response = operation.result()

    # Handle the response
    print(response)

Ruby

require "google/cloud/dataplex/v1"

##
# Snippet for the delete_data_scan call in the DataScanService service
#
# 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/ruby/docs/reference.
#
# This is an auto-generated example demonstrating basic usage of
# Google::Cloud::Dataplex::V1::DataScanService::Client#delete_data_scan.
#
def delete_data_scan
  # Create a client object. The client can be reused for multiple calls.
  client = Google::Cloud::Dataplex::V1::DataScanService::Client.new

  # Create a request. To set request fields, pass in keyword arguments.
  request = Google::Cloud::Dataplex::V1::DeleteDataScanRequest.new

  # Call the delete_data_scan method.
  result = client.delete_data_scan request

  # The returned object is of type Gapic::Operation. You can use it to
  # check the status of an operation, cancel it, or wait for results.
  # Here is how to wait for a response.
  result.wait_until_done! timeout: 60
  if result.response?
    p result.response
  else
    puts "No response received."
  end
end

REST

Pour supprimer une analyse de la qualité des données, utilisez la méthode dataScans.delete :

Étape suivante

En savoir plus sur la gouvernance des données dans BigQuery