Mascherare i dati delle colonne

Questo documento mostra come implementare la maschera dei dati per oscurare selettivamente i dati sensibili. Implementando il mascheramento dei dati, puoi fornire diversi livelli di visibilità a gruppi di utenti diversi. Per informazioni generali, consulta Introduzione al mascheramento dei dati.

Per implementare il mascheramento dei dati, aggiungi una norma relativa ai dati a una colonna. Per aggiungere una policy di mascheramento dei dati a una colonna, devi completare i seguenti passaggi :

1. Crea una tassonomia con almeno un tag di criteri.
2. (Facoltativo) Concedi il ruolo Lettore granulare Data Catalog a una o più entità in uno o più tag di criteri che hai creato.
3. Crea fino a tre policy dei dati per il tag di criteri, per mappare le regole di mascheramento e le entità (che rappresentano utenti o gruppi) a quel tag.
4. Imposta il tag di criteri su una colonna. che mappa i criteri relativi ai dati associati altag di criteriy nella colonna selezionata.
5. Assegna agli utenti che devono avere accesso ai dati mascherati il ruolo Lettore mascherato BigQuery. Come best practice, assegna il ruolo Lettore mascherato BigQuery a livello di criteri dei dati. L'assegnazione del ruolo a livello di progetto o superiore concede agli utenti le autorizzazioni per tutti i criteri dei dati del progetto, il che può causare problemi dovuti a un numero eccessivo di autorizzazioni.

Puoi utilizzare la console Google Cloud o l'API BigQuery Data Policy per lavorare con i criteri dei dati.

Una volta completati questi passaggi, gli utenti che eseguono query sulla colonna ricevono dati non mascherati, dati mascherati o un errore di accesso negato, a seconda dei gruppi a cui appartengono e dei ruoli che sono stati loro concessi. Per ulteriori informazioni, vedi Come interagiscono i ruoli Lettore mascherato e Lettore granulare.

In alternativa, puoi applicare le norme sui dati direttamente a una colonna (Anteprima). Per saperne di più, consulta Mascherare i dati con le norme relative ai dati direttamente in una colonna.

Mascherare i dati con i tag di policy

Utilizza i tag di criteri per oscurare selettivamente i dati sensibili.

Prima di iniziare

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 viene attivato automaticamente nei nuovi progetti, ma potresti doverlo attivare in un progetto preesistente.

   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. Se stai creando una policy dei dati che fa riferimento a una routine di mascheramento personalizzata, crea la UDF di mascheramento associata in modo che sia disponibile nei passaggi successivi.

Creazione tassonomie

All'utente o account di servizio che crea una tassonomia deve essere concesso il ruolo Amministratore tag di criteri Data Catalog.

Console

1. Apri la pagina Tassonomie di tag di criteri nella consoleGoogle Cloud .

   Apri la pagina Tassonomie di tag di criteri

2. Fai clic su Crea tassonomia.

3. Nella pagina Nuova tassonomia:

   1. In Nome tassonomia, inserisci il nome della tassonomia che vuoi creare.
   2. In Descrizione, inserisci una descrizione.
   3. Se necessario, modifica il progetto elencato in Progetto.
   4. Se necessario, modifica la posizione elencata in Posizione.
   5. In Tag delle norme, inserisci un nome e una descrizione per tag di criteri.
   6. Per aggiungere un tag di criteri figlio a un tag di criteri, fai clic su Aggiungi tag secondario.
   7. Per aggiungere un nuovo tag di criteri allo stesso livello di un altro tag di criteri, fai clic su + Aggiungi tag di policy.
   8. Continua ad aggiungere tag policy e tag policy figlio in base alle esigenze della tua tassonomia.
   9. Al termine della creazione dei tag criterio per la gerarchia, fai clic su Crea.

API

Per utilizzare le classificazioni esistenti, chiama taxonomies.import al posto dei primi due passaggi della seguente procedura.

