Masquer les données de colonne

Ce document explique comment implémenter le masquage des données afin d'obscurcir de manière sélective des données sensibles. En implémentant le masquage de données, vous pouvez fournir différents niveaux de visibilité à différents groupes d'utilisateurs. Pour obtenir des informations générales, consultez la page Présentation du masquage des données.

Vous mettez en œuvre le masquage de données en ajoutant une stratégie de données à une colonne. Pour ajouter une règle de masquage de données à une colonne, procédez comme suit :

1. Créez une taxonomie avec au moins un tag avec stratégie.
2. Facultatif : attribuez le rôle "Lecteur détaillé Data Catalog" à un ou plusieurs comptes principaux sur un ou plusieurs tags avec stratégie que vous avez créés.
3. Créez jusqu'à trois stratégies de données pour le tag avec stratégie, afin de mapper les règles de masquage et les comptes principaux (qui représentent des utilisateurs ou des groupes) à ce tag.
4. Définissez le tag avec stratégie sur une colonne. Cela mappe les stratégies de données associées au tag avec stratégie à la colonne sélectionnée.
5. Attribuez le rôle Lecteur masqué BigQuery aux utilisateurs qui doivent avoir accès aux données masquées. Nous vous recommandons d'attribuer le rôle de lecteur masqué BigQuery au niveau de la stratégie de données. L'attribution du rôle au niveau du projet ou à un niveau supérieur accorde aux utilisateurs des autorisations sur toutes les stratégies de données du projet, ce qui peut entraîner des problèmes en raison d'autorisations en excès.

Vous pouvez utiliser la console Google Cloud ou l'API BigQuery Data Policy pour travailler avec les règles relatives aux données.

Une fois ces étapes terminées, les utilisateurs exécutant des requêtes sur la colonne obtiennent des données non masquées, des données masquées ou une erreur d'accès refusé, en fonction des groupes auxquels ils appartiennent et des rôles qui leur ont été attribués. Pour en savoir plus, consultez la section Interaction des rôles Lecteur masqué et Lecteur détaillé.

Vous pouvez également appliquer des règles de données directement à une colonne (Aperçu). Pour en savoir plus, consultez Masquer des données avec des règles de données directement dans une colonne.

Masquer des données avec des tags avec stratégie

Utilisez des tags avec stratégie pour masquer sélectivement les données sensibles.

Avant de commencer

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Data Catalog and BigQuery Data Policy APIs.

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 APIs

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Data Catalog and BigQuery Data Policy APIs.

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 APIs

1. BigQuery est automatiquement activé dans les nouveaux projets, mais vous devrez peut-être l'activer dans un projet préexistant.

   Enable the BigQuery 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

2. Si vous créez une stratégie de données qui fait référence à une routine de masquage personnalisée, créez la fonction de masquage définie par l'utilisateur associée afin qu'elle soit disponible dans les étapes suivantes.

Créer des catégories

L'utilisateur ou le compte de service qui crée une taxonomie doit disposer du rôle "Administrateur de tags avec stratégie Data Catalog".

Console

1. Ouvrez la page Catégories de tags avec stratégie dans la consoleGoogle Cloud .

   Ouvrir la page Catégories de tags avec stratégie

2. Cliquez sur Créer une taxonomie.

3. Sur la page Nouvelle taxonomie :

   1. Dans le champ Nom de la taxonomie, saisissez le nom de la taxonomie à créer.
   2. Dans le champ Description, saisissez une description.
   3. Si nécessaire, modifiez le projet répertorié sous Project (Projet).
   4. Si nécessaire, modifiez l'emplacement répertorié sous Location (Emplacement).
   5. Sous Policy Tags (Tags avec stratégie), saisissez un nom et une description de tag avec stratégie.
   6. Pour ajouter un tag avec stratégie enfant à un tag avec stratégie, cliquez sur Ajouter un sous-tag.
   7. Pour ajouter un tag avec stratégie au même niveau qu'un autre tag, cliquez sur + Ajouter un tag avec stratégie.
   8. Continuez à ajouter des tags avec stratégie et des tags avec stratégie enfant selon les besoins de votre taxonomie.
   9. Lorsque vous avez fini de créer des tags avec stratégie pour votre hiérarchie, cliquez sur Enregistrer.

API

Pour utiliser les taxonomies existantes, appelez taxonomies.import à la place des deux premières étapes de la procédure suivante.

1. Appelez taxonomies.create pour créer une taxonomie.
2. Appelez taxonomies.policytag.create pour créer un tag avec stratégie.

Utiliser des tags avec stratégie

Pour en savoir plus sur l'utilisation des tags avec stratégie, comme leur affichage ou leur mise à jour, consultez la section Utiliser des tags avec stratégie. Pour en savoir plus sur les bonnes pratiques, consultez la page Bonnes pratiques d'utilisation des tags avec stratégie dans BigQuery.

Créer des stratégies de données

L'utilisateur ou le compte de service qui crée une stratégie de données doit disposer des autorisations bigquery.dataPolicies.create, bigquery.dataPolicies.setIamPolicy et datacatalog.taxonomies.get.

Les autorisations bigquery.dataPolicies.create et bigquery.dataPolicies.setIamPolicy sont incluses dans les rôles "Administrateur de stratégies de données BigQuery", "Administrateur BigQuery" et "Propriétaire de données BigQuery". L'autorisation datacatalog.taxonomies.get est incluse dans les rôles "Administrateur Data Catalog" et "Lecteur Data Catalog".

Si vous créez une stratégie de données qui fait référence à une routine de masquage personnalisée, vous avez également besoin d'autorisations de routine.

En cas de masquage personnalisé, accordez aux utilisateurs les rôles Administrateur BigQuery ou Propriétaire de données BigQuery pour vous assurer qu'ils disposent des autorisations nécessaires pour les routines et les règles de données.

Vous pouvez créer jusqu'à neuf stratégies de données pour un tag avec stratégie. L'une de ces stratégies est réservée aux paramètres de contrôle des accès au niveau des colonnes.

Console

