Mascare os dados das colunas

Este documento mostra como implementar a ocultação de dados para ocultar seletivamente dados confidenciais. Ao implementar a ocultação de dados, pode fornecer diferentes níveis de visibilidade a diferentes grupos de utilizadores. Para obter informações gerais, consulte o artigo Introdução à ocultação de dados.

Implementa a ocultação de dados adicionando uma política de dados a uma coluna. Para adicionar uma política de ocultação de dados a uma coluna, tem de concluir os seguintes passos :

  1. Crie uma taxonomia com, pelo menos, uma etiqueta de política.
  2. Opcional: conceda a função Leitor detalhado do catálogo de dados a um ou mais responsáveis em uma ou mais das etiquetas de políticas que criou.
  3. Crie até três políticas de dados para a etiqueta de política, de modo a mapear regras de ocultação e responsáveis (que representam utilizadores ou grupos) para essa etiqueta.
  4. Defina a etiqueta de política numa coluna. Que mapeia as políticas de dados associadas à etiqueta de política para a coluna selecionada.
  5. Atribua aos utilizadores que devem ter acesso aos dados ocultados a função de leitor ocultado do BigQuery. Como prática recomendada, atribua a função de leitor com máscara do BigQuery ao nível da política de dados. A atribuição da função ao nível do projeto ou superior concede aos utilizadores autorizações para todas as políticas de dados no âmbito do projeto, o que pode originar problemas causados por autorizações excessivas.

Pode usar a Google Cloud consola ou a API BigQuery Data Policy para trabalhar com políticas de dados.

Quando concluir estes passos, os utilizadores que executam consultas na coluna recebem dados não ocultados, dados ocultados ou um erro de acesso negado, consoante os grupos aos quais pertencem e as funções que lhes foram concedidas. Para mais informações, consulte o artigo Como interagem as funções de leitor oculto e leitor detalhado.

Em alternativa, pode aplicar políticas de dados diretamente numa coluna (Pré-visualização). Para mais informações, consulte o artigo Mascare dados com políticas de dados diretamente numa coluna.

Mascare dados com etiquetas de políticas

Use etiquetas de políticas para ocultar seletivamente dados confidenciais.