1. Chiama taxonomies.create per creare una tassonomia.
2. Chiama taxonomies.policytag.create per creare un tag di criteri.

Utilizzare i tag di policy

Per saperne di più su come utilizzare i tag delle policy, ad esempio come visualizzarli o aggiornarli, consulta Utilizzare i tag delle policy. Per le best practice, consulta Best practice per l'utilizzo dei tag di criteri in BigQuery.

Creare policy sui dati

L'utente o il account di servizio che crea una norma sui dati deve disporre delle autorizzazioni bigquery.dataPolicies.create, bigquery.dataPolicies.setIamPolicy e datacatalog.taxonomies.get.

Le autorizzazioni bigquery.dataPolicies.create e bigquery.dataPolicies.setIamPolicy sono incluse nei ruoli Amministratore policy dei dati BigQuery, Amministratore BigQuery e Proprietario dati BigQuery. L'autorizzazione datacatalog.taxonomies.get è inclusa nei ruoli Amministratore Data Catalog e Visualizzatore Data Catalog.

Se stai creando una policy dei dati che fa riferimento a una routine di mascheramento personalizzata, devi disporre anche delle autorizzazioni per le routine.

In caso di mascheramento personalizzato, concedi agli utenti i ruoli Amministratore BigQuery o Proprietario dati BigQuery per assicurarti che dispongano delle autorizzazioni necessarie per le routine e le norme sui dati.

Puoi creare fino a nove policy dei dati per un tag di criteri. Uno di questi criteri è riservato alle impostazioncontrollo dell'accessoso a livello di colonna.

Console

1. Apri la pagina Tassonomie di tag di criteri nella consoleGoogle Cloud .

   Apri la pagina Tassonomie di tag di criteri

2. Fai clic sul nome della tassonomia da aprire.
3. Seleziona un tag di criteri.
4. Fai clic su Gestisci i criteri relativi ai dati.
5. In Nome della norma sui dati, digita un nome per la norma sui dati. Il nome della norma deve essere univoco all'interno del progetto in cui si trova.
6. Per Regola di mascheramento, scegli una regola di mascheramento predefinita o una routine di mascheramento personalizzata. Se selezioni una routine di mascheramento personalizzata, assicurati di disporre delle autorizzazioni bigquery.routines.get e bigquery.routines.list a livello di progetto.
7. In Entità, digita il nome di uno o più utenti o gruppi a cui vuoi concedere l'accesso mascherato alla colonna. Tieni presente che a tutti gli utenti e i gruppi che inserisci qui viene concesso il ruolo Lettore mascherato BigQuery.
8. Fai clic su Invia.

API

1. Chiama il metodo create. Trasmetti una risorsa DataPolicy che soddisfi i seguenti requisiti:

   • Il campo dataPolicyType è impostato su DATA_MASKING_POLICY.
   • Il campo dataMaskingPolicy identifica la regola o la routine di mascheramento dei dati da utilizzare.
   • Il campo dataPolicyId fornisce un nome per la norma sui dati che è univoco all'interno del progetto in cui si trova la norma sui dati.

2. Chiama il metodo setIamPolicy e trasmetti un Policy. Il Policy deve identificare le entità a cui viene concesso l'accesso ai dati mascherati e specificare roles/bigquerydatapolicy.maskedReader per il campo role.

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Node.js.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client.

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

Imposta i tag di policy sulle colonne

Imposta una policy dei dati su una colonna collegando il tag di criteri associato alla policy dei dati alla colonna.

L'utente o il account di servizio che imposta un tag di criteri deve disporre delle autorizzazioni datacatalog.taxonomies.get e bigquery.tables.setCategory. datacatalog.taxonomies.get è incluso nei ruoli Amministratore tag di policy di Data Catalog e Visualizzatore progetto. bigquery.tables.setCategory è incluso nei ruoli BigQuery Admin (roles/bigquery.admin) e BigQuery Data Owner (roles/bigquery.dataOwner).