1. Ouvrez la page Catégories de tags avec stratégie dans la consoleGoogle Cloud .

   Ouvrir la page Catégories de tags avec stratégie

2. Cliquez sur le nom de la taxonomie à ouvrir.
3. Sélectionnez un tag avec stratégie.
4. Cliquez sur Gérer les stratégies des données.
5. Dans Nom de la stratégie de données, saisissez un nom pour la stratégie de données. Le nom de la stratégie de données doit être unique dans le projet dans lequel se trouve la stratégie de données.
6. Pour Règle de masquage, choisissez une règle de masquage prédéfinie ou une routine de masquage personnalisée. Si vous sélectionnez une routine de masquage personnalisée, assurez-vous de disposer des autorisations bigquery.routines.get et bigquery.routines.list au niveau du projet.
7. Pour Compte principal, saisissez le nom d'un ou de plusieurs utilisateurs ou groupes auxquels vous souhaitez accorder un accès masqué à la colonne. Notez que tous les utilisateurs et groupes que vous saisissez ici se voient attribuer le rôle de lecteur masqué BigQuery.
8. Cliquez sur Envoyer.

API

1. Appelez la méthode create. Transmettez une ressource DataPolicy qui répond aux exigences suivantes :

   • Le champ dataPolicyType est défini sur DATA_MASKING_POLICY.
   • Le champ dataMaskingPolicy identifie la stratégie ou la routine de masquage de données à utiliser.
   • Le champ dataPolicyId fournit un nom pour la stratégie de données qui est unique dans le projet dans lequel se trouve la stratégie de données.

2. Appelez la méthode setIamPolicy et transmettez un objet Policy. Policy doit identifier les comptes principaux autorisés à accéder aux données masquées et spécifier roles/bigquerydatapolicy.maskedReader pour le champ role.

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Node.js.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

const datapolicy = require('@google-cloud/bigquery-datapolicies');
const {DataPolicyServiceClient} = datapolicy.v2;
const protos = datapolicy.protos.google.cloud.bigquery.datapolicies.v2;
const {status} = require('@grpc/grpc-js');

const dataPolicyServiceClient = new DataPolicyServiceClient();

/**
 * Creates a data policy to apply a data masking rule to a specific BigQuery table column. 
 * This is a primary mechanism for implementing column-level security in BigQuery.
 *
 * @param {string} projectId The Google Cloud project ID (for example, 'example-project-id')
 * @param {string} location The Google Cloud location. Example: 'us'
 * @param {string} dataPolicyId The user-assigned ID of the data policy. Example: 'example-data-policy-id'
 */
async function createDataPolicy(projectId, location, dataPolicyId) {
  const parent = `projects/${projectId}/locations/${location}`;

  const dataPolicy = {
    dataPolicyType: protos.DataPolicy.DataPolicyType.DATA_MASKING_POLICY,
    dataMaskingPolicy: {
      predefinedExpression:
        protos.DataMaskingPolicy.PredefinedExpression.SHA256,
    },
  };

  const request = {
    parent,
    dataPolicyId,
    dataPolicy,
  };

  try {
    const [response] = await dataPolicyServiceClient.createDataPolicy(request);
    console.log(`Successfully created data policy: ${response.name}`);
    console.log(`Data policy ID: ${response.dataPolicyId}`);
    console.log(`Data policy type: ${response.dataPolicyType}`);
    if (response.dataMaskingPolicy) {
      console.log(
        `Data masking expression: ${response.dataMaskingPolicy.predefinedExpression}`,
      );
    }
  } catch (err) {
    if (err.code === status.ALREADY_EXISTS) {
      console.log(
        `Data policy '${dataPolicyId}' already exists in location '${location}' of project '${projectId}'.`,
      );
      console.log(
        'Consider updating the existing data policy or using a different dataPolicyId.',
      );
    } else {
      console.error('Error creating data policy:', err.message);
    }
  }
}

Python

Avant d'essayer cet exemple, suivez les instructions de configuration pour Python du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Python.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

from google.api_core import exceptions
from google.cloud import bigquery_datapolicies_v2

client = bigquery_datapolicies_v2.DataPolicyServiceClient()


def create_data_policy(project_id: str, location: str, data_policy_id: str) -> None:
    """Creates a data policy to apply a data masking rule to a specific BigQuery table column. 
    This is a primary mechanism for implementing column-level security in BigQuery.

    Args:
        project_id (str): The Google Cloud project ID.
        location (str): The geographic location of the data policy (for example, "us-central1").
        data_policy_id (str): The ID for the new data policy.
    """

    parent = f"projects/{project_id}/locations/{location}"

    # Define the data masking policy.
    # Here, we specify a SHA-256 predefined expression for data masking.
    data_masking_policy = bigquery_datapolicies_v2.DataMaskingPolicy(
        predefined_expression=bigquery_datapolicies_v2.DataMaskingPolicy.PredefinedExpression.SHA256
    )

    # Create the DataPolicy object.
    # We set the type to DATA_MASKING_POLICY and assign the defined masking policy.
    data_policy = bigquery_datapolicies_v2.DataPolicy(
        data_policy_type=bigquery_datapolicies_v2.DataPolicy.DataPolicyType.DATA_MASKING_POLICY,
        data_masking_policy=data_masking_policy,
    )

    request = bigquery_datapolicies_v2.CreateDataPolicyRequest(
        parent=parent,
        data_policy_id=data_policy_id,
        data_policy=data_policy,
    )

    try:
        response = client.create_data_policy(request=request)
        print(f"Successfully created data policy: {response.name}")
        print(f"Data Policy ID: {response.data_policy_id}")
        print(f"Data Policy Type: {response.data_policy_type.name}")
        print(
            "Data Masking Predefined Expression:"
            f" {response.data_masking_policy.predefined_expression.name}"
        )
    except exceptions.AlreadyExists as e:
        print(
            f"Error: Data policy '{data_policy_id}' already exists in project"
            f" '{project_id}' in location '{location}'. Use a unique ID or"
            " update the existing policy if needed."
        )

    except exceptions.NotFound as e:
        print(
            f"Error: The specified project '{project_id}' or location '{location}'"
            " was not found or is inaccessible. Make sure the project ID and"
            " location are correct and you have the necessary permissions."
        )
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