Antes de começar

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

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

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

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

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

    Go to project selector

  6. Verify that billing is enabled for your Google Cloud project.

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

    8.
  8. O BigQuery é ativado automaticamente em novos projetos, mas pode ter de o ativar num projeto pré-existente.

    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

  9. Se estiver a criar uma política de dados que faça referência a uma rotina de ocultação personalizada, crie a UDF de ocultação associada para que esteja disponível nos seguintes passos.

    10. Crie taxonomias

    O utilizador ou a conta de serviço que cria uma taxonomia tem de receber a função de administrador de etiquetas de políticas do Data Catalog.

    Consola

    1. Abra a página Taxonomias de etiquetas de políticas na Google Cloud consola.

      Abra a página Taxonomias de etiquetas de políticas

    2. Clique em Criar taxonomia.

    3. Na página Nova taxonomia:

      1. Em Nome da taxonomia, introduza o nome da taxonomia que quer criar.
      2. Em Descrição, introduza uma descrição.
      3. Se necessário, altere o projeto apresentado em Projeto.
      4. Se necessário, altere a localização apresentada em Localização.
      5. Em Etiquetas de políticas, introduza um nome e uma descrição para a etiqueta de política.
      6. Para adicionar uma etiqueta de política secundária a uma etiqueta de política, clique em Adicionar subetiqueta.
      7. Para adicionar uma nova etiqueta de política ao mesmo nível que outra etiqueta de política, clique em + Adicionar etiqueta de política.
      8. Continue a adicionar etiquetas de políticas e etiquetas de políticas para crianças conforme necessário para a sua taxonomia.
      9. Quando terminar de criar etiquetas de políticas para a sua hierarquia, clique em Criar.

    API

    Para usar taxonomias existentes, chame taxonomies.import em vez dos dois primeiros passos do procedimento seguinte.

    1. Ligue taxonomies.create para criar uma taxonomia.
    2. Chame taxonomies.policytag.create para criar uma etiqueta de política.

    Trabalhe com etiquetas de políticas

    Para mais informações sobre como trabalhar com etiquetas de políticas, como visualizá-las ou atualizá-las, consulte o artigo Trabalhe com etiquetas de políticas. Para ver as práticas recomendadas, consulte o artigo Práticas recomendadas para usar etiquetas de políticas no BigQuery.

    Crie políticas de dados

    A conta de utilizador ou de serviço que cria uma política de dados tem de ter as autorizações bigquery.dataPolicies.create, bigquery.dataPolicies.setIamPolicy e datacatalog.taxonomies.get.

    As autorizações bigquery.dataPolicies.create e bigquery.dataPolicies.setIamPolicy estão incluídas nas funções de administrador da política de dados do BigQuery, administrador do BigQuery e proprietário de dados do BigQuery. A autorização datacatalog.taxonomies.get está incluída nas funções de administrador e leitor do Data Catalog.

    Se estiver a criar uma política de dados que faça referência a uma rotina de ocultação personalizada, também precisa de autorizações de rotina.

    No caso da ocultação personalizada, conceda aos utilizadores as funções de administrador do BigQuery ou proprietário de dados do BigQuery para garantir que têm as autorizações necessárias para as rotinas e as políticas de dados.

    Pode criar até nove políticas de dados para uma etiqueta de política. Uma destas políticas está reservada para definições de controlo de acesso ao nível da coluna.

    Consola

    1. Abra a página Taxonomias de etiquetas de políticas na Google Cloud consola.

      Abra a página Taxonomias de etiquetas de políticas

    2. Clique no nome da taxonomia para a abrir.
    3. Selecione uma etiqueta de política.
    4. Clique em Gerir políticas de dados.
    5. Em Nome da política de dados, escreva um nome para a política de dados. O nome da política de dados tem de ser exclusivo no projeto em que a política de dados reside.
    6. Para Regra de ocultação, escolha uma regra de ocultação predefinida ou uma rotina de ocultação personalizada. Se estiver a selecionar uma rotina de ocultação personalizada, certifique-se de que tem as autorizações bigquery.routines.get e bigquery.routines.list ao nível do projeto.
    7. Para Principal, escreva o nome de um ou mais utilizadores ou grupos aos quais quer conceder acesso oculto à coluna. Tenha em atenção que todos os utilizadores e grupos que introduzir aqui recebem a função de leitor com dados ocultados do BigQuery.
    8. Clique em Enviar.

    API

    1. Chame o método create. Transmita um recurso que cumpra os seguintes requisitos:DataPolicy

      • O campo dataPolicyType está definido como DATA_MASKING_POLICY.
      • O campo dataMaskingPolicy identifica a regra de ocultação de dados ou a rotina a usar.
      • O campo dataPolicyId fornece um nome para a política de dados que é exclusivo no projeto em que a política de dados reside.

    2. Chame o método setIamPolicy e transmita um Policy. O Policy tem de identificar os principais aos quais é concedido acesso aos dados ocultados e especificar roles/bigquerydatapolicy.maskedReader para o campo role.

    Node.js

    Antes de experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Node.js BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

    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

    Antes de experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Python BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

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

    Defina etiquetas de políticas nas colunas

    Defina uma política de dados numa coluna anexando a etiqueta de política associada à política de dados à coluna.

    O utilizador ou a conta de serviço que define uma etiqueta de política precisa das autorizações datacatalog.taxonomies.get e bigquery.tables.setCategory. datacatalog.taxonomies.get está incluída nas funções de administrador de etiquetas de políticas do Data Catalog e visualizador de projetos. bigquery.tables.setCategory está incluída nas funções de administrador do BigQuery (roles/bigquery.admin) e proprietário de dados do BigQuery (roles/bigquery.dataOwner).

    Para ver taxonomias e etiquetas de políticas em todos os projetos de uma organização na Google Cloud consola, os utilizadores precisam da autorização resourcemanager.organizations.get, que está incluída na função Visualizador da organização.

    Consola

    Defina a etiqueta de política modificando um esquema através daGoogle Cloud consola.

    1. Abra a página do BigQuery na Google Cloud consola.

      Aceda à página do BigQuery

    2. No explorador do BigQuery, localize e selecione a tabela que quer atualizar. É apresentado o esquema da tabela.

    3. Clique em Editar esquema.

    4. No ecrã Esquema atual, selecione a coluna de destino e clique em Adicionar etiqueta de política.

    5. No ecrã Adicione uma etiqueta de política, localize e selecione a etiqueta de política que quer aplicar à coluna.

    6. Clique em Selecionar. O seu ecrã deve ser semelhante ao seguinte:

      Editar esquema.

    7. Clique em Guardar.

    bq

    1. Escreva o esquema num ficheiro local.

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

      where:

      • project-id é o ID do seu projeto.
      • dataset é o nome do conjunto de dados que contém a tabela que está a atualizar.
      • table é o nome da tabela que está a atualizar.

    2. Modifique o ficheiro schema.json para definir uma etiqueta de política numa coluna. Para o valor do campo names de policyTags, use o nome do recurso da etiqueta de política.

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

    3. Atualize o esquema.

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

    API

    Para tabelas existentes, ligue para tables.patch ou, para novas tabelas, ligue para tables.insert. Use a propriedade schema do objeto Table que transmite para definir uma etiqueta de política na definição do esquema. Consulte o esquema do exemplo de linha de comandos para ver como definir uma etiqueta de política.

    Quando trabalha com uma tabela existente, o método tables.patch é preferível, porque o método tables.update substitui todo o recurso da tabela.

    Aplique o controlo de acesso

    Quando cria uma política de dados para uma etiqueta de política, o controlo de acesso é aplicado automaticamente. Todas as colunas às quais essa etiqueta de política é aplicada devolvem dados ocultados em resposta a consultas de utilizadores que têm a função de leitor ocultado.

    Para parar a aplicação do controlo de acesso, tem de eliminar primeiro todas as políticas de dados associadas às etiquetas de políticas na taxonomia. Para mais informações, consulte o artigo Aplique o controlo de acesso.

    Obtenha uma política de dados

    Siga estes passos para obter informações sobre uma política de dados:

    Node.js

    Antes de experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Node.js BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

    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

    Antes de experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Python BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

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

    Verifique as autorizações de IAM numa política de dados

    Siga estes passos para obter a política de IAM de uma política de dados:

    API

    Chame o método testIamPermissions.

    Node.js

    Antes de experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Node.js BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

    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

    Antes de experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Python BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

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

    Indique políticas de dados

    Siga estes passos para listar as políticas de dados:

    Node.js

    Antes de experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Node.js BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

    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

    Antes de experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Python BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

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

    Atualize as políticas de dados

    O utilizador ou a conta de serviço que atualiza uma política de dados tem de ter a autorização bigquery.dataPolicies.update. Se estiver a atualizar a etiqueta de política à qual a política de dados está associada, também precisa da autorização datacatalog.taxonomies.get.

    Se estiver a atualizar os responsáveis associados à política de dados, precisa da autorização bigquery.dataPolicies.setIamPolicy.

    As autorizações bigquery.dataPolicies.update e bigquery.dataPolicies.setIamPolicy estão incluídas nas funções de administrador da política de dados do BigQuery, administrador do BigQuery e proprietário de dados do BigQuery. A autorização datacatalog.taxonomies.get está incluída nas funções de administrador e leitor do Data Catalog.

    Consola

    1. Abra a página Taxonomias de etiquetas de políticas na Google Cloud consola.

      Abra a página Taxonomias de etiquetas de políticas

    2. Clique no nome da taxonomia para a abrir.
    3. Selecione uma etiqueta de política.
    4. Clique em Gerir políticas de dados.
    5. Opcionalmente, altere a regra de ocultação.
    6. Opcional: adicione ou remova diretores.
    7. Clique em Enviar.

    API

    Para alterar a regra de ocultação de dados, chame o método patch e transmita um recurso DataPolicy com um campo dataMaskingPolicy atualizado.

    Para alterar os principais associados a uma política de dados, chame o método setIamPolicy e transmita um Policy que atualiza os principais aos quais é concedido acesso a dados ocultados.

    Node.js

    Antes de experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Node.js BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

    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

    Antes de experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Python BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

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

    Elimine políticas de dados

    O utilizador ou a conta de serviço que cria uma política de dados tem de ter a autorização bigquery.dataPolicies.delete. Esta autorização está incluída nas funções de administrador da política de dados do BigQuery, administrador do BigQuery e proprietário de dados do BigQuery.

    Consola

    1. Abra a página Taxonomias de etiquetas de políticas na Google Cloud consola.

      Abra a página Taxonomias de etiquetas de políticas

    2. Clique no nome da taxonomia para a abrir.
    3. Selecione uma etiqueta de política.
    4. Clique em Gerir políticas de dados.
    5. Clique em junto à política de dados que quer eliminar.
    6. Clique em Enviar.
    7. Clique em Confirm.

    API

    Para eliminar uma política de dados, chame o método delete.

    Node.js

    Antes de experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Node.js BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

    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

    Antes de experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Python BigQuery documentação de referência.

    Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente. 

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

    Aplique políticas de dados a uma coluna para mascarar dados

    Em alternativa à criação de etiquetas de políticas, pode criar políticas de dados e aplicá-las diretamente numa coluna.

    Trabalhe com políticas de dados

    Pode criar, atualizar e eliminar políticas de dados através da API BigQuery Data Policy. Para aplicar uma política de dados diretamente numa coluna, não pode usar a página Taxonomias de etiquetas de políticas na Google Cloud consola.

    Para trabalhar com políticas de dados, use o recurso v2.projects.locations.datapolicies.

    Crie políticas de dados

    O utilizador ou a conta de serviço que cria uma política de dados tem de ter a autorização bigquery.dataPolicies.create.

    A autorização bigquery.dataPolicies.create está incluída nas funções de administrador da política de dados do BigQuery, administrador do BigQuery e proprietário de dados do BigQuery. A autorização datacatalog.taxonomies.get está incluída nas funções de administrador e leitor do Data Catalog.

    Se estiver a criar uma política de dados que faça referência a uma rotina de ocultação personalizada, também precisa de autorizações de rotina.

    Se usar a ocultação personalizada, conceda aos utilizadores a função de proprietário de dados do BigQuery para garantir que têm as autorizações necessárias para rotinas e políticas de dados.

    API

    Para criar uma política de dados, chame o método create. Transmita um recurso DataPolicy que cumpra os seguintes requisitos:

    • O campo dataPolicyType está definido como DATA_MASKING_POLICY ou RAW_DATA_ACCESS_POLICY.
    • O campo dataMaskingPolicy identifica a regra de ocultação de dados ou a rotina a usar.
    • O campo dataPolicyId fornece um nome para a política de dados que é exclusivo no projeto em que a política de dados reside.

    SQL

    Para criar uma política de dados com acesso oculto, use a declaração CREATE DATA_POLICY e defina o valor de data_policy_type como 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"
    );

    Para criar uma política de dados com acesso não processado, use a declaração CREATE DATA_POLICY e defina o valor de data_policy_type como 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");

    Se o valor de data_policy_type não for especificado, o valor predefinido é RAW_DATA_ACCESS_POLICY. 

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

    • O campo data_policy_type está definido como DATA_MASKING_POLICY ou RAW_DATA_ACCESS_POLICY. Não pode atualizar este campo depois de criar a política de dados.
    • O campo masking_expression identifica a regra de ocultação de dados ou a rotina a usar.

    Atualize as políticas de dados

    O utilizador ou a conta de serviço que atualiza uma política de dados tem de ter a autorização bigquery.dataPolicies.update.

    A autorização bigquery.dataPolicies.update está incluída nas funções de administrador da política de dados do BigQuery, administrador do BigQuery e proprietário de dados do BigQuery.

    API

    Para alterar a regra de ocultação de dados, chame o método patch e transmita um recurso DataPolicy com um campo dataMaskingPolicy atualizado.

    SQL

    Use a declaração ALTER DATA_POLICY para atualizar as regras de ocultação de dados. Por exemplo:

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

    Também pode conceder acesso de controlo de acesso detalhado a políticas de dados.

    As autorizações para conceder acesso de controlo detalhado às políticas de dados e gerir políticas de dados são diferentes. Para controlar as autorizações de controlo de acesso detalhado, tem de atualizar o campo grantees da política de dados. Para controlar o acesso às políticas de dados, defina as funções do IAM através do método setIamPolicy.

    Para definir beneficiários numa política de dados, use o método v2 patch . Para gerir as autorizações da política de dados, use o método v1 setIamPolicy.

    API

    Para conceder acesso de controlo de acesso detalhado às políticas de dados, chame o método patch e transmita um recurso DataPolicy com um campo grantees atualizado.

    SQL

    Para conceder acesso de controlo de acesso detalhado às políticas de dados, use a declaração GRANT FINE_GRAINED_READ para adicionar grantees. Por exemplo:

        GRANT FINE_GRAINED_READ ON DATA_POLICY `myproject.region-us.data_policy_name`
    TO "principal://goog/subject/user1@example.com","principal://goog/subject/user2@example.com"

    Para revogar o acesso de controlo de acesso detalhado das políticas de dados, use a declaração REVOKE FINE_GRAINED_READ para remover grantees. Por exemplo:

        REVOKE FINE_GRAINED_READ ON DATA_POLICY `myproject.region-us.data_policy_name`
    FROM "principal://goog/subject/user1@example.com","principal://goog/subject/user2@example.com"

    Elimine políticas de dados

    O utilizador ou a conta de serviço que cria uma política de dados tem de ter a autorização bigquery.dataPolicies.delete. Esta autorização está incluída nas funções de administrador da política de dados do BigQuery, administrador do BigQuery e proprietário de dados do BigQuery.

    API

    Para eliminar uma política de dados, chame o método delete.

    SQL

    Use a declaração DROP DATA_POLICY para eliminar uma política de dados:

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

    Atribua uma política de dados diretamente a uma coluna

    Pode atribuir uma política de dados diretamente a uma coluna sem usar etiquetas de políticas.

    Antes de começar

    Para obter as autorizações de que precisa para atribuir uma política de dados diretamente a uma coluna, peça ao seu administrador para lhe conceder a função do IAM administrador de políticas de dados do BigQuery (roles/bigquerydatapolicy.admin) na sua tabela. Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

    Esta função predefinida contém as autorizações necessárias para atribuir uma política de dados diretamente a uma coluna. Para ver as autorizações exatas que são necessárias, expanda a secção Autorizações necessárias:

    Autorizações necessárias

    São necessárias as seguintes autorizações para atribuir uma política de dados diretamente a uma coluna:

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

    Também pode conseguir estas autorizações com funções personalizadas ou outras funções predefinidas.

    Atribua uma política de dados

    Para atribuir uma política de dados diretamente a uma coluna, faça uma das seguintes ações:

    SQL

    Para anexar uma política de dados a uma coluna, use as declarações DDL CREATE TABLE, ALTER TABLE ADD COLUMN> ou ALTER COLUMN SET OPTIONS.

    O exemplo seguinte usa a declaração CREATE TABLE e define políticas de dados numa coluna:

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

    O exemplo seguinte usa o ALTER COLUMN SET OPTIONS para adicionar uma política de dados a uma coluna existente numa tabela:

    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

    Para atribuir uma política de dados a uma coluna, chame o método patch na tabela e atualize o esquema da tabela com as políticas de dados aplicáveis.

    Desassocie uma política de dados

    Para anular a atribuição de uma política de dados diretamente numa coluna, faça uma das seguintes ações:

    SQL

    Para desanexar uma política de dados a uma coluna, use a declaração DDL ALTER COLUMN SET OPTIONS.

    O exemplo seguinte usa o ALTER COLUMN SET OPTIONS para remover todas as políticas de dados de uma coluna existente numa tabela:

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

    O exemplo seguinte usa o ALTER COLUMN SET OPTIONS para substituir políticas de dados de uma coluna existente numa tabela:

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

    API

    Para anular a atribuição de uma política de dados a uma coluna, chame o método patch na tabela e atualize o esquema da tabela com políticas de dados vazias ou atualizadas.

    Limitações

    A atribuição de uma política de dados diretamente a uma coluna está sujeita às seguintes limitações:

    • Tem de usar o recurso v2.projects.locations.datapolicies.
    • Não é possível aplicar etiquetas de políticas e políticas de dados à mesma coluna.
    • Pode anexar um máximo de oito políticas de dados a uma coluna.
    • Uma tabela pode fazer referência a um máximo de 1000 políticas de dados únicas através das respetivas colunas.
    • Uma consulta pode referenciar um máximo de 2000 políticas de dados.
    • Só pode eliminar uma política de dados se nenhuma coluna da tabela fizer referência à mesma.
    • Se um utilizador tiver apenas a função maskedAccess, a chamada da API tabledata.list falha.
    • As operações de cópia de tabelas falham em tabelas protegidas por políticas de dados de colunas se o utilizador não tiver acesso aos dados não processados.
    • As operações de cópia de tabelas entre regiões não suportam tabelas protegidas por políticas de dados ao nível da coluna.
    • As políticas de dados ao nível da coluna não estão disponíveis nas regiões do BigQuery Omni.
    • O SQL antigo falha se a tabela de destino tiver políticas de dados de colunas.
    • Os trabalhos de carregamento não suportam esquemas especificados pelo utilizador com políticas de dados de colunas.
    • Se substituir uma tabela de destino, o sistema remove todas as etiquetas de políticas existentes da tabela, a menos que use a flag --destination_schema para especificar um esquema com políticas de dados de colunas.
    • Por predefinição, a ocultação de dados não suporta colunas particionadas ou agrupadas. Esta é uma limitação geral da ocultação de dados e não é específica das políticas de dados de colunas. A ocultação de dados em colunas particionadas ou agrupadas pode aumentar significativamente os custos das consultas.
    • Não pode atribuir uma política de dados diretamente a uma coluna em tabelas do BigLake para Apache Iceberg no BigQuery, tabelas de objetos, tabelas externas não pertencentes ao BigLake, tabelas externas do Apache Iceberg e Delta Lake.
    • O acesso detalhado só pode ser concedido ao nível da política de dados. Para mais informações, consulte o artigo Atualize as políticas de dados.