Per visualizzare le classificazioni e i tag di policy in tutti i progetti di un'organizzazione nella consoleGoogle Cloud , gli utenti devono disporre dell'autorizzazione resourcemanager.organizations.get, inclusa nel ruolo Visualizzatore organizzazione.

Nota: puoi assegnare un solo tag di criteri per colonna.

Console

Imposta il tag di criteri modificando uno schema utilizzando la consoleGoogle Cloud .

1. Apri la pagina BigQuery nella console Google Cloud .

   Vai alla pagina BigQuery

2. In BigQuery Explorer, individua e seleziona la tabella da aggiornare. Si apre lo schema della tabella.

3. Fai clic su Modifica schema.

4. Nella schermata Schema attuale, seleziona la colonna di destinazione e fai clic su Aggiungi tag di policy.

5. Nella schermata Aggiungi un tag di policy, individua e seleziona il tag di criteri che vuoi applicare alla colonna.

6. Fai clic su Seleziona. La schermata dovrebbe essere simile a questa:

   

7. Fai clic su Salva.

bq

1. Scrivi lo schema in un file locale.

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

   dove:

   • project-id è l'ID progetto.
   • dataset è il nome del set di dati contenente la tabella che stai aggiornando.
   • table è il nome della tabella che stai aggiornando.

2. Modifica schema.json per impostare un tag di criteri su una colonna. Per il valore del campo names di policyTags, utilizza il nome risorsa del tag policy.

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

3. Aggiorna lo schema.

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

API

Per le tabelle esistenti, chiama il numero tables.patch o, per le nuove tabelle, chiama il numero tables.insert. Utilizza la proprietà schema dell'oggetto Table che trasmetti per impostare un tag di criteri nella definizione dello schema. Consulta lo schema dell'esempio di riga di comando per scoprire come impostare untag di criteriy.

Quando lavori con una tabella esistente, è preferibile il metodo tables.patch, perché il metodo tables.update sostituisce l'intera risorsa tabella.

Applica controllo di accesso

Quando crei una norma sui dati per un tag di criteri, controllo dell'accesso viene applicato automaticamente. Tutte le colonne a cui è applicato questo tag di criteri restituiscono dati mascherati in risposta alle query degli utenti che hanno il ruolo Lettore mascherato.

Per interrompere l'applicazione del controllo dell'accesso, devi prima eliminare tutti i criteri dei dati associati ai tag criterio nella tassonomia. Per saperne di più, consulta Applicare il controllo dell'accesso.

Ottenere una norma sui dati

Per ottenere informazioni su una norma relativa ai dati:

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Node.js.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client.

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

Controlla le autorizzazioni IAM per una norma sui dati

Segui questi passaggi per ottenere il criterio IAM per una norma sui dati:

API

Chiama il metodo testIamPermissions.

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Node.js.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client.

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

Elenca le norme sui dati

Per elencare le norme relative ai dati:

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Node.js.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client.

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

Aggiornare le norme relative ai dati

L'utente o il account di servizio che aggiorna una norma sui dati deve disporre dell'autorizzazione bigquery.dataPolicies.update. Se stai aggiornando il tag di criteri a cui sono associati i criteri relativi ai dati, devi disporre anche dell'autorizzazione datacatalog.taxonomies.get.

Se stai aggiornando i principali associati alle norme sui dati, devi disporre dell'autorizzazione bigquery.dataPolicies.setIamPolicy.

Le autorizzazioni bigquery.dataPolicies.update e bigquery.dataPolicies.setIamPolicy sono incluse nei ruoli Amministratore policy dei dati BigQuery, Amministratore BigQuery e Proprietario dati BigQuery. L'autorizzazione datacatalog.taxonomies.get è inclusa nei ruoli Amministratore Data Catalog e Visualizzatore Data Catalog.

Console

1. Apri la pagina Tassonomie di tag di criteri nella consoleGoogle Cloud .

   Apri la pagina Tassonomie di tag di criteri