Définir des tags avec stratégie sur des colonnes

Définissez une stratégie de données sur une colonne en associant la colonne au tag avec stratégie associé à la stratégie de données.

L'utilisateur ou le compte de service qui définit un tag avec stratégie a besoin des autorisations datacatalog.taxonomies.get et bigquery.tables.setCategory. datacatalog.taxonomies.get est inclus dans les rôles "Administrateur de tags avec stratégie Data Catalog" et "Lecteur de projet". bigquery.tables.setCategory est inclus dans les rôles Administrateur BigQuery (roles/bigquery.admin) et Propriétaire de données BigQuery (roles/bigquery.dataOwner).

Pour afficher les taxonomies et les tags avec stratégie de tous les projets d'une organisation dans la consoleGoogle Cloud , les utilisateurs doivent disposer de l'autorisation resourcemanager.organizations.get, qui est incluse dans le rôle Lecteur de l'organisation.

Remarque : Vous ne pouvez attribuer qu'un seul tag avec stratégie par colonne.

Console

Définissez le tag avec stratégie en modifiant un schéma à l'aide de la consoleGoogle Cloud .

1. Ouvrez la page BigQuery dans la console Google Cloud .

   Accéder à la page "BigQuery"

2. Dans l'explorateur BigQuery, localisez et sélectionnez la table que vous souhaitez mettre à jour. Le schéma de la table s'ouvre.

3. Cliquez sur Modifier le schéma.

4. Dans l'écran Current schema (Schéma actuel), sélectionnez la colonne cible, puis cliquez sur Add policy tag (Ajouter un tag avec stratégie).

5. Dans l'écran Add policy tag (Ajouter un tag avec stratégie), sélectionnez le tag avec stratégie que vous souhaitez appliquer à la colonne.

6. Cliquez sur Sélectionner. L'écran qui s'affiche devrait se présenter comme ceci :

   

7. Cliquez sur Enregistrer.

bq

1. Enregistrez le schéma dans un fichier local.

   bq show --schema --format=prettyjson \
      project-id:dataset.table > schema.json

   où :

   • project-id est l'ID de votre projet.
   • dataset est le nom de l'ensemble de données contenant la table que vous mettez à jour.
   • table est le nom de la table que vous mettez à jour.

2. Modifiez le fichier schema.json pour définir un tag avec stratégie sur une colonne. Pour la valeur du champ names de policyTags, utilisez le nom de ressource du tag avec stratégie.

   [
    ...
    {
      "name": "ssn",
      "type": "STRING",
      "mode": "REQUIRED",
      "policyTags": {
        "names": ["projects/project-id/locations/location/taxonomies/taxonomy-id/policyTags/policytag-id"]
      }
    },
    ...
   ]

3. Mettez à jour le schéma.

   bq update \
      project-id:dataset.table schema.json

API

Pour les tables existantes, appelez tables.patch ou, pour les nouvelles tables, appelez tables.insert. Utilisez la propriété schema de l'objet Table que vous transmettez pour définir un tag avec stratégie dans votre définition de schéma. Consultez l'exemple de schéma de ligne de commande pour savoir comment définir un tag avec stratégie.

Lorsque vous utilisez une table existante, la méthode tables.patch est préférable, car la méthode tables.update remplace l'intégralité de la ressource de table.

Appliquer le contrôle des accès

Lorsque vous créez une stratégie de données pour un tag avec stratégie, le contrôle des accès est automatiquement appliqué. Toutes les colonnes auxquelles ce tag avec stratégie est appliqué renvoient des données masquées en réponse aux requêtes des utilisateurs disposant du rôle "Lecteur masqué".

Pour arrêter l'application du contrôle des accès, vous devez d'abord supprimer toutes les stratégies de données associées aux tags avec stratégie de la taxonomie. Pour en savoir plus, consultez la section Appliquer le contrôle des accès.

Obtenir un règlement sur les données

Pour obtenir des informations sur une règle relative aux données, procédez comme suit :

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Node.js.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

const {DataPolicyServiceClient} =
  require('@google-cloud/bigquery-datapolicies').v2;
const {status} = require('@grpc/grpc-js');

const client = new DataPolicyServiceClient();

/**
 * Gets a specific data policy from the BigQuery Data Policy API by its name.
 *
 * This sample demonstrates how to fetch the details of an existing data policy.
 * Data policies are used to define rules for data masking or row-level security
 * on BigQuery tables.
 *
 * @param {string} projectId The Google Cloud project ID (for example, 'example-project-id')
 * @param {string} [location='us'] The Google Cloud location of the data policy (For example, 'us', 'europe-west2').
 * @param {string} [dataPolicyId='example-data-policy'] The ID of the data policy to retrieve.
 */
async function getDataPolicy(
  projectId,
  location = 'us',
  dataPolicyId = 'example-data-policy',
) {
  const name = client.dataPolicyPath(projectId, location, dataPolicyId);

  const request = {
    name,
  };

  try {
    const [dataPolicy] = await client.getDataPolicy(request);
    console.log('Successfully retrieved data policy:');
    console.log(`  Name: ${dataPolicy.name}`);
    console.log(`  Type: ${dataPolicy.dataPolicyType}`);
    if (dataPolicy.dataMaskingPolicy) {
      console.log(
        `  Data Masking Policy: ${dataPolicy.dataMaskingPolicy.predefinedExpression || dataPolicy.dataMaskingPolicy.routine}`,
      );
    }
    if (dataPolicy.grantees && dataPolicy.grantees.length > 0) {
      console.log(`  Grantees: ${dataPolicy.grantees.join(', ')}`);
    }
  } catch (err) {
    if (err.code === status.NOT_FOUND) {
      console.error(
        `Error: Data policy '${dataPolicyId}' not found in location '${location}' for project '${projectId}'.`,
      );
      console.error(
        'Make sure the data policy ID, project ID, and location are correct.',
      );
    } else {
      console.error('Error retrieving data policy:', err.message);
    }
  }
}

Python

Avant d'essayer cet exemple, suivez les instructions de configuration pour Python du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Python.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

from google.api_core import exceptions
from google.cloud import bigquery_datapolicies_v2


client = bigquery_datapolicies_v2.DataPolicyServiceClient()


def get_data_policy(
    project_id: str,
    location: str,
    data_policy_id: str,
) -> None:
    """Gets a specific data policy from the BigQuery Data Policy API by its name.


    Args:
        project_id: The Google Cloud project ID.
        location: The geographic location of the data policy (for example, "us", "eu").
        data_policy_id: The user-assigned ID of the data policy.
    """
    client = bigquery_datapolicies_v2.DataPolicyServiceClient()

    data_policy_name = client.data_policy_path(
        project=project_id,
        location=location,
        data_policy=data_policy_id,
    )

    try:
        response = client.get_data_policy(name=data_policy_name)

        print(f"Successfully retrieved data policy: {response.name}")
        print(f"  Data Policy ID: {response.data_policy_id}")
        print(f"  Data Policy Type: {response.data_policy_type.name}")
        if response.policy_tag:
            print(f"  Policy Tag: {response.policy_tag}")
        if response.grantees:
            print(f"  Grantees: {', '.join(response.grantees)}")
        if response.data_masking_policy:
            masking_policy = response.data_masking_policy
            if masking_policy.predefined_expression:
                print(
                    f"  Data Masking Predefined Expression: {masking_policy.predefined_expression.name}"
                )
            elif masking_policy.routine:
                print(f"  Data Masking Routine: {masking_policy.routine}")

    except exceptions.NotFound:
        print(f"Error: Data policy '{data_policy_name}' not found.")
        print("Make sure the data policy ID, project ID, and location are correct.")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

Vérifier les autorisations IAM sur une stratégie de données

Pour obtenir la stratégie IAM associée à une règle de données, procédez comme suit :

API

Appelez la méthode testIamPermissions.

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Node.js.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

const {DataPolicyServiceClient} =
  require('@google-cloud/bigquery-datapolicies').v2;
const {status} = require('@grpc/grpc-js');

const client = new DataPolicyServiceClient();

/**
 * Get the IAM policy for a specified data policy resource from the BigQuery Data Policy API.
 * This is useful for auditing which members have which roles on the policy.
 *
 *
 * @param {string} projectId Google Cloud Project ID (For example, 'example-project-id')
 * @param {string} location Google Cloud Location (For example, 'us-central1')
 * @param {string} dataPolicyId The ID of the data policy (For example, 'example-data-policy-id')
 */
async function getIamPolicy(projectId, location, dataPolicyId) {
  const resourceName = client.dataPolicyPath(projectId, location, dataPolicyId);

  const request = {
    resource: resourceName,
  };

  try {
    const [policy] = await client.getIamPolicy(request);
    console.log(
      'Successfully retrieved IAM policy for data policy %s:',
      resourceName,
    );
    console.log(JSON.stringify(policy, null, 2));
  } catch (err) {
    if (err.code === status.NOT_FOUND) {
      console.error(
        `Error: Data Policy '${dataPolicyId}' not found in location '${location}' of project '${projectId}'. ` +
          'Make sure the data policy exists and the resource name is correct.',
      );
    } else {
      console.error(
        `Error getting IAM policy for data policy '${dataPolicyId}':`,
        err,
      );
    }
  }
}

Python

Avant d'essayer cet exemple, suivez les instructions de configuration pour Python du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Python.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

from google.api_core import exceptions
from google.cloud import bigquery_datapolicies_v2
from google.iam.v1 import iam_policy_pb2

client = bigquery_datapolicies_v2.DataPolicyServiceClient()


def get_data_policy_iam_policy(
    project_id: str,
    location: str,
    data_policy_id: str,
) -> None:
    """Get the IAM policy for a specified data policy resource from the BigQuery Data Policy API. 
    This is useful for auditing which members have which roles on the policy.

    Args:
        project_id: The Google Cloud project ID.
        location: The geographic location of the data policy (for example, "us").
        data_policy_id: The ID of the data policy.
    """

    resource_name = client.data_policy_path(
        project=project_id,
        location=location,
        data_policy=data_policy_id,
    )

    request = iam_policy_pb2.GetIamPolicyRequest(resource=resource_name)

    try:
        policy = client.get_iam_policy(request=request)

        print(f"Successfully retrieved IAM policy for data policy: {resource_name}")
        print("Policy Version:", policy.version)
        if policy.bindings:
            print("Policy Bindings:")
            for binding in policy.bindings:
                print(f"  Role: {binding.role}")
                print(f"  Members: {', '.join(binding.members)}")
                if binding.condition.expression:
                    print(f"  Condition: {binding.condition.expression}")
        else:
            print("No bindings found in the policy.")

    except exceptions.NotFound:
        print(f"Error: Data policy '{resource_name}' not found.")
        print("Make sure the project ID, location, and data policy ID are correct.")
    except exceptions.GoogleAPIError as e:
        print(f"An API error occurred: {e}")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

Lister les règles relatives aux données

Pour lister les règles relatives aux données, procédez comme suit :

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Node.js.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

const {DataPolicyServiceClient} =
  require('@google-cloud/bigquery-datapolicies').v2;
const {status} = require('@grpc/grpc-js');

const client = new DataPolicyServiceClient();

/**
 * Lists all data policies in a given project and location.
 *
 * Data policies define rules for data masking, row-level security, or column-level security.
 *
 * @param {string} projectId The Google Cloud project ID. (for example, 'example-project-id')
 * @param {string} location The Google Cloud location of the data policies. (For example, 'us')
 */