2. Fai clic sul nome della tassonomia da aprire.
3. Seleziona un tag di criteri.
4. Fai clic su Gestisci i criteri relativi ai dati.
5. (Facoltativo) Modifica la regola di mascheramento.
6. (Facoltativo) Aggiungi o rimuovi i principal.
7. Fai clic su Invia.

API

Per modificare la regola di mascheramento dei dati, chiama il metodo patch e trasmetti una risorsa DataPolicy con un campo dataMaskingPolicy aggiornato.

Per modificare le entità associate a una policy dei dati, chiama il metodo setIamPolicy e passa un Policy che aggiorna le entità a cui viene concesso l'accesso ai dati mascherati.

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Node.js.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client.

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

Eliminare i criteri relativi ai dati

L'utente o il account di servizio che crea un criterio dei dati deve disporre dell'autorizzazione bigquery.dataPolicies.delete. Questa autorizzazione è inclusa nei ruoli Amministratore policy dei dati BigQuery, Amministratore BigQuery e Proprietario dati BigQuery.

Console

1. Apri la pagina Tassonomie di tag di criteri nella consoleGoogle Cloud .

   Apri la pagina Tassonomie di tag di criteri

2. Fai clic sul nome della tassonomia da aprire.
3. Seleziona un tag di criteri.
4. Fai clic su Gestisci i criteri relativi ai dati.
5. Fai clic su accanto al criterio relativo ai dati da eliminare.
6. Fai clic su Invia.
7. Fai clic su Conferma.

API

Per eliminare un criterio relativo ai dati, chiama il metodo delete.

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Node.js.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di BigQuery per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API BigQuery Python.

Per eseguire l'autenticazione in BigQuery, configura le Credenziali predefinite dell'applicazione. Per saperne di più, vedi Configurare l'autenticazione per le librerie client.

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

Mascherare i dati applicando criteri relativi ai dati a una colonna

Anteprima

Questo prodotto o funzionalità è soggetto ai "Termini delle offerte pre-GA" nella sezione Termini di servizio generali dei Termini specifici dei servizi. I prodotti e le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per ulteriori informazioni, consulta le descrizioni delle fasi di lancio.

Nota: per fornire un feedback o richiedere assistenza per questa funzionalità, invia un'email all'indirizzo [e-mail].

In alternativa alla creazione di tag di criteri, puoi creare criteri relativi ai dati e applicarli direttamente a una colonna.

Utilizzare le norme relative ai dati

Puoi creare, aggiornare ed eliminare criteri dei dati utilizzando l'API BigQuery Data Policy. Per applicare una norma sui dati direttamente a una colonna, non puoi utilizzare la pagina Tassonomie dei tag delle norme nella console Google Cloud .

Per lavorare con le norme sui dati, utilizza la risorsa v2.projects.locations.datapolicies.

Creare policy sui dati

L'utente o il account di servizio che crea una norma sui dati deve disporre dell'autorizzazione bigquery.dataPolicies.create.

L'autorizzazione bigquery.dataPolicies.create è inclusa nei ruoli Amministratore policy dei dati BigQuery, Amministratore BigQuery e Proprietario dati BigQuery. L'autorizzazione datacatalog.taxonomies.get è inclusa nei ruoli Amministratore Data Catalog e Visualizzatore Data Catalog.

Se stai creando una policy dei dati che fa riferimento a una routine di mascheramento personalizzata, devi disporre anche delle autorizzazioni per le routine.

Se utilizzi il mascheramento personalizzato, assegna agli utenti il ruolo Proprietario dati BigQuery per assicurarti che dispongano delle autorizzazioni necessarie sia per le routine sia per le norme sui dati.

API

Per creare una norma sui dati, chiama il metodo create. Trasmetti una risorsa DataPolicy che soddisfi i seguenti requisiti:

• Il campo dataPolicyType è impostato su DATA_MASKING_POLICY o RAW_DATA_ACCESS_POLICY.
• Il campo dataMaskingPolicy identifica la regola o la routine di mascheramento dei dati da utilizzare.
• Il campo dataPolicyId fornisce un nome per la norma sui dati univoco all'interno del progetto in cui si trova la norma sui dati.