async function listDataPolicies(projectId, location) {
  const parent = `projects/${projectId}/locations/${location}`;

  const request = {
    parent,
  };

  try {
    console.log(
      `Listing data policies for project: ${projectId} in location: ${location}`,
    );
    const [dataPolicies] = await client.listDataPolicies(request);

    if (dataPolicies.length === 0) {
      console.log(
        `No data policies found in location ${location} for project ${projectId}.`,
      );
      return;
    }

    console.log('Data Policies:');
    for (const dataPolicy of dataPolicies) {
      console.log(`  Data Policy Name: ${dataPolicy.name}`);
      console.log(`    ID: ${dataPolicy.dataPolicyId}`);
      console.log(`    Type: ${dataPolicy.dataPolicyType}`);
      if (dataPolicy.policyTag) {
        console.log(`    Policy Tag: ${dataPolicy.policyTag}`);
      }
      if (dataPolicy.grantees && dataPolicy.grantees.length > 0) {
        console.log(`    Grantees: ${dataPolicy.grantees.join(', ')}`);
      }
      if (dataPolicy.dataMaskingPolicy) {
        if (dataPolicy.dataMaskingPolicy.predefinedExpression) {
          console.log(
            `    Data Masking Predefined Expression: ${dataPolicy.dataMaskingPolicy.predefinedExpression}`,
          );
        } else if (dataPolicy.dataMaskingPolicy.routine) {
          console.log(
            `    Data Masking Routine: ${dataPolicy.dataMaskingPolicy.routine}`,
          );
        }
      }
    }

    console.log(`Successfully listed ${dataPolicies.length} data policies.`);
  } catch (err) {
    if (err.code === status.NOT_FOUND) {
      console.error(
        `Error: The project or location '${location}' for project '${projectId}' was not found. ` +
          'Make sure the project ID and location are correct and that the BigQuery Data Policy API is enabled.',
      );
    } else if (err.code === status.PERMISSION_DENIED) {
      console.error(
        `Error: Permission denied when listing data policies for project '${projectId}' in location '${location}'. ` +
          'Make sure the authenticated account has the necessary permissions (For example, bigquery.datapolicies.list).',
      );
    } else {
      console.error(`Error listing data policies: ${err.message}`);
    }
  }
}

Python

Avant d'essayer cet exemple, suivez les instructions de configuration pour Python du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Python.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

import google.api_core.exceptions
from google.cloud import bigquery_datapolicies_v2

client = bigquery_datapolicies_v2.DataPolicyServiceClient()


def list_data_policies(project_id: str, location: str) -> None:
    """Lists all data policies in a specified project.

    Args:
        project_id: The Google Cloud project ID.
        location: The geographic location of the data policies (for example, "us", "us-central1").
    """

    parent = f"projects/{project_id}/locations/{location}"

    try:
        request = bigquery_datapolicies_v2.ListDataPoliciesRequest(parent=parent)

        print(
            f"Listing data policies for project '{project_id}' in location '{location}':"
        )
        page_result = client.list_data_policies(request=request)

        found_policies = False
        for data_policy in page_result:
            found_policies = True
            print(f"  Data Policy Name: {data_policy.name}")
            print(f"  Data Policy ID: {data_policy.data_policy_id}")
            print(f"  Data Policy Type: {data_policy.data_policy_type.name}")
            if data_policy.policy_tag:
                print(f"  Policy Tag: {data_policy.policy_tag}")
            if data_policy.grantees:
                print(f"  Grantees: {', '.join(data_policy.grantees)}")
            print("-" * 20)

        if not found_policies:
            print("No data policies found.")

    except google.api_core.exceptions.NotFound as e:
        print(f"Error: The specified project or location was not found or accessible.")
        print(f"Details: {e}")
        print(
            "Make sure the project ID and location are correct and you have the necessary permissions."
        )
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

Mettre à jour les stratégies des données

L'utilisateur ou le compte de service qui met à jour une stratégie de données doit disposer de l'autorisation bigquery.dataPolicies.update. Si vous mettez à jour le tag avec stratégie associé à la stratégie de données, vous devez également disposer de l'autorisation datacatalog.taxonomies.get.

Si vous mettez à jour les comptes principaux associés à la stratégie de données, vous devez disposer de l'autorisation bigquery.dataPolicies.setIamPolicy.

Les autorisations bigquery.dataPolicies.update et bigquery.dataPolicies.setIamPolicy sont incluses dans les rôles "Administrateur de stratégies de données BigQuery", "Administrateur BigQuery" et "Propriétaire de données BigQuery". L'autorisation datacatalog.taxonomies.get est incluse dans les rôles "Administrateur Data Catalog" et "Lecteur Data Catalog".

Console

1. Ouvrez la page Catégories de tags avec stratégie dans la consoleGoogle Cloud .

   Ouvrir la page Catégories de tags avec stratégie

2. Cliquez sur le nom de la taxonomie à ouvrir.
3. Sélectionnez un tag avec stratégie.
4. Cliquez sur Gérer les stratégies des données.
5. Vous pouvez également modifier la stratégie de masquage.
6. Facultatif : ajoutez ou supprimez des comptes principaux.
7. Cliquez sur Envoyer.

API

Pour modifier la stratégie de masquage de données, appelez la méthode patch et transmettez une ressource DataPolicy avec un champ dataMaskingPolicy mis à jour.

Pour modifier les comptes principaux associés à une stratégie de données, appelez la méthode setIamPolicy et transmettez un objet Policy qui met à jour les comptes principaux autorisés à accéder aux données masquées.

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Node.js.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

const datapolicy = require('@google-cloud/bigquery-datapolicies');
const {DataPolicyServiceClient} = datapolicy.v2;
const protos = datapolicy.protos.google.cloud.bigquery.datapolicies.v2;
const {status} = require('@grpc/grpc-js');

const client = new DataPolicyServiceClient();

/**
 * Updates the data masking configuration of an existing data policy.
 * This example demonstrates how to use a FieldMask to selectively update the
 * `data_masking_policy` (for example, changing the masking expression from
 * ALWAYS_NULL to SHA256) without affecting other fields or recreating the policy.
 *
 * @param {string} projectId The Google Cloud project ID (For example, 'example-project-id').
 * @param {string} location The location of the data policy (For example, 'us').
 * @param {string} dataPolicyId The ID of the data policy to update (For example, 'example-data-policy-id').
 */