SQL

Per creare un criterio dei dati con accesso mascherato, utilizza l'istruzione CREATE DATA_POLICY e imposta il valore di data_policy_type su 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"
    );

Per creare una policy dei dati con accesso non elaborato, utilizza l'istruzione CREATE DATA_POLICY e imposta il valore di data_policy_type su 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 il valore di data_policy_type non è specificato, il valore predefinito è RAW_DATA_ACCESS_POLICY.

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

• Il campo data_policy_type è impostato su DATA_MASKING_POLICY o RAW_DATA_ACCESS_POLICY. Non puoi aggiornare questo campo dopo la creazione della norma sui dati.
• Il campo masking_expression identifica la regola o la routine di mascheramento dei dati da utilizzare.

Aggiornare le norme relative ai dati

L'utente o il account di servizio che aggiorna una norma sui dati deve disporre dell'autorizzazione bigquery.dataPolicies.update.

L'autorizzazione bigquery.dataPolicies.update è inclusa nei ruoli Amministratore policy dei dati BigQuery, Amministratore BigQuery e Proprietario dati BigQuery.

API

Per modificare la regola di mascheramento dei dati, chiama il metodo patch e trasmetti una risorsa DataPolicy con un campo dataMaskingPolicy aggiornato.

SQL

Utilizza l'istruzione ALTER DATA_POLICY per aggiornare le regole di mascheramento dei dati. Ad esempio:

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

Puoi anche concedere l'controllo dell'accesso dell'accesso granulare alle norme sui dati.

Le autorizzazioni per concedere l'accesso al controllo dell'accesso granulare ai criteri relativi ai dati e per gestire i criteri relativi ai dati sono diverse. Per controllare le autorizzazioni di controllo dell'accesso granulare, devi aggiornare il campo grantees della policy dei dati. Per controllare l'accesso alle norme sui dati, imposta i ruoli IAM utilizzando il metodo setIamPolicy.

Per impostare i beneficiari di una policy sui dati, utilizza il metodo patch v2 . Per gestire le autorizzazioni dei criteri relativi ai dati, utilizza il metodo v1 setIamPolicy.

API

Per concedere l'controllo dell'accesso dell'accesso granulare alle norme sui dati, chiama il metodo patch e trasmetti una risorsa DataPolicy con un campo grantees aggiornato.

SQL

Per concedere l'controllo dell'accesso dell'accesso granulare alle policy dei dati, utilizza l'istruzione GRANT FINE_GRAINED_READ per aggiungere grantees. Ad esempio:

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

Per revocare l'accesso controllo dell'accesso granulare dalle norme sui dati, utilizza l'istruzione REVOKE FINE_GRAINED_READ per rimuovere grantees. Ad esempio:

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

Eliminare i criteri relativi ai dati

L'utente o il account di servizio che crea una norma sui dati deve disporre dell'autorizzazione bigquery.dataPolicies.delete. Questa autorizzazione è inclusa nei ruoli Amministratore policy dei dati BigQuery, Amministratore BigQuery e Proprietario dati BigQuery.

API

Per eliminare un criterio relativo ai dati, chiama il metodo delete.

SQL

Utilizza l'istruzione DROP DATA_POLICY per eliminare un criterio dei dati:

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

Assegnare una norma sui dati direttamente a una colonna

Puoi assegnare un criterio dei dati direttamente a una colonna senza utilizzare i tag di criteri.

Prima di iniziare

Per ottenere le autorizzazioni necessarie per assegnare una policy dei dati direttamente a una colonna, chiedi all'amministratore di concederti il ruolo IAM BigQuery Data Policy Admin (roles/bigquerydatapolicy.admin) nella tabella. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene le autorizzazioni necessarie per assegnare una policy dei dati direttamente a una colonna. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per assegnare una policy dei dati direttamente a una colonna sono necessarie le seguenti autorizzazioni:

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

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Assegnare una policy dei dati