async function updateDataPolicy(projectId, location, dataPolicyId) {
  const resourceName = client.dataPolicyPath(projectId, location, dataPolicyId);

  const getRequest = {
    name: resourceName,
  };

  try {
    // To prevent race conditions, use the policy's etag in the update.
    const [currentDataPolicy] = await client.getDataPolicy(getRequest);
    const currentETag = currentDataPolicy.etag;

    // This example transitions a masking rule from ALWAYS_NULL to SHA256.
    const dataPolicy = {
      name: resourceName,
      etag: currentETag,
      dataMaskingPolicy: {
        predefinedExpression:
          protos.DataMaskingPolicy.PredefinedExpression.SHA256,
      },
    };

    // Use a field mask to selectively update only the data masking policy.
    const updateMask = {
      paths: ['data_masking_policy'],
    };

    const request = {
      dataPolicy,
      updateMask,
    };

    const [response] = await client.updateDataPolicy(request);
    console.log(`Successfully updated data policy: ${response.name}`);
    console.log(
      `New masking expression: ${response.dataMaskingPolicy.predefinedExpression}`
    );
  } catch (err) {
    if (err.code === status.NOT_FOUND) {
      console.error(
        `Error: Data policy '${resourceName}' not found. ` +
          'Make sure the data policy exists and the project, location, and data policy ID are correct.'
      );
    } else {
      console.error('Error updating data policy:', err.message, err);
    }
  }
}

Python

Avant d'essayer cet exemple, suivez les instructions de configuration pour Python du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Python.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

from google.api_core import exceptions
from google.cloud import bigquery_datapolicies_v2
from google.protobuf import field_mask_pb2

client = bigquery_datapolicies_v2.DataPolicyServiceClient()


def update_data_policy(
    project_id: str,
    location: str,
    data_policy_id: str
) -> None:
    """Updates the data masking configuration of an existing data policy.

    This example demonstrates how to use a FieldMask to selectively update the
    `data_masking_policy` (for example, changing the masking expression from
    ALWAYS_NULL to SHA256) without affecting other fields or recreating the policy.

    Args:
        project_id: The Google Cloud project ID.
        location: The geographic location (for example, "us") of the data policy.
        data_policy_id: The ID of the data policy to update.
    """

    data_policy_name = client.data_policy_path(
        project=project_id,
        location=location,
        data_policy=data_policy_id,
    )

    # To prevent race conditions, use the policy's etag in the update.
    existing_policy = client.get_data_policy(name=data_policy_name)

    # This example transitions a masking rule from ALWAYS_NULL to SHA256.
    updated_data_policy = bigquery_datapolicies_v2.DataPolicy(
        name=data_policy_name,
        data_masking_policy=bigquery_datapolicies_v2.DataMaskingPolicy(
            predefined_expression=bigquery_datapolicies_v2.DataMaskingPolicy.PredefinedExpression.SHA256
        ),
        etag=existing_policy.etag,
    )

    # Use a field mask to selectively update only the data masking policy.
    update_mask = field_mask_pb2.FieldMask(
        paths=["data_masking_policy"]
    )
    request = bigquery_datapolicies_v2.UpdateDataPolicyRequest(
        data_policy=updated_data_policy,
        update_mask=update_mask,
    )

    try:
        response = client.update_data_policy(request=request)
        print(f"Successfully updated data policy: {response.name}")
        print(f"New data policy type: {response.data_policy_type.name}")
        if response.data_masking_policy:
            print(
                f"New masking expression: {response.data_masking_policy.predefined_expression.name}"
            )
    except exceptions.NotFound:
        print(f"Error: Data policy '{data_policy_name}' not found.")
        print("Make sure the data policy ID and location are correct.")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

Supprimer les stratégies de données

L'utilisateur ou le compte de service qui crée une stratégie de données doit disposer de l'autorisation bigquery.dataPolicies.delete. Cette autorisation est incluse dans les rôles d'administrateur de stratégies de données BigQuery, d'administrateur BigQuery et de propriétaire de données BigQuery.

Console

1. Ouvrez la page Catégories de tags avec stratégie dans la consoleGoogle Cloud .

   Ouvrir la page Catégories de tags avec stratégie

2. Cliquez sur le nom de la taxonomie à ouvrir.
3. Sélectionnez un tag avec stratégie.
4. Cliquez sur Gérer les stratégies des données.
5. Cliquez sur à côté de la stratégie de données à supprimer.
6. Cliquez sur Envoyer.
7. Cliquez sur Confirmer.

API

Pour supprimer une stratégie de données, appelez la méthode delete.

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Node.js.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

const {DataPolicyServiceClient} =
  require('@google-cloud/bigquery-datapolicies').v2;
const {status} = require('@grpc/grpc-js');

const client = new DataPolicyServiceClient();

/**
 * Deletes a data policy from the BigQuery Data Policy API, which is identified by its project ID, location, and data policy ID.
 *
 * @param {string} projectId The Google Cloud project ID.
 * @param {string} location The Google Cloud location (For example, 'us').
 * @param {string} dataPolicyId The ID of the data policy to delete (For example, 'example-data-policy').
 */
async function deleteDataPolicy(projectId, location, dataPolicyId) {
  const name = client.dataPolicyPath(projectId, location, dataPolicyId);

  const request = {
    name,
  };

  try {
    await client.deleteDataPolicy(request);
    console.log(`Successfully deleted data policy: ${name}`);
  } catch (err) {
    if (err.code === status.NOT_FOUND) {
      console.error(
        `Data policy ${name} not found. Make sure the data policy ID and location are correct.`,
      );
    } else {
      console.error(`Error deleting data policy ${name}:`, err.message);
    }
  }
}

Python

Avant d'essayer cet exemple, suivez les instructions de configuration pour Python du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Python.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

from google.api_core import exceptions as core_exceptions
from google.cloud import bigquery_datapolicies_v2

client = bigquery_datapolicies_v2.DataPolicyServiceClient()


def delete_data_policy(project_id: str, location: str, data_policy_id: str) -> None:
    """Deletes a data policy from the BigQuery Data Policy APIs.

    Args:
        project_id: The Google Cloud project ID.
        location: The location of the data policy (for example, "us").
        data_policy_id: The ID of the data policy to delete.
    """

    name = client.data_policy_path(
        project=project_id, location=location, data_policy=data_policy_id
    )

    try:
        client.delete_data_policy(name=name)
        print(f"Successfully deleted data policy: {name}")
    except core_exceptions.NotFound:
        print(f"Data policy '{name}' not found. It may have already been deleted.")
    except Exception as e:
        print(f"Error deleting data policy '{name}': {e}")

Masquer des données en appliquant des stratégies de données à une colonne

Preview

Ce produit ou cette fonctionnalité sont soumis aux "Conditions des offres de pré-DG" de la section "Conditions générales du service" des Conditions spécifiques du service. Les produits et fonctionnalités de pré-DG sont proposés "en l'état" et peuvent avoir une compatibilité limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Remarque : Pour envoyer des commentaires ou demander de l'aide concernant cette fonctionnalité, envoyez un e-mail à l'adresse [e-mail].

Au lieu de créer des tags avec stratégie, vous pouvez créer des stratégies de données et les appliquer directement à une colonne.

Utiliser les règles relatives aux données

Vous pouvez créer, modifier et supprimer des règles de données à l'aide de l'API BigQuery Data Policy. Pour appliquer une règle de données directement à une colonne, vous ne pouvez pas utiliser la page Catégories de tags avec stratégie dans la console Google Cloud .

Pour utiliser des règles de données, utilisez la ressource v2.projects.locations.datapolicies.

Créer des stratégies de données

L'utilisateur ou le compte de service qui crée une stratégie de données doit disposer de l'autorisation bigquery.dataPolicies.create.

L'autorisation bigquery.dataPolicies.create est incluse dans les rôles "Administrateur de stratégies de données BigQuery", "Administrateur BigQuery" et "Propriétaire de données BigQuery". L'autorisation datacatalog.taxonomies.get est incluse dans les rôles "Administrateur Data Catalog" et "Lecteur Data Catalog".

Si vous créez une stratégie de données qui fait référence à une routine de masquage personnalisée, vous avez également besoin d'autorisations de routine.

Si vous utilisez le masquage personnalisé, accordez aux utilisateurs le rôle Propriétaire de données BigQuery pour vous assurer qu'ils disposent des autorisations nécessaires pour les routines et les règles de données.

API

Pour créer une stratégie de données, appelez la méthode create. Transmettez une ressource DataPolicy qui répond aux exigences suivantes :

• Le champ dataPolicyType est défini sur DATA_MASKING_POLICY ou RAW_DATA_ACCESS_POLICY.
• Le champ dataMaskingPolicy identifie la stratégie ou la routine de masquage de données à utiliser.
• Le champ dataPolicyId fournit un nom pour la stratégie de données qui est unique dans le projet dans lequel se trouve la stratégie de données.

SQL

Pour créer une règle de données avec un accès masqué, utilisez l'instruction CREATE DATA_POLICY et définissez la valeur de data_policy_type sur DATA_MASKING_POLICY :

    CREATE[ OR REPLACE] DATA_POLICY [IF NOT EXISTS] `myproject.region-us.data_policy_name`
    OPTIONS (
      data_policy_type="DATA_MASKING_POLICY",
      masking_expression="ALWAYS_NULL"
    );

Pour créer une règle de données avec un accès brut, utilisez l'instruction CREATE DATA_POLICY et définissez la valeur de data_policy_type sur RAW_DATA_ACCESS_POLICY :

    CREATE[ OR REPLACE] DATA_POLICY [IF NOT EXISTS] `myproject.region-us.data_policy_name`
    OPTIONS (data_policy_type="RAW_DATA_ACCESS_POLICY");

Si la valeur de data_policy_type n'est pas spécifiée, la valeur par défaut est RAW_DATA_ACCESS_POLICY.

    CREATE[ OR REPLACE] DATA_POLICY [IF NOT EXISTS] myproject.region-us.data_policy_name;

• Le champ data_policy_type est défini sur DATA_MASKING_POLICY ou RAW_DATA_ACCESS_POLICY. Vous ne pouvez pas modifier ce champ une fois la règle de confidentialité créée.
• Le champ masking_expression identifie la stratégie ou la routine de masquage de données à utiliser.

Mettre à jour les stratégies des données

L'utilisateur ou le compte de service qui met à jour une stratégie de données doit disposer de l'autorisation bigquery.dataPolicies.update.

L'autorisation bigquery.dataPolicies.update est incluse dans les rôles "Administrateur de stratégies de données BigQuery", "Administrateur BigQuery" et "Propriétaire de données BigQuery".

API

Pour modifier la stratégie de masquage de données, appelez la méthode patch et transmettez une ressource DataPolicy avec un champ dataMaskingPolicy mis à jour.

SQL

Utilisez l'instruction ALTER DATA_POLICY pour mettre à jour les règles de masquage des données. Exemple :

    ALTER DATA_POLICY `myproject.region-us.data_policy_name`
    SET OPTIONS (
      data_policy_type="DATA_MASKING_POLICY",
      masking_expression="SHA256"
    );

Vous pouvez également accorder un contrôle précis des accès aux règles relatives aux données.

Les autorisations permettant d'accorder un contrôle des accès précis aux stratégies de données et de les gérer sont différentes. Pour contrôler les autorisations de contrôle des accès précis, vous devez mettre à jour le champ grantees de la stratégie de données. Pour contrôler l'accès aux règles relatives aux données, définissez les rôles IAM à l'aide de la méthode setIamPolicy.

Pour définir des bénéficiaires sur une règle de données, utilisez la méthode v2 patch . Pour gérer les autorisations de la stratégie de données, utilisez la méthode v1 setIamPolicy.

API

Pour accorder contrôle des accès précis aux règles de données, appelez la méthode patch et transmettez une ressource DataPolicy avec un champ grantees mis à jour.

SQL

Pour accorder un contrôle des accès précis aux règles de données, utilisez l'instruction GRANT FINE_GRAINED_READ pour ajouter grantees. Exemple :

    GRANT FINE_GRAINED_READ ON DATA_POLICY `myproject.region-us.data_policy_name`
    TO "principal://goog/subject/[e-mail]","principal://goog/subject/[e-mail]"