Per assegnare una norma sui dati direttamente a una colonna, esegui una delle seguenti operazioni:

SQL

Per collegare un criterio dei dati a una colonna, utilizza le istruzioni DDL CREATE TABLE, ALTER TABLE ADD COLUMN o ALTER COLUMN SET OPTIONS.

L'esempio seguente utilizza l'istruzione CREATE TABLE e imposta i criteri per i dati su una colonna:

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

L'esempio seguente utilizza ALTER COLUMN SET OPTIONS per aggiungere una norma sui dati a una colonna esistente di una tabella:

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

Per assegnare un criterio di gestione dei dati a una colonna, chiama il metodo patch nella tabella e aggiorna lo schema della tabella con i criteri di gestione dei dati applicabili.

Annullare l'assegnazione di una policy sui dati

Per annullare l'assegnazione di una policy di dati direttamente a una colonna, esegui una delle seguenti operazioni:

SQL

Per scollegare un criterio di dati a una colonna, utilizza l'istruzione DDL ALTER COLUMN SET OPTIONS.

L'esempio seguente utilizza ALTER COLUMN SET OPTIONS per rimuovere tutte le norme sui dati da una colonna esistente di una tabella:

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

L'esempio seguente utilizza ALTER COLUMN SET OPTIONS per sostituire le norme sui dati di una colonna esistente in una tabella:

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

API

Per annullare l'assegnazione di una norma sui dati a una colonna, chiama il metodo patch sulla tabella e aggiorna lo schema della tabella con norme sui dati vuote o aggiornate.

Limitazioni

L'assegnazione di una policy dei dati direttamente a una colonna è soggetta alle seguenti limitazioni:

• Devi utilizzare la risorsa v2.projects.locations.datapolicies.
• Non puoi applicare sia i tag di policy sia le policy dei dati alla stessa colonna.
• Puoi allegare un massimo di otto norme sui dati a una colonna.
• Una tabella può fare riferimento a un massimo di 1000 policy dei dati univoche tramite le sue colonne.
• Una query può fare riferimento a un massimo di 2000 policy dei dati.
• Puoi eliminare una norma sui dati solo se non viene fatto riferimento a nessuna colonna della tabella.
• Se un utente ha solo il ruolo maskedAccess, la chiamata API tabledata.list non riesce.
• Le operazioni di copia delle tabelle non riescono sulle tabelle protette da policy sui dati delle colonne se l'utente non ha accesso ai dati non elaborati.
• Le operazioni di copia delle tabelle tra regioni diverse non supportano le tabelle protette da criteri per i dati delle colonne.
• Le policy dei dati delle colonne non sono disponibili nelle regioni BigQuery Omni.
• Legacy SQL non riesce se la tabella di destinazione ha policy dei dati delle colonne.
• I job di caricamento non supportano gli schemi specificati dall'utente con norme sui dati delle colonne.
• Se sovrascrivi una tabella di destinazione, il sistema rimuove tutti i tag dei criteri esistenti dalla tabella, a meno che tu non utilizzi il flag --destination_schema per specificare uno schema con criteri relativi ai dati delle colonne.
• Per impostazione predefinita, il mascheramento dei dati non supporta le colonne partizionate o in cluster. Si tratta di una limitazione generale del mascheramento dei dati, non specifica per le policy relative ai dati delle colonne. La maschera dei dati nelle colonne partizionate o in cluster può aumentare significativamente i costi delle query.
• Non puoi assegnare una norma sui dati direttamente a una colonna nelle tabelle BigLake per Apache Iceberg in BigQuery, nelle tabelle degli oggetti, nelle tabelle esterne non BigLake, nelle tabelle esterne Apache Iceberg e in Delta Lake.
• L'accesso granulare può essere concesso solo a livello di norma sui dati. Per ulteriori informazioni, consulta Aggiornamenti delle norme relative ai dati.