Pour révoquer l'accès au contrôle des accès ultraprécis à partir des règles de données, utilisez l'instruction REVOKE FINE_GRAINED_READ pour supprimer grantees. Exemple :

    REVOKE FINE_GRAINED_READ ON DATA_POLICY `myproject.region-us.data_policy_name`
    FROM "principal://goog/subject/[e-mail]","principal://goog/subject/[e-mail]"

Supprimer les stratégies de données

L'utilisateur ou le compte de service qui crée une stratégie de données doit disposer de l'autorisation bigquery.dataPolicies.delete. Cette autorisation est incluse dans les rôles d'administrateur de stratégies de données BigQuery, d'administrateur BigQuery et de propriétaire de données BigQuery.

API

Pour supprimer une stratégie de données, appelez la méthode delete.

SQL

Utilisez l'instruction DROP DATA_POLICY pour supprimer une règle de données :

    DROP DATA_POLICY `myproject.region-us.data_policy_name`;

Attribuer une règle de données directement à une colonne

Vous pouvez attribuer une règle de données directement à une colonne sans utiliser de tags avec stratégie.

Avant de commencer

Pour obtenir les autorisations nécessaires pour attribuer une règle de données directement à une colonne, demandez à votre administrateur de vous accorder le rôle IAM Administrateur de règles de données BigQuery (roles/bigquerydatapolicy.admin) sur votre table. Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Ce rôle prédéfini contient les autorisations requises pour attribuer une règle de données directement à une colonne. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour attribuer une règle de données directement à une colonne :

• bigquery.tables.update
• bigquery.tables.setColumnDataPolicy
• bigquery.dataPolicies.attach

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

Attribuer une règle de données

Pour attribuer une règle de données directement à une colonne, effectuez l'une des opérations suivantes :

SQL

Pour associer une stratégie de données à une colonne, utilisez les instructions LDD CREATE TABLE, ALTER TABLE ADD COLUMN ou ALTER COLUMN SET OPTIONS.

L'exemple suivant utilise l'instruction CREATE TABLE et définit des règles de données sur une colonne :

    CREATE TABLE myproject.table1 (
    name INT64 OPTIONS (data_policies=["{'name':'myproject.region-us.data_policy_name1'}",
                                      "{'name':'myproject.region-us.data_policy_name2'}"])
    );

L'exemple suivant utilise ALTER COLUMN SET OPTIONS pour ajouter une règle de données à une colonne existante d'une table :

ALTER TABLE myproject.table1
ALTER COLUMN column_name SET OPTIONS (
  data_policies += ["{'name':'myproject.region-us.data_policy_name1'}",
                    "{'name':'myproject.region-us.data_policy_name2'}"]);

API

Pour attribuer une stratégie de données à une colonne, appelez la méthode patch sur la table et mettez à jour le schéma de la table avec les stratégies de données applicables.

Annuler l'attribution d'une règle de données

Pour dissocier une règle de données directement d'une colonne, effectuez l'une des opérations suivantes :

SQL

Pour dissocier une règle de données d'une colonne, utilisez l'instruction LDD ALTER COLUMN SET OPTIONS.

L'exemple suivant utilise ALTER COLUMN SET OPTIONS pour supprimer toutes les règles de données d'une colonne existante dans une table :

ALTER TABLE myproject.table1
ALTER COLUMN column_name SET OPTIONS (
  data_policies = []);

L'exemple suivant utilise ALTER COLUMN SET OPTIONS pour remplacer les règles de données d'une colonne existante dans une table :

ALTER TABLE myproject.table1
ALTER COLUMN column_name SET OPTIONS (
  data_policies = ["{'name':'myproject.region-us.new_data_policy_name'}"]);

API

Pour dissocier une stratégie de données d'une colonne, appelez la méthode patch sur la table et mettez à jour le schéma de la table avec des stratégies de données vides ou mises à jour.

Limites

L'attribution d'une stratégie de données directement à une colonne est soumise aux limites suivantes :

• Vous devez utiliser la ressource v2.projects.locations.datapolicies.
• Vous ne pouvez pas appliquer à la fois des tags avec stratégie et des règles relatives aux données à la même colonne.
• Vous pouvez associer jusqu'à huit stratégies de données à une colonne.
• Une table peut faire référence à un maximum de 1 000 règles de données uniques via ses colonnes.
• Une requête peut faire référence à un maximum de 2 000 règles de données.
• Vous ne pouvez supprimer une règle de données que si aucune colonne de table ne la référence.
• Si un utilisateur ne dispose que du rôle maskedAccess, l'appel d'API tabledata.list échoue.
• Les opérations de copie de tables protégées par des règles de données de colonne échouent si l'utilisateur n'a pas accès aux données brutes.
• Les opérations de copie de tables interrégionales ne sont pas compatibles avec les tables protégées par des règles de données au niveau des colonnes.
• Les règles de données au niveau des colonnes ne sont pas disponibles dans les régions BigQuery Omni.
• L'ancien SQL échoue si la table cible comporte des règles de données au niveau des colonnes.
• Les jobs de chargement ne sont pas compatibles avec les schémas spécifiés par l'utilisateur qui comportent des règles de données pour les colonnes.
• Si vous écrasez une table de destination, le système supprime tous les tags avec stratégie existants de la table, sauf si vous utilisez l'option --destination_schema pour spécifier un schéma avec des règles de données de colonne.
• Par défaut, le masquage des données n'est pas compatible avec les colonnes partitionnées ou en cluster. Il s'agit d'une limite générale du masquage de données, et non d'une limite spécifique aux règles relatives aux données de colonne. Le masquage de données sur des colonnes partitionnées ou en cluster peut augmenter considérablement les coûts des requêtes.
• Vous ne pouvez pas attribuer de règle de données directement à une colonne dans les tables BigLake pour Apache Iceberg dans BigQuery, les tables d'objets, les tables externes non BigLake, les tables externes Apache Iceberg et Delta Lake.
• L'accès précis ne peut être accordé qu'au niveau de la règle de données. Pour en savoir plus, consultez Mettre à jour les règles relatives aux données.