Controlar el acceso a los recursos con la gestión de identidades y accesos

En este documento se describe cómo ver, conceder y revocar controles de acceso para conjuntos de datos de BigQuery y para los recursos de los conjuntos de datos: tablas, vistas y rutinas. Aunque los modelos también son recursos a nivel de conjunto de datos, no puedes conceder acceso a modelos concretos mediante roles de gestión de identidades y accesos.

Puedes conceder acceso a los Google Cloud recursos mediante políticas de permiso, también conocidas como políticas de Gestión de Identidades y Accesos (IAM), que se adjuntan a los recursos. Solo puedes adjuntar una política de permiso a cada recurso. La política de permiso controla el acceso al recurso en sí, así como a cualquier recurso descendiente que herede la política de permiso.

Para obtener más información sobre las políticas de permiso, consulta la sección Estructura de las políticas de la documentación de IAM.

En este documento se da por hecho que conoces la gestión de identidades y accesos (IAM) de Google Cloud.

Limitaciones

• Las listas de control de acceso (LCAs) de las rutinas no se incluyen en las rutinas replicadas.
• Las rutinas de conjuntos de datos externos o vinculados no admiten controles de acceso.
• Las tablas de conjuntos de datos externos o vinculados no admiten controles de acceso.
• Los controles de acceso a rutinas no se pueden configurar con Terraform.
• Los controles de acceso de rutinas no se pueden definir con el SDK de Google Cloud.
• Los controles de acceso rutinarios no se pueden definir con el lenguaje de control de datos (DCL) de BigQuery.
• Data Catalog no admite controles de acceso rutinarios. Si un usuario ha concedido acceso a nivel de rutina de forma condicional, no verá sus rutinas en el panel lateral de BigQuery. Para evitar este problema, concede acceso a nivel de conjunto de datos.
• En la INFORMATION_SCHEMA.OBJECT_PRIVILEGES vista no se muestran los controles de acceso de las rutinas.

Antes de empezar

Concede roles de gestión de identidades y accesos (IAM) que proporcionen a los usuarios los permisos necesarios para realizar cada tarea de este documento.

Roles obligatorios

Para obtener los permisos que necesitas para modificar las políticas de gestión de identidades y accesos de los recursos, pide a tu administrador que te asigne el rol de gestión de identidades y accesos Propietario de datos de BigQuery (roles/bigquery.dataOwner) en el proyecto. Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

Este rol predefinido contiene los permisos necesarios para modificar las políticas de gestión de identidades y accesos de los recursos. Para ver los permisos exactos que se necesitan, despliega la sección Permisos necesarios:

Permisos obligatorios

Para modificar las políticas de gestión de identidades y accesos de los recursos, se necesitan los siguientes permisos:

• Para obtener la política de acceso de un conjunto de datos, sigue estos pasos: bigquery.datasets.get
• Para definir la política de acceso de un conjunto de datos, sigue estos pasos: bigquery.datasets.update
• Para obtener la política de acceso de un conjunto de datos (solo en la consola): bigquery.datasets.getIamPolicyGoogle Cloud
• Para definir la política de acceso de un conjunto de datos (solo en la consola), sigue estos pasos: bigquery.datasets.setIamPolicy
• Para obtener la política de una tabla o una vista, sigue estos pasos: bigquery.tables.getIamPolicy
• Para definir la política de una tabla o una vista, sigue estos pasos: bigquery.tables.setIamPolicy
• Para obtener la política de acceso de una rutina, sigue estos pasos: bigquery.routines.getIamPolicy
• Para definir la política de acceso de una rutina, sigue estos pasos: bigquery.routines.setIamPolicy
• Para crear trabajos de la herramienta bq o SQL de BigQuery (opcional): bigquery.jobs.create

También puedes obtener estos permisos con roles personalizados u otros roles predefinidos.

Trabajar con controles de acceso a conjuntos de datos

Para proporcionar acceso a un conjunto de datos, puedes conceder a una entidad principal de gestión de identidades y accesos un rol predefinido o personalizado que determine lo que puede hacer con el conjunto de datos. También se conoce como adjuntar una política de permiso a un recurso. Después de conceder acceso, puedes ver los controles de acceso del conjunto de datos y revocar el acceso al conjunto de datos.

Conceder acceso a un conjunto de datos

No puedes conceder acceso a un conjunto de datos cuando lo creas con la interfaz web de BigQuery o con la herramienta de línea de comandos bq. Primero debe crear el conjunto de datos y, después, conceder acceso a él. La API te permite conceder acceso durante la creación del conjunto de datos llamando al método datasets.insert con un recurso de conjunto de datos definido.

Un proyecto es el recurso superior de un conjunto de datos, y un conjunto de datos es el recurso superior de tablas, vistas, rutinas y modelos. Cuando asignas un rol a nivel de proyecto, el rol y sus permisos se heredan en el conjunto de datos y en los recursos del conjunto de datos. Del mismo modo, cuando asignas un rol a nivel del conjunto de datos, el rol y sus permisos se heredan en los recursos del conjunto de datos.

Puede proporcionar acceso a un conjunto de datos concediendo un permiso de rol de gestión de identidades y accesos para acceder al conjunto de datos o concediendo acceso de forma condicional mediante una condición de gestión de identidades y accesos. Para obtener más información sobre cómo conceder acceso condicional, consulta el artículo Controlar el acceso con condiciones de gestión de identidades y accesos.

Nota: Si das acceso a un conjunto de datos, no se mostrará automáticamente en el panel Explorador. Para ver un proyecto en el panel Explorador, consulta Destacar un proyecto.

Para conceder acceso a un conjunto de datos a un rol de gestión de identidades y accesos sin usar condiciones, selecciona una de las siguientes opciones:

Consola

1. Ve a la página BigQuery.

   Ir a BigQuery

2. En el panel Explorador, despliega tu proyecto y selecciona el conjunto de datos que quieras compartir.

3. Haz clic en Compartir > Permisos.

4. Haz clic en Añadir principal.

5. En el campo New principals (Nuevos principales), introduce un principal.

6. En la lista Selecciona un rol, elige un rol predefinido o un rol personalizado.

7. Haz clic en Guardar.

8. Para volver a la información del conjunto de datos, haz clic en Cerrar.

SQL

Para conceder acceso a conjuntos de datos a principales, usa la declaración de DCL GRANT:

1. En la Google Cloud consola, ve a la página BigQuery.

   Ir a BigQuery

2. En el editor de consultas, introduce la siguiente instrucción:

   GRANT `ROLE_LIST`
   ON SCHEMA RESOURCE_NAME
   TO "USER_LIST"

   Haz los cambios siguientes:

   • ROLE_LIST: un rol o una lista de roles separados por comas que quieras conceder
   • RESOURCE_NAME: el nombre del conjunto de datos al que vas a dar acceso

   • USER_LIST: lista de usuarios separada por comas a los que se les ha concedido el rol

     Para ver una lista de formatos válidos, consulta user_list.

3. Haz clic en Ejecutar.

Para obtener más información sobre cómo ejecutar consultas, consulta Ejecutar una consulta interactiva.

En el siguiente ejemplo, se asigna el rol Lector de datos de BigQuery a myDataset:

GRANT `roles/bigquery.dataViewer`
ON SCHEMA `myProject`.myDataset
TO "user:[e-mail]", "user:[e-mail]"

bq

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Para escribir la información del conjunto de datos (incluidos los controles de acceso) en un archivo JSON, usa el comando bq show:

   bq show \
       --format=prettyjson \
       PROJECT_ID:DATASET > PATH_TO_FILE

   Haz los cambios siguientes:

   • PROJECT_ID: tu ID de proyecto
   • DATASET: el nombre del conjunto de datos
   • PATH_TO_FILE: la ruta al archivo JSON en tu máquina local

3. Haz cambios en la sección access del archivo JSON. Puedes añadir a cualquiera de las entradas de specialGroup: projectOwners, projectWriters, projectReaders y allAuthenticatedUsers. También puedes añadir cualquiera de los siguientes elementos: userByEmail, groupByEmail y domain.

   Por ejemplo, la sección access del archivo JSON de un conjunto de datos tendría el siguiente aspecto:

   {
    "access": [
     {
      "role": "READER",
      "specialGroup": "projectReaders"
     },
     {
      "role": "WRITER",
      "specialGroup": "projectWriters"
     },
     {
      "role": "OWNER",
      "specialGroup": "projectOwners"
     },
     {
      "role": "READER",
      "specialGroup": "allAuthenticatedUsers"
     },
     {
      "role": "READER",
      "domain": "domain_name"
     },
     {
      "role": "WRITER",
      "userByEmail": "user_email"
     },
     {
      "role": "READER",
      "groupByEmail": "group_email"
     }
    ],
    ...
   }

4. Cuando hayas terminado de hacer los cambios, usa el comando bq update e incluye el archivo JSON con la marca --source. Si el conjunto de datos está en un proyecto que no es el predeterminado, añade el ID del proyecto al nombre del conjunto de datos con el siguiente formato: PROJECT_ID:DATASET.

   Precaución: Cuando apliques el archivo JSON que contiene los controles de acceso, se sobrescribirán los controles de acceso que ya tengas.

     bq update 
   
     --source PATH_TO_FILE 
   
     PROJECT_ID:DATASET
     

5. Para verificar los cambios en el control de acceso, vuelve a usar el comando bq show sin escribir la información en un archivo:

   bq show --format=prettyjson PROJECT_ID:DATASET

Terraform

Usa los recursos de google_bigquery_dataset_iam para actualizar el acceso a un conjunto de datos.

Importante: Los diferentes recursos proporcionados por google_bigquery_dataset_iam pueden entrar en conflicto entre sí, así como con el recurso google_bigquery_dataset_access. Lee atentamente la documentación sobre google_bigquery_dataset_iam antes de hacer cambios en el control de acceso con Terraform.

Definir la política de acceso de un conjunto de datos

En el siguiente ejemplo se muestra cómo usar el recurso google_bigquery_dataset_iam_policy para definir la política de gestión de identidades y accesos del conjunto de datos mydataset. De esta forma, se sustituirá cualquier política que ya esté asociada al conjunto de datos:

# This file sets the IAM policy for the dataset created by
# https://github.com/terraform-google-modules/terraform-docs-samples/blob/main/bigquery/bigquery_create_dataset/main.tf.
# You must place it in the same local directory as that main.tf file,
# and you must have already applied that main.tf file to create
# the "default" dataset resource with a dataset_id of "mydataset".

data "google_iam_policy" "iam_policy" {
  binding {
    role = "roles/bigquery.admin"
    members = [
      "user:[e-mail]",
    ]
  }
  binding {
    role = "roles/bigquery.dataOwner"
    members = [
      "group:[e-mail]",
    ]
  }
  binding {
    role = "roles/bigquery.dataEditor"
    members = [
      "serviceAccount:[e-mail]",
    ]
  }
}

resource "google_bigquery_dataset_iam_policy" "dataset_iam_policy" {
  dataset_id  = google_bigquery_dataset.default.dataset_id
  policy_data = data.google_iam_policy.iam_policy.policy_data
}

Definir la pertenencia a un rol de un conjunto de datos

En el siguiente ejemplo se muestra cómo usar el recurso google_bigquery_dataset_iam_binding para asignar un rol determinado al conjunto de datos mydataset. De esta forma, se sustituirá cualquier pertenencia a ese rol. Se conservan otros roles de la política de gestión de identidades y accesos del conjunto de datos:

# This file sets membership in an IAM role for the dataset created by
# https://github.com/terraform-google-modules/terraform-docs-samples/blob/main/bigquery/bigquery_create_dataset/main.tf.
# You must place it in the same local directory as that main.tf file,
# and you must have already applied that main.tf file to create
# the "default" dataset resource with a dataset_id of "mydataset".

resource "google_bigquery_dataset_iam_binding" "dataset_iam_binding" {
  dataset_id = google_bigquery_dataset.default.dataset_id
  role       = "roles/bigquery.jobUser"

  members = [
    "user:[e-mail]",
    "group:[e-mail]"
  ]
}

Definir la pertenencia a un rol para un solo principal

En el siguiente ejemplo se muestra cómo usar el recurso google_bigquery_dataset_iam_member para actualizar la política de gestión de identidades y accesos del conjunto de datos mydataset y asignar un rol a un principal. Actualizar esta política de IAM no afecta al acceso de ninguna otra entidad a la que se le haya concedido ese rol para el conjunto de datos.

# This file adds a member to an IAM role for the dataset created by
# https://github.com/terraform-google-modules/terraform-docs-samples/blob/main/bigquery/bigquery_create_dataset/main.tf.
# You must place it in the same local directory as that main.tf file,
# and you must have already applied that main.tf file to create
# the "default" dataset resource with a dataset_id of "mydataset".

resource "google_bigquery_dataset_iam_member" "dataset_iam_member" {
  dataset_id = google_bigquery_dataset.default.dataset_id
  role       = "roles/bigquery.user"
  member     = "user:[e-mail]"
}

Para aplicar la configuración de Terraform en un proyecto, sigue los pasos que se indican en las siguientes secciones. Google Cloud

Preparar Cloud Shell

1. Abre Cloud Shell.

2. Define el Google Cloud proyecto Google Cloud predeterminado en el que quieras aplicar tus configuraciones de Terraform.

   Solo tiene que ejecutar este comando una vez por proyecto y puede hacerlo en cualquier directorio.

   export GOOGLE_CLOUD_PROJECT=PROJECT_ID

   Las variables de entorno se anulan si defines valores explícitos en el archivo de configuración de Terraform.

Preparar el directorio

Cada archivo de configuración de Terraform debe tener su propio directorio (también llamado módulo raíz).

1. En Cloud Shell, crea un directorio y un archivo nuevo en ese directorio. El nombre del archivo debe tener la extensión .tf. Por ejemplo, main.tf. En este tutorial, nos referiremos al archivo como main.tf.

   mkdir DIRECTORY && cd DIRECTORY && touch main.tf

2. Si estás siguiendo un tutorial, puedes copiar el código de ejemplo de cada sección o paso.

   Copia el código de ejemplo en el archivo main.tf que acabas de crear.

   También puedes copiar el código de GitHub. Se recomienda cuando el fragmento de Terraform forma parte de una solución integral.

3. Revisa y modifica los parámetros de ejemplo para aplicarlos a tu entorno.
4. Guarda los cambios.
5. Inicializa Terraform. Solo tienes que hacerlo una vez por directorio.

   terraform init

   Si quieres usar la versión más reciente del proveedor de Google, incluye la opción -upgrade:

   terraform init -upgrade

Aplica los cambios

1. Revisa la configuración y comprueba que los recursos que va a crear o actualizar Terraform se ajustan a tus expectativas:

   terraform plan

   Haga las correcciones necesarias en la configuración.

2. Aplica la configuración de Terraform ejecutando el siguiente comando e introduciendo yes en la petición:

   terraform apply

   Espera hasta que Terraform muestre el mensaje "Apply complete!".

3. Abre tu Google Cloud proyecto para ver los resultados. En la Google Cloud consola, ve a tus recursos en la interfaz de usuario para asegurarte de que Terraform los ha creado o actualizado.

Nota: Los ejemplos de Terraform suelen presuponer que las APIs necesarias están habilitadas en tu proyecto. Google Cloud

API

Para aplicar controles de acceso al crear el conjunto de datos, llama al método datasets.insert con un recurso de conjunto de datos definido. Para actualizar los controles de acceso, llama al método datasets.patch y usa la propiedad access en el recurso Dataset.

Como el método datasets.update sustituye todo el recurso del conjunto de datos, datasets.patch es el método preferido para actualizar los controles de acceso.

Go

Antes de probar este ejemplo, sigue las Goinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Go de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

Define la nueva lista de acceso añadiendo la nueva entrada a la lista actual con el tipo DatasetMetadataToUpdate. A continuación, llama a la función dataset.Update() para actualizar la propiedad.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
)

// grantAccessToDataset creates a new ACL conceding the READER role to the group "[e-mail]"
// For more information on the types of ACLs available see:
// https://cloud.google.com/storage/docs/access-control/lists
func grantAccessToDataset(w io.Writer, projectID, datasetID string) error {
	// TODO(developer): uncomment and update the following lines:
	// projectID := "my-project-id"
	// datasetID := "mydataset"

	ctx := context.Background()

	// Create BigQuery handler.
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	// Create dataset handler
	dataset := client.Dataset(datasetID)

	// Get metadata
	meta, err := dataset.Metadata(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Metadata: %w", err)
	}

	// Find more details about BigQuery Entity Types here:
	// https://pkg.go.dev/cloud.google.com/go/bigquery#EntityType
	//
	// Find more details about BigQuery Access Roles here:
	// https://pkg.go.dev/cloud.google.com/go/bigquery#AccessRole

	entityType := bigquery.GroupEmailEntity
	entityID := "[e-mail]"
	roleType := bigquery.ReaderRole

	// Append a new access control entry to the existing access list.
	update := bigquery.DatasetMetadataToUpdate{
		Access: append(meta.Access, &bigquery.AccessEntry{
			Role:       roleType,
			EntityType: entityType,
			Entity:     entityID,
		}),
	}

	// Leverage the ETag for the update to assert there's been no modifications to the
	// dataset since the metadata was originally read.
	meta, err = dataset.Update(ctx, update, meta.ETag)
	if err != nil {
		return err
	}

	fmt.Fprintf(w, "Details for Access entries in dataset %v.\n", datasetID)
	for _, access := range meta.Access {
		fmt.Fprintln(w)
		fmt.Fprintf(w, "Role: %s\n", access.Role)
		fmt.Fprintf(w, "Entities: %v\n", access.Entity)
	}

	return nil
}

Java

Antes de probar este ejemplo, sigue las Javainstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

import com.google.cloud.bigquery.Acl;
import com.google.cloud.bigquery.Acl.Entity;
import com.google.cloud.bigquery.Acl.Group;
import com.google.cloud.bigquery.Acl.Role;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Dataset;
import com.google.cloud.bigquery.DatasetId;
import java.util.ArrayList;
import java.util.List;

public class GrantAccessToDataset {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    // Project and dataset from which to get the access policy
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    // Group to add to the ACL
    String entityEmail = "[e-mail]";

    grantAccessToDataset(projectId, datasetName, entityEmail);
  }

  public static void grantAccessToDataset(
      String projectId, String datasetName, String entityEmail) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      // Create datasetId with the projectId and the datasetName.
      DatasetId datasetId = DatasetId.of(projectId, datasetName);
      Dataset dataset = bigquery.getDataset(datasetId);

      // Create a new Entity with the corresponding type and email
      // "[e-mail]"
      // For more information on the types of Entities available see:
      // https://cloud.google.com/java/docs/reference/google-cloud-bigquery/latest/com.google.cloud.bigquery.Acl.Entity
      // and
      // https://cloud.google.com/java/docs/reference/google-cloud-bigquery/latest/com.google.cloud.bigquery.Acl.Entity.Type
      Entity entity = new Group(entityEmail);

      // Create a new ACL granting the READER role to the group with the entity email
      // "[e-mail]"
      // For more information on the types of ACLs available see:
      // https://cloud.google.com/storage/docs/access-control/lists
      Acl newEntry = Acl.of(entity, Role.READER);

      // Get a copy of the ACLs list from the dataset and append the new entry.
      List<Acl> acls = new ArrayList<>(dataset.getAcl());
      acls.add(newEntry);

      // Update the ACLs by setting the new list.
      Dataset updatedDataset = bigquery.update(dataset.toBuilder().setAcl(acls).build());
      System.out.println(
          "ACLs of dataset \""
              + updatedDataset.getDatasetId().getDataset()
              + "\" updated successfully");
    } catch (BigQueryException e) {
      System.out.println("ACLs were not updated \n" + e.toString());
    }
  }
}

Node.js

Antes de probar este ejemplo, sigue las Node.jsinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

Define la nueva lista de acceso añadiendo la nueva entrada a la lista actual con el método Dataset#metadata. A continuación, llama a la función Dataset#setMetadata() para actualizar la propiedad.

/**
 * TODO(developer): Update and un-comment below lines.
 */

// const datasetId = "my_project_id.my_dataset_name";

// ID of the user or group from whom you are adding access.
// const entityId = "[e-mail]";

// One of the "Basic roles for datasets" described here:
// https://cloud.google.com/bigquery/docs/access-control-basic-roles#dataset-basic-roles
// const role = "READER";

const {BigQuery} = require('@google-cloud/bigquery');

// Instantiate a client.
const client = new BigQuery();

// Type of entity you are granting access to.
// Find allowed allowed entity type names here:
// https://cloud.google.com/bigquery/docs/reference/rest/v2/datasets#resource:-dataset
const entityType = 'groupByEmail';

async function grantAccessToDataset() {
  const [dataset] = await client.dataset(datasetId).get();

  // The 'access entries' array is immutable. Create a copy for modifications.
  const entries = [...dataset.metadata.access];

  // Append an AccessEntry to grant the role to a dataset.
  // Find more details about the AccessEntry object in the BigQuery documentation:
  // https://cloud.google.com/python/docs/reference/bigquery/latest/google.cloud.bigquery.dataset.AccessEntry
  entries.push({
    role,
    [entityType]: entityId,
  });

  // Assign the array of AccessEntries back to the dataset.
  const metadata = {
    access: entries,
  };

  // Update will only succeed if the dataset
  // has not been modified externally since retrieval.
  //
  // See the BigQuery client library documentation for more details on metadata updates:
  // https://cloud.google.com/nodejs/docs/reference/bigquery/latest

  // Update just the 'access entries' property of the dataset.
  await client.dataset(datasetId).setMetadata(metadata);

  console.log(
    `Role '${role}' granted for entity '${entityId}' in '${datasetId}'.`
  );
}

Python

Antes de probar este ejemplo, sigue las Pythoninstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Python de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

Define la propiedad dataset.access_entries con los controles de acceso de un conjunto de datos. A continuación, llama a la función client.update_dataset() para actualizar la propiedad.

from google.api_core.exceptions import PreconditionFailed
from google.cloud import bigquery
from google.cloud.bigquery.enums import EntityTypes

# TODO(developer): Update and uncomment the lines below.

# ID of the dataset to grant access to.
# dataset_id = "my_project_id.my_dataset"

# ID of the user or group receiving access to the dataset.
# Alternatively, the JSON REST API representation of the entity,
# such as the view's table reference.
# entity_id = "[e-mail]"

# One of the "Basic roles for datasets" described here:
# https://cloud.google.com/bigquery/docs/access-control-basic-roles#dataset-basic-roles
# role = "READER"

# Type of entity you are granting access to.
# Find allowed allowed entity type names here:
# https://cloud.google.com/python/docs/reference/bigquery/latest/enums#class-googlecloudbigqueryenumsentitytypesvalue
entity_type = EntityTypes.GROUP_BY_EMAIL

# Instantiate a client.
client = bigquery.Client()

# Get a reference to the dataset.
dataset = client.get_dataset(dataset_id)

# The `access_entries` list is immutable. Create a copy for modifications.
entries = list(dataset.access_entries)

# Append an AccessEntry to grant the role to a dataset.
# Find more details about the AccessEntry object here:
# https://cloud.google.com/python/docs/reference/bigquery/latest/google.cloud.bigquery.dataset.AccessEntry
entries.append(
    bigquery.AccessEntry(
        role=role,
        entity_type=entity_type,
        entity_id=entity_id,
    )
)

# Assign the list of AccessEntries back to the dataset.
dataset.access_entries = entries

# Update will only succeed if the dataset
# has not been modified externally since retrieval.
#
# See the BigQuery client library documentation for more details on `update_dataset`:
# https://cloud.google.com/python/docs/reference/bigquery/latest/google.cloud.bigquery.client.Client#google_cloud_bigquery_client_Client_update_dataset
try:
    # Update just the `access_entries` property of the dataset.
    dataset = client.update_dataset(
        dataset,
        ["access_entries"],
    )

    # Show a success message.
    full_dataset_id = f"{dataset.project}.{dataset.dataset_id}"
    print(
        f"Role '{role}' granted for entity '{entity_id}'"
        f" in dataset '{full_dataset_id}'."
    )
except PreconditionFailed:  # A read-modify-write error
    print(
        f"Dataset '{dataset.dataset_id}' was modified remotely before this update. "
        "Fetch the latest version and retry."
    )

Roles predefinidos que conceden acceso a conjuntos de datos

Puedes conceder acceso a un conjunto de datos a los siguientes roles predefinidos de gestión de identidades y accesos.

Precaución: Aunque es posible conceder permisos de administrador de BigQuery o de administrador de BigQuery Studio en un conjunto de datos, no debes asignar estos roles a nivel de conjunto de datos. El rol Propietario de datos de BigQuery también concede todos los permisos del conjunto de datos y es un rol menos permisivo. Los roles Administrador de BigQuery y Administrador de BigQuery Studio se suelen asignar en el nivel de proyecto.

Rol	Descripción
Propietario de datos de BigQuery (roles/bigquery.dataOwner)	Si se asigna a un conjunto de datos, este rol concede los siguientes permisos: Todos los permisos del conjunto de datos y de todos los recursos que contiene: tablas y vistas, modelos y rutinas. Nota: Las entidades a las que se les asigna el rol Propietario de datos a nivel de proyecto también pueden crear conjuntos de datos y enumerar los conjuntos de datos del proyecto a los que tienen acceso.
Editor de datos de BigQuery (roles/bigquery.dataEditor)	Si se asigna a un conjunto de datos, este rol concede los siguientes permisos: Obtiene los metadatos y los permisos del conjunto de datos. En el caso de las tablas y las vistas: Crear, actualizar, obtener, mostrar y eliminar las tablas y las vistas del conjunto de datos. Leer (consultar), exportar, replicar y actualizar datos de tablas. Crear, actualizar y eliminar índices. Crea y restaura capturas. Todos los permisos de las rutinas y los modelos del conjunto de datos. Nota: Las entidades a las que se les ha asignado el rol Editor de datos a nivel de proyecto también pueden crear conjuntos de datos y enumerar los conjuntos de datos del proyecto a los que tienen acceso.
Lector de datos de BigQuery (roles/bigquery.dataViewer)	Si se asigna a un conjunto de datos, este rol concede los siguientes permisos: Obtiene los metadatos y los permisos del conjunto de datos. Mostrar las tablas, las vistas y los modelos de un conjunto de datos. Obtiene los metadatos y los controles de acceso de las tablas y las vistas del conjunto de datos. Leer (consultar), replicar y exportar datos de tablas, así como crear capturas. Mostrar e invocar las rutinas del conjunto de datos.
Visor de metadatos de BigQuery (roles/bigquery.metadataViewer)	Si se asigna a un conjunto de datos, este rol concede los siguientes permisos: Obtiene los metadatos y los controles de acceso del conjunto de datos. Obtiene metadatos y controles de acceso de tablas y vistas. Obtener metadatos de los modelos y las rutinas del conjunto de datos. Muestra las tablas, las vistas, los modelos y las rutinas del conjunto de datos.

Permisos de conjunto de datos

La mayoría de los permisos que empiezan por bigquery.datasets se aplican a nivel de conjunto de datos. bigquery.datasets.create no. Para crear conjuntos de datos, se debe conceder el permiso bigquery.datasets.create a un rol en el contenedor principal, es decir, el proyecto.

En la siguiente tabla se enumeran todos los permisos de conjuntos de datos y el recurso de nivel más bajo al que se puede aplicar el permiso.

Permiso	Recurso	Acción
bigquery.datasets.create	Proyecto	Crear conjuntos de datos en el proyecto.
bigquery.datasets.get	Conjunto de datos	Obtiene los metadatos y los controles de acceso del conjunto de datos. Para ver los permisos en la consola, también se necesita el permiso bigquery.datasets.getIamPolicy.
bigquery.datasets.getIamPolicy	Conjunto de datos	La consola lo requiere para conceder al usuario permiso para obtener los controles de acceso de un conjunto de datos. Apertura en caso de fallo. La consola también requiere el permiso bigquery.datasets.get para ver el conjunto de datos.
bigquery.datasets.update	Conjunto de datos	Actualiza los metadatos y los controles de acceso del conjunto de datos. Para actualizar los controles de acceso en la consola, también se necesita el permiso bigquery.datasets.setIamPolicy.
bigquery.datasets.setIamPolicy	Conjunto de datos	La consola lo requiere para conceder al usuario permiso para definir los controles de acceso de un conjunto de datos. Apertura en caso de fallo. La consola también requiere el permiso bigquery.datasets.update para actualizar el conjunto de datos.
bigquery.datasets.delete	Conjunto de datos	Elimina un conjunto de datos.
bigquery.datasets.createTagBinding	Conjunto de datos	Adjunta etiquetas al conjunto de datos.
bigquery.datasets.deleteTagBinding	Conjunto de datos	Desvincula las etiquetas del conjunto de datos.
bigquery.datasets.listTagBindings	Conjunto de datos	Muestra las etiquetas del conjunto de datos.
bigquery.datasets.listEffectiveTags	Conjunto de datos	Muestra las etiquetas efectivas (aplicadas y heredadas) del conjunto de datos.
bigquery.datasets.link	Conjunto de datos	Crea un conjunto de datos vinculado.
bigquery.datasets.listSharedDatasetUsage	Proyecto	Muestra las estadísticas de uso de los conjuntos de datos compartidos a los que tienes acceso en el proyecto. Este permiso es necesario para consultar la vista INFORMATION_SCHEMA.SHARED_DATASET_USAGE.

Ver los controles de acceso de un conjunto de datos

Para ver los controles de acceso definidos explícitamente de un conjunto de datos, elija una de las siguientes opciones. Para ver los roles heredados de un conjunto de datos, usa la interfaz web de BigQuery.

Consola

1. Ve a la página BigQuery.

   Ir a BigQuery

2. En el panel Explorador, expande tu proyecto y selecciona un conjunto de datos.

3. Haz clic en Compartir > Permisos.

   Los controles de acceso del conjunto de datos aparecen en el panel Permisos del conjunto de datos.

bq

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Para obtener una política y guardarla en un archivo local en formato JSON, usa el comando bq show en Cloud Shell:

   bq show \
      --format=prettyjson \
      PROJECT_ID:DATASET > PATH_TO_FILE

   Haz los cambios siguientes:

   • PROJECT_ID: tu ID de proyecto
   • DATASET: el nombre del conjunto de datos
   • PATH_TO_FILE: la ruta al archivo JSON de tu máquina local

SQL

Vista previa

Este producto o función está sujeto a los "Términos de las Ofertas de Acceso Previo a la Disponibilidad General" de la sección Términos Generales de los Servicios de los Términos Específicos de los Servicios. Los productos y las funciones previos a la disponibilidad general están disponibles tal cual y pueden tener una compatibilidad y asistencia limitadas. Para obtener más información, consulta las descripciones de las fases de lanzamiento.

Consulta la INFORMATION_SCHEMA.OBJECT_PRIVILEGES vista. Las consultas para obtener los controles de acceso de un conjunto de datos deben especificar el object_name.

1. En la Google Cloud consola, ve a la página BigQuery.

   Ir a BigQuery

2. En el editor de consultas, introduce la siguiente instrucción:

   SELECT
   COLUMN_LIST
   FROM
     PROJECT_ID.`region-REGION`.INFORMATION_SCHEMA.OBJECT_PRIVILEGES
   WHERE
   object_name = "DATASET";

   Haz los cambios siguientes:

   • COLUMN_LIST: una lista separada por comas de las columnas de la vista INFORMATION_SCHEMA.OBJECT_PRIVILEGES
   • PROJECT_ID: tu ID de proyecto
   • REGION: un calificador de región
   • DATASET: el nombre de un conjunto de datos de tu proyecto

3. Haz clic en Ejecutar.

Para obtener más información sobre cómo ejecutar consultas, consulta Ejecutar una consulta interactiva.

Ejemplo:

Esta consulta obtiene los controles de acceso de mydataset.

SELECT
object_name, privilege_type, grantee
FROM
my_project.`region-us`.INFORMATION_SCHEMA.OBJECT_PRIVILEGES
WHERE
object_name = "mydataset";

La salida debería tener este aspecto:

+------------------+-----------------------------+-------------------------+
|   object_name    |  privilege_type             | grantee                 |
+------------------+-----------------------------+-------------------------+
| mydataset        | roles/bigquery.dataOwner    | projectOwner:myproject  |
| mydataset        | roles/bigquery.dataViwer    | user:[e-mail]   |
+------------------+-----------------------------+-------------------------+

API

Para ver los controles de acceso de un conjunto de datos, llama al método datasets.get con un datasetrecurso definido.

Los controles de acceso aparecen en la propiedad access del recurso dataset.

Go

Antes de probar este ejemplo, sigue las Goinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Go de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

Llama a la función client.Dataset().Metadata(). La política de acceso está disponible en la propiedad Access.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
)

// viewDatasetAccessPolicies retrieves the ACL for the given dataset
// For more information on the types of ACLs available see:
// https://cloud.google.com/storage/docs/access-control/lists
func viewDatasetAccessPolicies(w io.Writer, projectID, datasetID string) error {
	// TODO(developer): uncomment and update the following lines:
	// projectID := "my-project-id"
	// datasetID := "mydataset"

	ctx := context.Background()

	// Create new client.
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	// Get dataset's metadata.
	meta, err := client.Dataset(datasetID).Metadata(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Client.Dataset.Metadata: %w", err)
	}

	fmt.Fprintf(w, "Details for Access entries in dataset %v.\n", datasetID)

	// Iterate over access permissions.
	for _, access := range meta.Access {
		fmt.Fprintln(w)
		fmt.Fprintf(w, "Role: %s\n", access.Role)
		fmt.Fprintf(w, "Entity: %v\n", access.Entity)
	}

	return nil
}

Java

Antes de probar este ejemplo, sigue las Javainstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

import com.google.cloud.bigquery.Acl;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Dataset;
import com.google.cloud.bigquery.DatasetId;
import java.util.List;

public class GetDatasetAccessPolicy {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    // Project and dataset from which to get the access policy.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    getDatasetAccessPolicy(projectId, datasetName);
  }

  public static void getDatasetAccessPolicy(String projectId, String datasetName) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      // Create datasetId with the projectId and the datasetName.
      DatasetId datasetId = DatasetId.of(projectId, datasetName);
      Dataset dataset = bigquery.getDataset(datasetId);

      // Show ACL details.
      // Find more information about ACL and the Acl Class here:
      // https://cloud.google.com/storage/docs/access-control/lists
      // https://cloud.google.com/java/docs/reference/google-cloud-bigquery/latest/com.google.cloud.bigquery.Acl
      List<Acl> acls = dataset.getAcl();
      System.out.println("ACLs in dataset \"" + dataset.getDatasetId().getDataset() + "\":");
      System.out.println(acls.toString());
      for (Acl acl : acls) {
        System.out.println();
        System.out.println("Role: " + acl.getRole());
        System.out.println("Entity: " + acl.getEntity());
      }
    } catch (BigQueryException e) {
      System.out.println("ACLs info not retrieved. \n" + e.toString());
    }
  }
}

Node.js

Antes de probar este ejemplo, sigue las Node.jsinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

Recupera los metadatos del conjunto de datos con la función Dataset#getMetadata(). La política de acceso está disponible en la propiedad de acceso del objeto de metadatos resultante.

/**
 * TODO(developer): Update and un-comment below lines
 */
// const datasetId = "my_project_id.my_dataset";

const {BigQuery} = require('@google-cloud/bigquery');

// Instantiate a client.
const bigquery = new BigQuery();

async function viewDatasetAccessPolicy() {
  const dataset = bigquery.dataset(datasetId);

  const [metadata] = await dataset.getMetadata();
  const accessEntries = metadata.access || [];

  // Show the list of AccessEntry objects.
  // More details about the AccessEntry object in the BigQuery documentation:
  // https://cloud.google.com/nodejs/docs/reference/bigquery/latest
  console.log(
    `${accessEntries.length} Access entries in dataset '${datasetId}':`
  );
  for (const accessEntry of accessEntries) {
    console.log(`Role: ${accessEntry.role || 'null'}`);
    console.log(`Special group: ${accessEntry.specialGroup || 'null'}`);
    console.log(`User by Email: ${accessEntry.userByEmail || 'null'}`);
  }
}

Python

Antes de probar este ejemplo, sigue las Pythoninstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Python de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

Llama a la función client.get_dataset(). La política de acceso está disponible en la propiedad dataset.access_entries.

from google.cloud import bigquery

# Instantiate a client.
client = bigquery.Client()

# TODO(developer): Update and uncomment the lines below.

# Dataset from which to get the access policy.
# dataset_id = "my_dataset"

# Get a reference to the dataset.
dataset = client.get_dataset(dataset_id)

# Show the list of AccessEntry objects.
# More details about the AccessEntry object here:
# https://cloud.google.com/python/docs/reference/bigquery/latest/google.cloud.bigquery.dataset.AccessEntry
print(
    f"{len(dataset.access_entries)} Access entries found "
    f"in dataset '{dataset_id}':"
)

for access_entry in dataset.access_entries:
    print()
    print(f"Role: {access_entry.role}")
    print(f"Special group: {access_entry.special_group}")
    print(f"User by Email: {access_entry.user_by_email}")

Revocar el acceso a un conjunto de datos

Para revocar el acceso a un conjunto de datos, selecciona una de las siguientes opciones:

Consola

1. Ve a la página BigQuery.

   Ir a BigQuery

2. En el panel Explorador, expande tu proyecto y selecciona un conjunto de datos.

3. En el panel de detalles, haz clic en Compartir > Permisos.

4. En el cuadro de diálogo Permisos del conjunto de datos, despliega el principal cuyo acceso quieras revocar.

5. Haz clic en Eliminar principal.

6. En el cuadro de diálogo ¿Quitar rol del principal?, haz clic en Quitar.

7. Para volver a los detalles del conjunto de datos, haz clic en Cerrar.

Nota: Si no puede revocar el acceso al conjunto de datos, es posible que la entidad de seguridad haya heredado el acceso de un nivel superior de la jerarquía de recursos.

SQL

Para quitar el acceso de una entidad a un conjunto de datos, usa la REVOKE instrucción DCL:

1. En la Google Cloud consola, ve a la página BigQuery.

   Ir a BigQuery

2. En el editor de consultas, introduce la siguiente instrucción:

   REVOKE `ROLE_LIST`
   ON SCHEMA RESOURCE_NAME
   FROM "USER_LIST"

   Haz los cambios siguientes:

   • ROLE_LIST: un rol o una lista de roles separados por comas que quieras revocar
   • RESOURCE_NAME: el nombre del recurso cuyo permiso quieres revocar

   • USER_LIST: lista de usuarios separados por comas a los que se les revocarán los roles.

     Para ver una lista de formatos válidos, consulta user_list.

3. Haz clic en Ejecutar.

Para obtener más información sobre cómo ejecutar consultas, consulta Ejecutar una consulta interactiva.

En el siguiente ejemplo, se revoca el rol Propietario de datos de BigQuery de myDataset:

REVOKE `roles/bigquery.dataOwner`
ON SCHEMA `myProject`.myDataset
FROM "group:[e-mail]", "serviceAccount:[e-mail]"

bq

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Para escribir la información del conjunto de datos (incluidos los controles de acceso) en un archivo JSON, usa el comando bq show:

   bq show \
       --format=prettyjson \
       PROJECT_ID:DATASET > PATH_TO_FILE

   Haz los cambios siguientes:

   • PROJECT_ID: tu ID de proyecto
   • DATASET: el nombre del conjunto de datos
   • PATH_TO_FILE: la ruta al archivo JSON en tu máquina local

3. Haz cambios en la sección access del archivo JSON. Puedes eliminar cualquiera de las entradas de specialGroup: projectOwners, projectWriters, projectReaders y allAuthenticatedUsers. También puedes quitar cualquiera de los siguientes elementos: userByEmail, groupByEmail y domain.

   Por ejemplo, la sección access del archivo JSON de un conjunto de datos tendría el siguiente aspecto:

   {
    "access": [
     {
      "role": "READER",
      "specialGroup": "projectReaders"
     },
     {
      "role": "WRITER",
      "specialGroup": "projectWriters"
     },
     {
      "role": "OWNER",
      "specialGroup": "projectOwners"
     },
     {
      "role": "READER",
      "specialGroup": "allAuthenticatedUsers"
     },
     {
      "role": "READER",
      "domain": "domain_name"
     },
     {
      "role": "WRITER",
      "userByEmail": "user_email"
     },
     {
      "role": "READER",
      "groupByEmail": "group_email"
     }
    ],
    ...
   }

4. Cuando hayas terminado de hacer los cambios, usa el comando bq update e incluye el archivo JSON con la marca --source. Si el conjunto de datos está en un proyecto que no es el predeterminado, añade el ID del proyecto al nombre del conjunto de datos con el siguiente formato: PROJECT_ID:DATASET.

   Precaución: Cuando apliques el archivo JSON que contiene los controles de acceso, se sobrescribirán los controles de acceso que ya tengas.

     bq update 
   
         --source PATH_TO_FILE 
   
         PROJECT_ID:DATASET
     

5. Para verificar los cambios en el control de acceso, usa el comando show sin escribir la información en un archivo:

   bq show --format=prettyjson PROJECT_ID:DATASET

API

Llama al método datasets.patch y usa la propiedad access del recurso Dataset para actualizar tus controles de acceso.

Como el método datasets.update sustituye todo el recurso del conjunto de datos, datasets.patch es el método preferido para actualizar los controles de acceso.

Go

Antes de probar este ejemplo, sigue las Goinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Go de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

Define la nueva lista de acceso quitando la entrada de la lista actual con el tipo DatasetMetadataToUpdate. A continuación, llama a la función dataset.Update() para actualizar la propiedad.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
)

// revokeAccessToDataset creates a new ACL removing the dataset access to "[e-mail]" entity
// For more information on the types of ACLs available see:
// https://cloud.google.com/storage/docs/access-control/lists
func revokeAccessToDataset(w io.Writer, projectID, datasetID, entity string) error {
	// TODO(developer): uncomment and update the following lines:
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// entity := "[e-mail]"

	ctx := context.Background()

	// Create BigQuery client.
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	// Get dataset handler
	dataset := client.Dataset(datasetID)

	// Get dataset metadata
	meta, err := dataset.Metadata(ctx)
	if err != nil {
		return err
	}

	// Create new access entry list by copying the existing and omiting the access entry entity value
	var newAccessList []*bigquery.AccessEntry
	for _, entry := range meta.Access {
		if entry.Entity != entity {
			newAccessList = append(newAccessList, entry)
		}
	}

	// Only proceed with update if something in the access list was removed.
	// Additionally, we use the ETag from the initial metadata to ensure no
	// other changes were made to the access list in the interim.
	if len(newAccessList) < len(meta.Access) {
		update := bigquery.DatasetMetadataToUpdate{
			Access: newAccessList,
		}
		meta, err = dataset.Update(ctx, update, meta.ETag)
		if err != nil {
			return err
		}
	} else {
		return fmt.Errorf("any access entry was revoked")
	}

	fmt.Fprintf(w, "Details for Access entries in dataset %v.\n", datasetID)

	for _, access := range meta.Access {
		fmt.Fprintln(w)
		fmt.Fprintf(w, "Role: %s\n", access.Role)
		fmt.Fprintf(w, "Entity: %v\n", access.Entity)
	}

	return nil
}

Java

Antes de probar este ejemplo, sigue las Javainstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

import com.google.cloud.bigquery.Acl;
import com.google.cloud.bigquery.Acl.Entity;
import com.google.cloud.bigquery.Acl.Group;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Dataset;
import com.google.cloud.bigquery.DatasetId;
import java.util.List;

public class RevokeDatasetAccess {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    // Project and dataset from which to get the access policy.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    // Group to remove from the ACL
    String entityEmail = "[e-mail]";

    revokeDatasetAccess(projectId, datasetName, entityEmail);
  }

  public static void revokeDatasetAccess(String projectId, String datasetName, String entityEmail) {
    try {
      // Initialize client that will be used to send requests. This client only needs
      // to be created once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      // Create datasetId with the projectId and the datasetName.
      DatasetId datasetId = DatasetId.of(projectId, datasetName);
      Dataset dataset = bigquery.getDataset(datasetId);

      // Create a new Entity with the corresponding type and email
      // "[e-mail]"
      // For more information on the types of Entities available see:
      // https://cloud.google.com/java/docs/reference/google-cloud-bigquery/latest/com.google.cloud.bigquery.Acl.Entity
      // and
      // https://cloud.google.com/java/docs/reference/google-cloud-bigquery/latest/com.google.cloud.bigquery.Acl.Entity.Type
      Entity entity = new Group(entityEmail);

      // To revoke access to a dataset, remove elements from the Acl list.
      // Find more information about ACL and the Acl Class here:
      // https://cloud.google.com/storage/docs/access-control/lists
      // https://cloud.google.com/java/docs/reference/google-cloud-bigquery/latest/com.google.cloud.bigquery.Acl
      // Remove the entity from the ACLs list.
      List<Acl> acls =
          dataset.getAcl().stream().filter(acl -> !acl.getEntity().equals(entity)).toList();

      // Update the ACLs by setting the new list.
      bigquery.update(dataset.toBuilder().setAcl(acls).build());
      System.out.println("ACLs of \"" + datasetName + "\" updated successfully");
    } catch (BigQueryException e) {
      System.out.println("ACLs were not updated \n" + e.toString());
    }
  }
}

Node.js

Antes de probar este ejemplo, sigue las Node.jsinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

Actualiza la lista de acceso al conjunto de datos. Para ello, elimina la entrada especificada de la lista actual con el método Dataset#get() para obtener los metadatos actuales. Modifica la propiedad de acceso para excluir la entidad que quieras y, a continuación, llama a la función Dataset#setMetadata() para aplicar la lista de acceso actualizada.

/**
 * TODO(developer): Update and un-comment below lines
 */

// const datasetId = "my_project_id.my_dataset"

// ID of the user or group from whom you are revoking access.
// const entityId = "[e-mail]"

const {BigQuery} = require('@google-cloud/bigquery');

// Instantiate a client.
const bigquery = new BigQuery();

async function revokeDatasetAccess() {
  const [dataset] = await bigquery.dataset(datasetId).get();

  // To revoke access to a dataset, remove elements from the access list.
  //
  // See the BigQuery client library documentation for more details on access entries:
  // https://cloud.google.com/nodejs/docs/reference/bigquery/latest

  // Filter access entries to exclude entries matching the specified entity_id
  // and assign a new list back to the access list.
  dataset.metadata.access = dataset.metadata.access.filter(entry => {
    return !(
      entry.entity_id === entityId ||
      entry.userByEmail === entityId ||
      entry.groupByEmail === entityId
    );
  });

  // Update will only succeed if the dataset
  // has not been modified externally since retrieval.
  //
  // See the BigQuery client library documentation for more details on metadata updates:
  // https://cloud.google.com/bigquery/docs/updating-datasets

  // Update just the 'access entries' property of the dataset.
  await dataset.setMetadata(dataset.metadata);

  console.log(`Revoked access to '${entityId}' from '${datasetId}'.`);
}

Python

Antes de probar este ejemplo, sigue las Pythoninstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Python de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

Asigna a la propiedad dataset.access_entries los controles de acceso de un conjunto de datos. A continuación, llama a la función client.update_dataset() para actualizar la propiedad.

from google.cloud import bigquery
from google.api_core.exceptions import PreconditionFailed

# TODO(developer): Update and uncomment the lines below.

# ID of the dataset to revoke access to.
# dataset_id = "my-project.my_dataset"

# ID of the user or group from whom you are revoking access.
# Alternatively, the JSON REST API representation of the entity,
# such as a view's table reference.
# entity_id = "[e-mail]"

# Instantiate a client.
client = bigquery.Client()

# Get a reference to the dataset.
dataset = client.get_dataset(dataset_id)

# To revoke access to a dataset, remove elements from the AccessEntry list.
#
# See the BigQuery client library documentation for more details on `access_entries`:
# https://cloud.google.com/python/docs/reference/bigquery/latest/google.cloud.bigquery.dataset.Dataset#google_cloud_bigquery_dataset_Dataset_access_entries

# Filter `access_entries` to exclude entries matching the specified entity_id
# and assign a new list back to the AccessEntry list.
dataset.access_entries = [
    entry for entry in dataset.access_entries
    if entry.entity_id != entity_id
]

# Update will only succeed if the dataset
# has not been modified externally since retrieval.
#
# See the BigQuery client library documentation for more details on `update_dataset`:
# https://cloud.google.com/python/docs/reference/bigquery/latest/google.cloud.bigquery.client.Client#google_cloud_bigquery_client_Client_update_dataset
try:
    # Update just the `access_entries` property of the dataset.
    dataset = client.update_dataset(
        dataset,
        ["access_entries"],
    )

    # Notify user that the API call was successful.
    full_dataset_id = f"{dataset.project}.{dataset.dataset_id}"
    print(f"Revoked dataset access for '{entity_id}' to ' dataset '{full_dataset_id}.'")
except PreconditionFailed:  # A read-modify-write error.
    print(
        f"Dataset '{dataset.dataset_id}' was modified remotely before this update. "
        "Fetch the latest version and retry."
    )

Trabajar con controles de acceso a tablas y vistas

Las vistas se tratan como recursos de tabla en BigQuery. Puedes proporcionar acceso a una tabla o una vista concediendo a una entidad principal de gestión de identidades y accesos un rol predefinido o personalizado que determine lo que puede hacer la entidad principal con la tabla o la vista. También se conoce como adjuntar una política de permiso a un recurso. Después de conceder acceso, puede ver los controles de acceso de la tabla o la vista, así como revocar el acceso a la tabla o la vista.

Conceder acceso a una tabla o una vista

Para disfrutar de un control de acceso pormenorizado, puedes asignar un rol de gestión de identidades y accesos predefinido o personalizado a una tabla o vista concretas. La tabla o la vista también hereda los controles de acceso especificados a nivel de conjunto de datos y superiores. Por ejemplo, si asignas a un principal el rol Propietario de datos de BigQuery en un conjunto de datos, ese principal también tendrá permisos de Propietario de datos de BigQuery en las tablas y vistas del conjunto de datos.

Para conceder acceso a una tabla o una vista, seleccione una de las siguientes opciones:

Consola

1. Ve a la página BigQuery.

   Ir a BigQuery

2. En el panel Explorador, expande tu proyecto y selecciona la tabla o la vista que quieras compartir.

3. Haz clic en Compartir .

4. Haz clic en Añadir principal.

5. En el campo New principals (Nuevos principales), introduce un principal.

6. En la lista Selecciona un rol, elige un rol predefinido o un rol personalizado.

7. Haz clic en Guardar.

8. Para volver a la tabla o ver los detalles, haz clic en Cerrar.

SQL

Para conceder acceso a tablas o vistas a principales, usa la GRANT instrucción DCL:

1. En la Google Cloud consola, ve a la página BigQuery.

   Ir a BigQuery

2. En el editor de consultas, introduce la siguiente instrucción:

   GRANT `ROLE_LIST`
   ON RESOURCE_TYPE RESOURCE_NAME
   TO "USER_LIST"

   Haz los cambios siguientes:

   • ROLE_LIST: un rol o una lista de roles separados por comas que quieras conceder

   • RESOURCE_TYPE: el tipo de recurso al que se aplica el rol.

     Entre los valores admitidos se incluyen los siguientes: TABLE, VIEW, MATERIALIZED VIEW y EXTERNAL TABLE.

   • RESOURCE_NAME: el nombre del recurso al que quieres conceder el permiso

   • USER_LIST: lista de usuarios separada por comas a los que se les ha concedido el rol

     Para ver una lista de formatos válidos, consulta user_list.

3. Haz clic en Ejecutar.

Para obtener más información sobre cómo ejecutar consultas, consulta Ejecutar una consulta interactiva.

En el siguiente ejemplo se asigna el rol Lector de datos de BigQuery en myTable:

GRANT `roles/bigquery.dataViewer`
ON TABLE `myProject`.myDataset.myTable
TO "user:[e-mail]", "user:[e-mail]"

bq

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Para dar acceso a una tabla o a una vista, usa el comando bq add-iam-policy-binding:

   bq add-iam-policy-binding --member=MEMBER_TYPE:MEMBER --role=ROLE
     --table=true RESOURCE

   Haz los cambios siguientes:

   • MEMBER_TYPE: el tipo de miembro, como user, group, serviceAccount o domain.
   • MEMBER: la dirección de correo o el nombre de dominio del miembro.
   • ROLE: el rol que quieres asignar al miembro.
   • RESOURCE: el nombre de la tabla o la vista cuya política quieras actualizar.

Terraform

Usa los recursos de google_bigquery_table_iam para actualizar el acceso a una tabla.

Importante: Los diferentes recursos que ofrece google_bigquery_table_iam pueden entrar en conflicto entre sí. Te recomendamos que leas atentamente la documentación sobre google_bigquery_table_iam antes de hacer cambios en el control de acceso con Terraform.

Definir la política de acceso de una tabla

En el siguiente ejemplo se muestra cómo usar el recurso google_bigquery_table_iam_policy para definir la política de IAM de la tabla mytable. De esta forma, se sustituirá cualquier política que ya esté asociada a la tabla:

# This file sets the IAM policy for the table created by
# https://github.com/terraform-google-modules/terraform-docs-samples/blob/main/bigquery/bigquery_create_table/main.tf.
# You must place it in the same local directory as that main.tf file,
# and you must have already applied that main.tf file to create
# the "default" table resource with a table_id of "mytable".

data "google_iam_policy" "iam_policy" {
  binding {
    role = "roles/bigquery.dataOwner"
    members = [
      "user:[e-mail]",
    ]
  }
}

resource "google_bigquery_table_iam_policy" "table_iam_policy" {
  dataset_id  = google_bigquery_table.default.dataset_id
  table_id    = google_bigquery_table.default.table_id
  policy_data = data.google_iam_policy.iam_policy.policy_data
}

Definir la pertenencia a un rol de una tabla

En el siguiente ejemplo se muestra cómo usar el recurso google_bigquery_table_iam_binding para definir la pertenencia a un rol determinado en la tabla mytable. De esta forma, se sustituirá cualquier pertenencia a ese rol. Se conservarán otros roles de la política de gestión de identidades y accesos de la tabla.

# This file sets membership in an IAM role for the table created by
# https://github.com/terraform-google-modules/terraform-docs-samples/blob/main/bigquery/bigquery_create_table/main.tf.
# You must place it in the same local directory as that main.tf file,
# and you must have already applied that main.tf file to create
# the "default" table resource with a table_id of "mytable".

resource "google_bigquery_table_iam_binding" "table_iam_binding" {
  dataset_id = google_bigquery_table.default.dataset_id
  table_id   = google_bigquery_table.default.table_id
  role       = "roles/bigquery.dataOwner"

  members = [
    "group:[e-mail]",
  ]
}

Definir la pertenencia a un rol para un solo principal

En el siguiente ejemplo se muestra cómo usar el recurso google_bigquery_table_iam_member para actualizar la política de gestión de identidades y accesos de la tabla mytable y asignar un rol a un principal. Actualizar esta política de IAM no afecta al acceso de ninguna otra entidad a la que se le haya concedido ese rol para el conjunto de datos.

# This file adds a member to an IAM role for the table created by
# https://github.com/terraform-google-modules/terraform-docs-samples/blob/main/bigquery/bigquery_create_table/main.tf.
# You must place it in the same local directory as that main.tf file,
# and you must have already applied that main.tf file to create
# the "default" table resource with a table_id of "mytable".

resource "google_bigquery_table_iam_member" "table_iam_member" {
  dataset_id = google_bigquery_table.default.dataset_id
  table_id   = google_bigquery_table.default.table_id
  role       = "roles/bigquery.dataEditor"
  member     = "serviceAccount:[e-mail]"
}

Para aplicar la configuración de Terraform en un proyecto, sigue los pasos que se indican en las siguientes secciones. Google Cloud

Preparar Cloud Shell

1. Abre Cloud Shell.

2. Define el Google Cloud proyecto Google Cloud predeterminado en el que quieras aplicar tus configuraciones de Terraform.

   Solo tiene que ejecutar este comando una vez por proyecto y puede hacerlo en cualquier directorio.

   export GOOGLE_CLOUD_PROJECT=PROJECT_ID

   Las variables de entorno se anulan si defines valores explícitos en el archivo de configuración de Terraform.

Preparar el directorio

Cada archivo de configuración de Terraform debe tener su propio directorio (también llamado módulo raíz).

1. En Cloud Shell, crea un directorio y un archivo nuevo en ese directorio. El nombre del archivo debe tener la extensión .tf. Por ejemplo, main.tf. En este tutorial, nos referiremos al archivo como main.tf.

   mkdir DIRECTORY && cd DIRECTORY && touch main.tf

2. Si estás siguiendo un tutorial, puedes copiar el código de ejemplo de cada sección o paso.

   Copia el código de ejemplo en el archivo main.tf que acabas de crear.

   También puedes copiar el código de GitHub. Se recomienda cuando el fragmento de Terraform forma parte de una solución integral.

3. Revisa y modifica los parámetros de ejemplo para aplicarlos a tu entorno.
4. Guarda los cambios.
5. Inicializa Terraform. Solo tienes que hacerlo una vez por directorio.

   terraform init

   Si quieres usar la versión más reciente del proveedor de Google, incluye la opción -upgrade:

   terraform init -upgrade

Aplica los cambios

1. Revisa la configuración y comprueba que los recursos que va a crear o actualizar Terraform se ajustan a tus expectativas:

   terraform plan

   Haga las correcciones necesarias en la configuración.

2. Aplica la configuración de Terraform ejecutando el siguiente comando e introduciendo yes en la petición:

   terraform apply

   Espera hasta que Terraform muestre el mensaje "Apply complete!".

3. Abre tu Google Cloud proyecto para ver los resultados. En la Google Cloud consola, ve a tus recursos en la interfaz de usuario para asegurarte de que Terraform los ha creado o actualizado.

Nota: Los ejemplos de Terraform suelen presuponer que las APIs necesarias están habilitadas en tu proyecto. Google Cloud

API

1. Para obtener la política actual, llama al método tables.getIamPolicy.

2. Edita la política para añadir miembros o controles de acceso, o ambos. Para ver el formato que exige la política, consulta el tema de referencia Política.

   Precaución: Antes de definir la política, siempre debes obtener la política actual para obtener el valor actual de etag. El archivo de política actualizado debe incluir el mismo valor para etag que la política actual que vas a sustituir. De lo contrario, la actualización no se realizará. Esta función evita que se produzcan actualizaciones simultáneas.
   
   En el archivo de política, el valor de version sigue siendo 1. Este número de versión hace referencia a la versión del esquema de la política de gestión de identidades y accesos, no a la versión de la política. El valor de etag es el número de versión de la política.

3. Llama a tables.setIamPolicy para escribir la política actualizada.

   Nota: No se permiten enlaces vacíos sin miembros, lo que provoca un error.

Go

Antes de probar este ejemplo, sigue las Goinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Go de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

Llama a la función IAM().SetPolicy() del recurso para guardar los cambios en la política de acceso de una tabla o una vista.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
	"cloud.google.com/go/iam"
)

// grantAccessToResource creates a new ACL conceding the VIEWER role to the group "[e-mail]"
// For more information on the types of ACLs available see:
// https://cloud.google.com/storage/docs/access-control/lists
func grantAccessToResource(w io.Writer, projectID, datasetID, resourceID string) error {
	// Resource can be a table or a view
	//
	// TODO(developer): uncomment and update the following lines:
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// resourceID := "myresource"

	ctx := context.Background()

	// Create new client
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	// Get resource policy.
	policy, err := client.Dataset(datasetID).Table(resourceID).IAM().Policy(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	// Find more details about IAM Roles here:
	// https://pkg.go.dev/cloud.google.com/go/iam#RoleName
	entityID := "[e-mail]"
	roleType := iam.Viewer

	// Add new policy.
	policy.Add(fmt.Sprintf("group:%s", entityID), roleType)

	// Update resource's policy.
	err = client.Dataset(datasetID).Table(resourceID).IAM().SetPolicy(ctx, policy)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	// Get resource policy again expecting the update.
	policy, err = client.Dataset(datasetID).Table(resourceID).IAM().Policy(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	fmt.Fprintf(w, "Details for Access entries in table or view %v.\n", resourceID)

	for _, role := range policy.Roles() {
		fmt.Fprintln(w)
		fmt.Fprintf(w, "Role: %s\n", role)
		fmt.Fprintf(w, "Entities: %v\n", policy.Members(role))
	}

	return nil
}

Java

Antes de probar este ejemplo, sigue las Javainstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

import com.google.cloud.Identity;
import com.google.cloud.Policy;
import com.google.cloud.Role;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.TableId;

public class GrantAccessToTableOrView {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    // Project, dataset and resource (table or view) from which to get the access policy.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    String resourceName = "MY_TABLE_NAME";
    // Role to add to the policy access
    Role role = Role.of("roles/bigquery.dataViewer");
    // Identity to add to the policy access
    Identity identity = Identity.user("[e-mail]");
    grantAccessToTableOrView(projectId, datasetName, resourceName, role, identity);
  }

  public static void grantAccessToTableOrView(
      String projectId, String datasetName, String resourceName, Role role, Identity identity) {
    try {
      // Initialize client that will be used to send requests. This client only needs
      // to be created once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      // Create table identity given the projectId, the datasetName and the resourceName.
      TableId tableId = TableId.of(projectId, datasetName, resourceName);

      // Add new user identity to current IAM policy.
      Policy policy = bigquery.getIamPolicy(tableId);
      policy = policy.toBuilder().addIdentity(role, identity).build();

      // Update the IAM policy by setting the new one.
      bigquery.setIamPolicy(tableId, policy);

      System.out.println("IAM policy of resource \"" + resourceName + "\" updated successfully");
    } catch (BigQueryException e) {
      System.out.println("IAM policy was not updated. \n" + e.toString());
    }
  }
}

Node.js

Antes de probar este ejemplo, sigue las Node.jsinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

Llama a la función Table#getIamPolicy() para obtener la política de gestión de identidades y accesos actual de una tabla o una vista, modifica la política añadiendo nuevas vinculaciones y, a continuación, usa la función Table#setIamPolicy() para guardar los cambios en la política de acceso.

/**
 * TODO(developer): Update and un-comment below lines
 */
// const projectId = "YOUR_PROJECT_ID";
// const datasetId = "YOUR_DATASET_ID";
// const tableId = "YOUR_TABLE_ID";
// const principalId = "YOUR_PRINCIPAL_ID";
// const role = "YOUR_ROLE";

const {BigQuery} = require('@google-cloud/bigquery');

// Instantiate a client.
const client = new BigQuery();

async function grantAccessToTableOrView() {
  const dataset = client.dataset(datasetId);
  const table = dataset.table(tableId);

  // Get the IAM access policy for the table or view.
  const [policy] = await table.getIamPolicy();

  // Initialize bindings array.
  if (!policy.bindings) {
    policy.bindings = [];
  }

  // To grant access to a table or view
  // add bindings to the Table or View policy.
  //
  // Find more details about Policy and Binding objects here:
  // https://cloud.google.com/security-command-center/docs/reference/rest/Shared.Types/Policy
  // https://cloud.google.com/security-command-center/docs/reference/rest/Shared.Types/Binding
  const binding = {
    role,
    members: [principalId],
  };
  policy.bindings.push(binding);

  // Set the IAM access policy with updated bindings.
  await table.setIamPolicy(policy);

  // Show a success message.
  console.log(
    `Role '${role}' granted for principal '${principalId}' on resource '${datasetId}.${tableId}'.`
  );
}

await grantAccessToTableOrView();

Python

Antes de probar este ejemplo, sigue las Pythoninstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Python de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

Llama a la función client.set_iam_policy() para guardar los cambios en la política de acceso de una tabla o una vista.

from google.cloud import bigquery

# TODO(developer): Update and uncomment the lines below.

# Google Cloud Platform project.
# project_id = "my_project_id"

# Dataset where the table or view is.
# dataset_id = "my_dataset"

# Table or view name to get the access policy.
# resource_name = "my_table"

# Principal to grant access to a table or view.
# For more information about principal identifiers see:
# https://cloud.google.com/iam/docs/principal-identifiers
# principal_id = "user:[e-mail]"

# Role to grant to the principal.
# For more information about BigQuery roles see:
# https://cloud.google.com/bigquery/docs/access-control
# role = "roles/bigquery.dataViewer"

# Instantiate a client.
client = bigquery.Client()

# Get the full table or view name.
full_resource_name = f"{project_id}.{dataset_id}.{resource_name}"

# Get the IAM access policy for the table or view.
policy = client.get_iam_policy(full_resource_name)

# To grant access to a table or view, add bindings to the IAM policy.
#
# Find more details about Policy and Binding objects here:
# https://cloud.google.com/security-command-center/docs/reference/rest/Shared.Types/Policy
# https://cloud.google.com/security-command-center/docs/reference/rest/Shared.Types/Binding
binding = {
    "role": role,
    "members": [principal_id, ],
}
policy.bindings.append(binding)

# Set the IAM access policy with updated bindings.
updated_policy = client.set_iam_policy(full_resource_name, policy)

# Show a success message.
print(
    f"Role '{role}' granted for principal '{principal_id}'"
    f" on resource '{full_resource_name}'."
)

Roles predefinidos que conceden acceso a tablas y vistas

Las vistas se tratan como recursos de tabla en BigQuery. Para obtener un control de acceso pormenorizado, puedes asignar un rol de gestión de identidades y accesos predefinido o personalizado a una tabla o vista específica. La tabla o la vista también hereda los controles de acceso especificados a nivel de conjunto de datos y superiores. Por ejemplo, si asignas a una entidad el rol Propietario de datos de BigQuery en un conjunto de datos, esa entidad también tendrá permisos de propietario de datos en las tablas y vistas del conjunto de datos.

Los siguientes roles de gestión de identidades y accesos predefinidos tienen permisos en tablas o vistas.

Precaución: Aunque es posible asignar permisos de administrador de BigQuery o de administrador de BigQuery Studio a una tabla o una vista, no deberías asignar estos roles a nivel de tabla o de vista. El rol Propietario de datos de BigQuery también concede todos los permisos de tablas y vistas, y es un rol menos permisivo. Los roles Administrador de BigQuery y Administrador de BigQuery Studio se suelen conceder a nivel de proyecto.

Rol	Descripción
Propietario de datos de BigQuery (roles/bigquery.dataOwner)	Si se concede en una tabla o una vista, este rol otorga los siguientes permisos: Todos los permisos de la tabla o la vista. Todos los permisos de las políticas de acceso a las filas, excepto el permiso para anular las restricciones de viajes en el tiempo. Definir categorías y políticas de datos a nivel de columna. Nota: Las entidades a las que se les asigna el rol Propietario de datos a nivel de conjunto de datos también pueden crear tablas y enumerar las tablas del conjunto de datos.
Editor de datos de BigQuery (roles/bigquery.dataEditor)	Si se concede en una tabla o una vista, este rol otorga los siguientes permisos: Obtener metadatos, actualizar metadatos, obtener controles de acceso y eliminar la tabla o la vista. Obtener (consultar), exportar, replicar y actualizar datos de tablas. Crear, actualizar y eliminar índices. Crea y restaura capturas. Nota: Las entidades a las que se les ha asignado el rol Editor de datos a nivel de conjunto de datos también pueden crear tablas y enumerarlas en el conjunto de datos.
Lector de datos de BigQuery (roles/bigquery.dataViewer)	Si se concede en una tabla o una vista, este rol otorga los siguientes permisos: Obtiene los metadatos y los controles de acceso de la tabla o la vista. Obtener (consultar), exportar y replicar datos de tablas. Crea capturas. Nota: Las principales a las que se les haya asignado el rol Lector de datos a nivel de conjunto de datos también pueden enumerar las tablas del conjunto de datos.
Visor de metadatos de BigQuery (roles/bigquery.metadataViewer)	Si se concede en una tabla o una vista, este rol otorga los siguientes permisos: Obtiene los metadatos y los controles de acceso de la tabla o la vista. Nota: Las entidades a las que se les asigna el rol Lector de metadatos a nivel de conjunto de datos también pueden enumerar las tablas del conjunto de datos.

Permisos de tablas y vistas

Las vistas se tratan como recursos de tabla en BigQuery. Todos los permisos a nivel de tabla se aplican a las vistas.

La mayoría de los permisos que empiezan por bigquery.tables se aplican a nivel de tabla. bigquery.tables.create y bigquery.tables.list no. Para crear y enumerar tablas o vistas, se deben conceder los permisos bigquery.tables.create y bigquery.tables.list a un rol en un contenedor superior (el conjunto de datos o el proyecto).

En la siguiente tabla se enumeran todos los permisos de tablas y vistas, así como el recurso de nivel más bajo al que se pueden conceder.

Permiso	Recurso	Acción
bigquery.tables.create	Conjunto de datos	Crea tablas en el conjunto de datos.
bigquery.tables.createIndex	Tabla	Crea un índice de búsqueda en la tabla.
bigquery.tables.deleteIndex	Tabla	Eliminar un índice de búsqueda de la tabla.
bigquery.tables.createSnapshot	Tabla	Crea una captura de la tabla. Para crear una captura, se necesitan varios permisos adicionales a nivel de tabla y de conjunto de datos. Para obtener más información, consulta la sección sobre permisos y roles para crear copias de tablas.
bigquery.tables.deleteSnapshot	Tabla	Elimina una captura de la tabla.
bigquery.tables.delete	Tabla	Elimina una tabla.
bigquery.tables.createTagBinding	Tabla	Crea enlaces de etiquetas de recursos en una tabla.
bigquery.tables.deleteTagBinding	Tabla	Elimina las vinculaciones de etiquetas de recursos de una tabla.
bigquery.tables.listTagBindings	Tabla	Muestra las vinculaciones de etiquetas de recursos de una tabla.
bigquery.tables.listEffectiveTags	Tabla	Lista las etiquetas efectivas (aplicadas y heredadas) de la tabla.
bigquery.tables.export	Tabla	Exporta los datos de la tabla. Para ejecutar una tarea de exportación, también se necesitan permisos de bigquery.jobs.create.
bigquery.tables.get	Tabla	Obtiene los metadatos de una tabla.
bigquery.tables.getData	Tabla	Consultar los datos de la tabla. Para ejecutar una tarea de consulta, también se necesitan permisos de bigquery.jobs.create.
bigquery.tables.getIamPolicy	Tabla	Obtiene los controles de acceso de la tabla.
bigquery.tables.list	Conjunto de datos	Muestra todas las tablas y los metadatos de las tablas del conjunto de datos.
bigquery.tables.replicateData	Tabla	Replicar datos de tablas. Este permiso es necesario para crear réplicas de vistas materializadas.
bigquery.tables.restoreSnapshot	Tabla	Restaurar una captura de una tabla.
bigquery.tables.setCategory	Tabla	Defina etiquetas de política en el esquema de la tabla.
bigquery.tables.setColumnDataPolicy	Tabla	Definir políticas de acceso a nivel de columna en una tabla.
bigquery.tables.setIamPolicy	Tabla	Define controles de acceso en una tabla.
bigquery.tables.update	Tabla	Actualiza la tabla. metadata. bigquery.tables.get también es necesario para actualizar los metadatos de la tabla en la consola.
bigquery.tables.updateData	Tabla	Actualiza los datos de la tabla.
bigquery.tables.updateIndex	Tabla	Actualiza un índice de búsqueda en la tabla.

Ver los controles de acceso de una tabla o una vista

Para ver los controles de acceso de una tabla o una vista, elija una de las siguientes opciones:

Consola

1. Ve a la página BigQuery.

   Ir a BigQuery

2. En el panel Explorador, expande tu proyecto, expande un conjunto de datos y selecciona una tabla o una vista.

3. Haz clic en Compartir .

   Los controles de acceso a la tabla o la vista aparecen en el panel Compartir.

bq

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Para obtener una política de acceso y guardarla en un archivo local en formato JSON, usa el comando bq get-iam-policy en Cloud Shell:

   bq get-iam-policy \
       --table=true \
       PROJECT_ID:DATASET.RESOURCE > PATH_TO_FILE

   Haz los cambios siguientes:

   • PROJECT_ID: tu ID de proyecto
   • DATASET: el nombre del conjunto de datos
   • RESOURCE: el nombre de la tabla o de la vista cuya política quieres ver
   • PATH_TO_FILE: la ruta al archivo JSON de tu máquina local

SQL

Vista previa

Este producto o función está sujeto a los "Términos de las Ofertas de Acceso Previo a la Disponibilidad General" de la sección Términos Generales de los Servicios de los Términos Específicos de los Servicios. Los productos y las funciones previos a la disponibilidad general están disponibles tal cual y pueden tener una compatibilidad y asistencia limitadas. Para obtener más información, consulta las descripciones de las fases de lanzamiento.

Consulta la INFORMATION_SCHEMA.OBJECT_PRIVILEGES vista. Las consultas para obtener los controles de acceso de una tabla o una vista deben especificar object_schema y object_name.

1. En la Google Cloud consola, ve a la página BigQuery.

   Ir a BigQuery

2. En el editor de consultas, introduce la siguiente instrucción:

   SELECT
   COLUMN_LIST
   FROM
     PROJECT_ID.`region-REGION`.INFORMATION_SCHEMA.OBJECT_PRIVILEGES
   WHERE
   object_schema = "DATASET" AND object_name = "TABLE";

   Haz los cambios siguientes:

   • COLUMN_LIST: una lista separada por comas de las columnas de la vista INFORMATION_SCHEMA.OBJECT_PRIVILEGES
   • PROJECT_ID: tu ID de proyecto
   • REGION: un calificador de región
   • DATASET: el nombre de un conjunto de datos que contiene la tabla o la vista
   • TABLE: el nombre de la tabla o la vista

3. Haz clic en Ejecutar.

Para obtener más información sobre cómo ejecutar consultas, consulta Ejecutar una consulta interactiva.

Ejemplo:

SELECT
object_name, privilege_type, grantee
FROM
my_project.`region-us`.INFORMATION_SCHEMA.OBJECT_PRIVILEGES
WHERE
object_schema = "mydataset" AND object_name = "mytable";

+------------------+-----------------------------+--------------------------+
|   object_name    |  privilege_type             | grantee                  |
+------------------+-----------------------------+--------------------------+
| mytable          | roles/bigquery.dataEditor   | group:[e-mail]|
| mytable          | roles/bigquery.dataOwner    | user:[e-mail]|
+------------------+-----------------------------+--------------------------+

API

Para obtener la política actual, llama al método tables.getIamPolicy.

Nota: En el caso de las vistas, usa tables como valor de resource en esta llamada a la API.

Go

Antes de probar este ejemplo, sigue las Goinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Go de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

Llama a la función IAM().Policy() del recurso. A continuación, llama a la función Roles() para obtener la política de acceso de una tabla o una vista.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
)

// viewTableOrViewAccessPolicies retrieves the ACL for the given resource
// For more information on the types of ACLs available see:
// https://cloud.google.com/storage/docs/access-control/lists
func viewTableOrViewAccessPolicies(w io.Writer, projectID, datasetID, resourceID string) error {
	// Resource can be a table or a view
	//
	// TODO(developer): uncomment and update the following lines:
	// projectID := "my-project-id"
	// datasetID := "my-dataset-id"
	// resourceID := "my-resource-id"

	ctx := context.Background()

	// Create new client.
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	// Get resource's policy access.
	policy, err := client.Dataset(datasetID).Table(resourceID).IAM().Policy(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	fmt.Fprintf(w, "Details for Access entries in table or view %v.\n", resourceID)

	for _, role := range policy.Roles() {
		fmt.Fprintln(w)
		fmt.Fprintf(w, "Role: %s\n", role)
		fmt.Fprintf(w, "Entities: %v\n", policy.Members(role))
	}

	return nil
}

Java

Antes de probar este ejemplo, sigue las Javainstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

import com.google.cloud.Policy;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.TableId;

public class GetTableOrViewAccessPolicy {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    // Project, dataset and resource (table or view) from which to get the access policy.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    String resourceName = "MY_RESOURCE_NAME";
    getTableOrViewAccessPolicy(projectId, datasetName, resourceName);
  }

  public static void getTableOrViewAccessPolicy(
      String projectId, String datasetName, String resourceName) {
    try {
      // Initialize client that will be used to send requests. This client only needs
      // to be created once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      // Create table identity given the projectId, the datasetName and the resourceName.
      TableId tableId = TableId.of(projectId, datasetName, resourceName);

      // Get the table IAM policy.
      Policy policy = bigquery.getIamPolicy(tableId);

      // Show policy details.
      // Find more information about the Policy Class here:
      // https://cloud.google.com/java/docs/reference/google-cloud-core/latest/com.google.cloud.Policy
      System.out.println(
          "IAM policy info of resource \"" + resourceName + "\" retrieved succesfully");
      System.out.println();
      System.out.println("IAM policy info: " + policy.toString());
    } catch (BigQueryException e) {
      System.out.println("IAM policy info not retrieved. \n" + e.toString());
    }
  }
}

Node.js

Antes de probar este ejemplo, sigue las Node.jsinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

Recupera la política de gestión de identidades y accesos de una tabla o una vista con la función Table#getIamPolicy(). Los detalles de la política de acceso están disponibles en el objeto de política devuelto.

/**
 * TODO(developer): Update and un-comment below lines
 */
// const projectId = "YOUR_PROJECT_ID"
// const datasetId = "YOUR_DATASET_ID"
// const resourceName = "YOUR_RESOURCE_NAME";

const {BigQuery} = require('@google-cloud/bigquery');

// Instantiate a client.
const client = new BigQuery();

async function viewTableOrViewAccessPolicy() {
  const dataset = client.dataset(datasetId);
  const table = dataset.table(resourceName);

  // Get the IAM access policy for the table or view.
  const [policy] = await table.getIamPolicy();

  // Initialize bindings if they don't exist
  if (!policy.bindings) {
    policy.bindings = [];
  }

  // Show policy details.
  // Find more details for the Policy object here:
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Policy
  console.log(`Access Policy details for table or view '${resourceName}'.`);
  console.log(`Bindings: ${JSON.stringify(policy.bindings, null, 2)}`);
  console.log(`etag: ${policy.etag}`);
  console.log(`Version: ${policy.version}`);
}

Revocar el acceso a una tabla o una vista

Para revocar el acceso a una tabla o una vista, selecciona una de las siguientes opciones:

Consola

1. Ve a la página BigQuery.

   Ir a BigQuery

2. En el panel Explorador, expande tu proyecto, expande un conjunto de datos y selecciona una tabla o una vista.

3. En el panel de detalles, haz clic en Compartir.

4. En el cuadro de diálogo Compartir, despliega el principal cuyo acceso quieras revocar.

5. Haz clic en Eliminar.

6. En el cuadro de diálogo ¿Quitar rol del principal?, haz clic en Quitar.

7. Para volver a la tabla o ver los detalles, haz clic en Cerrar.

Nota: Si no puedes revocar el acceso, es posible que la cuenta principal haya heredado el acceso de un nivel superior de la jerarquía de recursos.

SQL

Para quitar el acceso a tablas o vistas de principales, usa la REVOKE instrucción DCL:

1. En la Google Cloud consola, ve a la página BigQuery.

   Ir a BigQuery

2. En el editor de consultas, introduce la siguiente instrucción:

   REVOKE `ROLE_LIST`
   ON RESOURCE_TYPE RESOURCE_NAME
   FROM "USER_LIST"

   Haz los cambios siguientes:

   • ROLE_LIST: un rol o una lista de roles separados por comas que quieras revocar

   • RESOURCE_TYPE: el tipo de recurso del que se revoca el rol

     Entre los valores admitidos se incluyen los siguientes: TABLE, VIEW, MATERIALIZED VIEW y EXTERNAL TABLE.

   • RESOURCE_NAME: el nombre del recurso cuyo permiso quieres revocar

   • USER_LIST: lista de usuarios separados por comas a los que se les revocarán los roles.

     Para ver una lista de formatos válidos, consulta user_list.

3. Haz clic en Ejecutar.

Para obtener más información sobre cómo ejecutar consultas, consulta Ejecutar una consulta interactiva.

En el siguiente ejemplo, se revoca el rol Propietario de datos de BigQuery en myTable:

REVOKE `roles/bigquery.dataOwner`
ON TABLE `myProject`.myDataset.myTable
FROM "group:[e-mail]", "serviceAccount:[e-mail]"

bq

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Para revocar el acceso a una tabla o una vista, usa el comando bq remove-iam-policy-binding:

   bq remove-iam-policy-binding --member=MEMBER_TYPE:MEMBER --role=ROLE
   --table=true RESOURCE

   Haz los cambios siguientes:

   • MEMBER_TYPE: el tipo de miembro, como user, group, serviceAccount o domain
   • MEMBER: la dirección de correo o el nombre de dominio del miembro
   • ROLE: el rol que quieres revocar al miembro
   • RESOURCE: el nombre de la tabla o la vista cuya política quieras actualizar

API

1. Para obtener la política actual, llama al método tables.getIamPolicy.

2. Edita la política para eliminar miembros, enlaces o ambos. Para ver el formato que exige la política, consulta el tema de referencia Política.

   Precaución: Cuando definas la política, siempre debes obtener la política actual como primer paso para obtener el valor actual de etag. El archivo de la política actualizada debe incluir el mismo valor para etag que la política actual que vas a sustituir. De lo contrario, la actualización no se realizará. Esta función evita que se produzcan actualizaciones simultáneas.
   
   En el archivo de política, el valor de version sigue siendo 1. Este número de versión hace referencia a la versión del esquema de la política de gestión de identidades y accesos, no a la versión de la política. El valor de etag es el número de versión de la política.

3. Llama a tables.setIamPolicy para escribir la política actualizada.

Nota: No se permiten enlaces vacíos sin miembros, lo que provoca un error.

Go

Antes de probar este ejemplo, sigue las Goinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Go de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

Llama a la función policy.Remove() para quitar el acceso. A continuación, llama a la función IAM().SetPolicy() para guardar los cambios en la política de acceso de una tabla o una vista.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
	"cloud.google.com/go/iam"
)

// revokeTableOrViewAccessPolicies creates a new ACL removing the VIEWER role to group "[e-mail]"
// For more information on the types of ACLs available see:
// https://cloud.google.com/storage/docs/access-control/lists
func revokeTableOrViewAccessPolicies(w io.Writer, projectID, datasetID, resourceID string) error {
	// Resource can be a table or a view
	//
	// TODO(developer): uncomment and update the following lines:
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// resourceID := "myresource"

	ctx := context.Background()

	// Create new client
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	// Get resource policy.
	policy, err := client.Dataset(datasetID).Table(resourceID).IAM().Policy(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	// Find more details about IAM Roles here:
	// https://pkg.go.dev/cloud.google.com/go/iam#RoleName
	entityID := "[e-mail]"
	roleType := iam.Viewer

	// Revoke policy access.
	policy.Remove(fmt.Sprintf("group:%s", entityID), roleType)

	// Update resource's policy.
	err = client.Dataset(datasetID).Table(resourceID).IAM().SetPolicy(ctx, policy)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	// Get resource policy again expecting the update.
	policy, err = client.Dataset(datasetID).Table(resourceID).IAM().Policy(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	fmt.Fprintf(w, "Details for Access entries in table or view %v.\n", resourceID)

	for _, role := range policy.Roles() {
		fmt.Fprintln(w)
		fmt.Fprintf(w, "Role: %s\n", role)
		fmt.Fprintf(w, "Entities: %v\n", policy.Members(role))
	}

	return nil
}

Java

Antes de probar este ejemplo, sigue las Javainstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

import com.google.cloud.Identity;
import com.google.cloud.Policy;
import com.google.cloud.Role;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.TableId;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class RevokeAccessToTableOrView {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    // Project, dataset and resource (table or view) from which to get the access policy
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    String resourceName = "MY_RESOURCE_NAME";
    // Role to remove from the access policy
    Role role = Role.of("roles/bigquery.dataViewer");
    // Identity to remove from the access policy
    Identity user = Identity.user("[e-mail]");
    revokeAccessToTableOrView(projectId, datasetName, resourceName, role, user);
  }

  public static void revokeAccessToTableOrView(
      String projectId, String datasetName, String resourceName, Role role, Identity identity) {
    try {
      // Initialize client that will be used to send requests. This client only needs
      // to be created once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      // Create table identity given the projectId, the datasetName and the resourceName.
      TableId tableId = TableId.of(projectId, datasetName, resourceName);

      // Remove either identities or roles, or both from bindings and replace it in
      // the current IAM policy.
      Policy policy = bigquery.getIamPolicy(tableId);
      // Create a copy of an immutable map.
      Map<Role, Set<Identity>> bindings = new HashMap<>(policy.getBindings());

      // Remove all identities with a specific role.
      bindings.remove(role);
      // Update bindings.
      policy = policy.toBuilder().setBindings(bindings).build();

      // Remove one identity in all the existing roles.
      for (Role roleKey : bindings.keySet()) {
        if (bindings.get(roleKey).contains(identity)) {
          // Create a copy of an immutable set if the identity is present in the role.
          Set<Identity> identities = new HashSet<>(bindings.get(roleKey));
          // Remove identity.
          identities.remove(identity);
          bindings.put(roleKey, identities);
          if (bindings.get(roleKey).isEmpty()) {
            // Remove the role if it has no identities.
            bindings.remove(roleKey);
          }
        }
      }
      // Update bindings.
      policy = policy.toBuilder().setBindings(bindings).build();

      // Update the IAM policy by setting the new one.
      bigquery.setIamPolicy(tableId, policy);

      System.out.println("IAM policy of resource \"" + resourceName + "\" updated successfully");
    } catch (BigQueryException e) {
      System.out.println("IAM policy was not updated. \n" + e.toString());
    }
  }
}

Node.js

Antes de probar este ejemplo, sigue las Node.jsinstrucciones de configuración de la guía de inicio rápido de BigQuery con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de BigQuery.

Para autenticarte en BigQuery, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación para bibliotecas de cliente.

Recupera la política de gestión de identidades y accesos actual de una tabla o una vista con el método Table#getIamPolicy(). Modifica la política para quitar el rol o el principal que quieras y, a continuación, aplica la política actualizada con el método Table#setIamPolicy().

/**
 * TODO(developer): Update and un-comment below lines
 */
// const projectId = "YOUR_PROJECT_ID"
// const datasetId = "YOUR_DATASET_ID"
// const tableId = "YOUR_TABLE_ID"
// const roleToRemove = "YOUR_ROLE"
// const principalToRemove = "YOUR_PRINCIPAL_ID"

const {BigQuery} = require('@google-cloud/bigquery');

// Instantiate a client.
const client = new BigQuery();

async function revokeAccessToTableOrView() {
  const dataset = client.dataset(datasetId);
  const table = dataset.table(tableId);

  // Get the IAM access policy for the table or view.
  const [policy] = await table.getIamPolicy();

  // Initialize bindings array.
  if (!policy.bindings) {
    policy.bindings = [];
  }

  // To revoke access to a table or view,
  // remove bindings from the Table or View policy.
  //
  // Find more details about Policy objects here:
  // https://cloud.google.com/security-command-center/docs/reference/rest/Shared.Types/Policy

  if (principalToRemove) {
    // Create a copy of bindings for modifications.
    const bindings = [...policy.bindings];

    // Filter out the principal from each binding.
    for (const binding of bindings) {
      if (binding.members) {
        binding.members = binding.members.filter(
          m => m !== principalToRemove
        );
      }
    }

    // Filter out bindings with empty members.
    policy.bindings = bindings.filter(
      binding => binding.members && binding.members.length > 0
    );
  }

  if (roleToRemove) {
    // Filter out all bindings with the roleToRemove
    // and assign a new list back to the policy bindings.
    policy.bindings = policy.bindings.filter(b => b.role !== roleToRemove);
  }

  // Set the IAM access policy with updated bindings.
  await table.setIamPolicy(policy);

  // Both role and principal are removed
  if (roleToRemove !== null && principalToRemove !== null) {
    console.log(
      `Role '${roleToRemove}' revoked for principal '${principalToRemove}' on resource '${datasetId}.${tableId}'.`
    );
  }

  // Only role is removed
  if (roleToRemove !== null && principalToRemove === null) {
    console.log(
      `Role '${roleToRemove}' revoked for all principals on resource '${datasetId}.${tableId}'.`
    );
  }

  // Only principal is removed
  if (roleToRemove === null && principalToRemove !== null) {
    console.log(
      `Access revoked for principal '${principalToRemove}' on resource '${datasetId}.${tableId}'.`
    );
  }

  // No changes were made
  if (roleToRemove === null && principalToRemove === null) {
    console.log(
      `No changes made to access policy for '${datasetId}.${tableId}'.`
    );
  }
}

Trabajar con controles de acceso para rutinas

Vista previa

Esta función está sujetas a los "Términos de las Ofertas de Acceso Previo a la Disponibilidad General" de la sección Términos Generales de los Servicios de los Términos Específicos de los Servicios. Las funciones previas a la disponibilidad general están disponibles tal cual y pueden tener una compatibilidad y asistencia limitadas. Para obtener más información, consulta las descripciones de las fases de lanzamiento.

Para enviar comentarios o solicitar asistencia sobre esta función, escribe un correo a [e-mail].

Puedes proporcionar acceso a una rutina concediendo a una entidad principal de gestión de identidades y accesos](/iam/docs/principal-identifiers#allow) un rol predefinido o personalizado que determine lo que puede hacer la entidad principal con la rutina. También se conoce como adjuntar una política de permiso a un recurso. Después de conceder acceso, puedes ver los controles de acceso de la rutina y revocar el acceso a ella.

Dar acceso a una rutina

Para tener un control de acceso pormenorizado, puedes asignar un rol de gestión de identidades y accesos predefinido o personalizado a una rutina específica. La rutina también hereda los controles de acceso especificados en el nivel del conjunto de datos y en niveles superiores. Por ejemplo, si asignas el rol Propietario de datos de BigQuery a una entidad en un conjunto de datos, esa entidad también tendrá permisos de propietario de datos en las rutinas del conjunto de datos.

Selecciona una de las opciones siguientes:

Consola

1. Ve a la página BigQuery.

   Ir a BigQuery

2. En el panel Explorador, expande tu proyecto, tu conjunto de datos y Rutinas. A continuación, selecciona una rutina.

3. Haz clic en Compartir .

4. Haz clic en Añadir miembros.

5. En el campo Miembros nuevos, introduce un principal.

6. En la lista Selecciona un rol, elige un rol predefinido o un rol personalizado.

7. Haz clic en Guardar.

8. Para volver a la información de la rutina, haz clic en Hecho.

bq

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Para escribir la información de la rutina (incluidos los controles de acceso) en un archivo JSON, usa el comando bq get-iam-policy:

   bq get-iam-policy \
       PROJECT_ID:DATASET.ROUTINE \
       > PATH_TO_FILE

   Haz los cambios siguientes:

   • PROJECT_ID: tu ID de proyecto
   • DATASET: el nombre del conjunto de datos que contiene la rutina que quieres actualizar
   • ROUTINE: el nombre del recurso que se va a actualizar
   • PATH_TO_FILE: la ruta al archivo JSON en tu máquina local
   Precaución: Cuando definas la política, siempre debes obtener la política actual como primer paso para obtener el valor actual de etag. El archivo de la política actualizada debe incluir el mismo valor para etag que la política actual que vas a sustituir. De lo contrario, la actualización no se realizará. Esta función evita que se produzcan actualizaciones simultáneas.
   
   En el archivo de política, el valor de version sigue siendo 1. Este número de versión hace referencia a la versión del esquema de la política de gestión de identidades y accesos, no a la versión de la política. El valor de etag es el número de versión de la política.

3. Haz cambios en la sección bindings del archivo JSON. Una vinculación vincula uno o varios principales a un solo role. Las entidades principales pueden ser cuentas de usuario, cuentas de servicio, grupos de Google y dominios. Por ejemplo, la sección bindings del archivo JSON de una rutina tendría el siguiente aspecto:

   {
     "bindings": [
       {
         "role": "roles/bigquery.dataViewer",
         "members": [
           "user:[e-mail]",
           "group:[e-mail]",
           "domain:example.com",
         ]
       },
     ],
     "etag": "BwWWja0YfJA=",
     "version": 1
   }

   Nota: No se permiten enlaces vacíos sin miembros, ya que provocan un error.

4. Para actualizar la política de acceso, usa el comando bq set-iam-policy:

   bq set-iam-policy PROJECT_ID:DATASET.ROUTINE PATH_TO_FILE

5. Para verificar los cambios en el control de acceso, vuelve a usar el comando bq get-iam-policy sin escribir la información en un archivo:

   bq get-iam-policy --format=prettyjson \\
       PROJECT_ID:DATASET.ROUTINE

API

1. Para obtener la política actual, llama al método routines.getIamPolicy.

2. Edita la política para añadir entidades principales, enlaces o ambos. Para ver el formato que exige la política, consulta el tema de referencia Política.

   Precaución: Antes de definir la política, siempre debes obtener la política actual para obtener el valor actual de etag. El archivo de política actualizado debe incluir el mismo valor para etag que la política actual que vas a sustituir. De lo contrario, la actualización no se realizará. Esta función evita que se produzcan actualizaciones simultáneas.
   
   En el archivo de política, el valor de version sigue siendo 1. Este número de versión hace referencia a la versión del esquema de la política de gestión de identidades y accesos, no a la versión de la política. El valor de etag es el número de versión de la política.

3. Llama a routines.setIamPolicy para escribir la política actualizada.

Nota: No se permiten las vinculaciones vacías sin miembros, ya que provocan un error.

Roles predefinidos que conceden acceso a rutinas

Para tener un control de acceso pormenorizado, puedes asignar un rol de gestión de identidades y accesos predefinido o personalizado a una rutina específica. La rutina también hereda los controles de acceso especificados en el nivel del conjunto de datos y en niveles superiores. Por ejemplo, si asignas el rol Propietario de datos a un principal en un conjunto de datos, ese principal también tendrá permisos de Propietario de datos en las rutinas del conjunto de datos a través de la herencia.

Los siguientes roles de gestión de identidades y accesos predefinidos tienen permisos en rutinas.

Precaución: Aunque es posible conceder permisos de administrador de BigQuery o de administrador de BigQuery Studio en una rutina, no debes asignar estos roles a nivel de rutina. El rol Editor de datos de BigQuery también concede todos los permisos de la rutina y es un rol menos permisivo. Los roles Administrador de BigQuery y Administrador de BigQuery Studio se suelen asignar en el nivel de proyecto.

Rol	Descripción
Propietario de datos de BigQuery (roles/bigquery.dataOwner)	Cuando se concede en una rutina, este rol otorga los siguientes permisos: Todos los permisos de la rutina. No debe asignar el rol Propietario de datos a nivel de rutina. El rol Editor de datos también concede todos los permisos de la rutina y es un rol menos permisivo. Nota: Las entidades a las que se les asigna el rol Propietario de datos a nivel de conjunto de datos pueden crear rutinas y mostrar las rutinas del conjunto de datos.
Editor de datos de BigQuery (roles/bigquery.dataEditor)	Cuando se concede en una rutina, este rol otorga los siguientes permisos: Todos los permisos de la rutina. Nota: Las entidades a las que se les ha concedido el rol Editor de datos a nivel de conjunto de datos pueden crear y enumerar rutinas en el conjunto de datos.
Lector de datos de BigQuery (roles/bigquery.dataViewer)	Cuando se concede en una rutina, este rol otorga los siguientes permisos: En una consulta, haz referencia a una rutina creada por otra persona. Nota: Las principales a las que se les haya concedido el rol Lector de datos a nivel de conjunto de datos también pueden enumerar las rutinas del conjunto de datos.
Visor de metadatos de BigQuery (roles/bigquery.metadataViewer)	Cuando se concede en una rutina, este rol otorga los siguientes permisos: En una consulta, haz referencia a una rutina creada por otra persona. Nota: Las entidades a las que se les asigna el rol Lector de metadatos a nivel de conjunto de datos también pueden enumerar las rutinas del conjunto de datos.

Permisos de las rutinas

La mayoría de los permisos que empiezan por bigquery.routines se aplican a nivel de rutina. bigquery.routines.create y bigquery.routines.list no. Para crear y enumerar rutinas, se deben conceder los permisos bigquery.routines.create y bigquery.routines.list a un rol en el contenedor superior, es decir, el conjunto de datos.

En la siguiente tabla se enumeran todos los permisos de las rutinas y el recurso de nivel más bajo al que se pueden conceder.

Permiso	Recurso	Descripción
bigquery.routines.create	Conjunto de datos	Crea una rutina en el conjunto de datos. Este permiso también requiere bigquery.jobs.create para ejecutar una tarea de consulta que contenga una instrucción CREATE FUNCTION.
bigquery.routines.delete	Rutina	Eliminar una rutina.
bigquery.routines.get	Rutina	Hacer referencia a una rutina creada por otra persona. Este permiso también requiere bigquery.jobs.create para ejecutar una tarea de consulta que haga referencia a la rutina. Además, necesitas permiso para acceder a cualquier recurso al que haga referencia la rutina, como tablas o vistas.
bigquery.routines.list	Conjunto de datos	Muestra las rutinas del conjunto de datos y los metadatos de las rutinas.
bigquery.routines.update	Rutina	Actualizar definiciones y metadatos de rutinas.
bigquery.routines.getIamPolicy	Rutina	Obtener controles de acceso para la rutina.
bigquery.routines.setIamPolicy	Rutina	Define los controles de acceso de la rutina.

Ver los controles de acceso de una rutina

Para ver los controles de acceso de una rutina, elige una de las siguientes opciones:

Consola

1. Ve a la página BigQuery.

   Ir a BigQuery

2. En el panel Explorador, expande tu proyecto, el conjunto de datos y Rutinas. A continuación, selecciona una rutina.

3. Haz clic en Compartir .

   Los controles de acceso de la rutina aparecen en el panel Compartir.

bq

El comando bq get-iam-policy no permite ver los controles de acceso de una rutina.

SQL

En la INFORMATION_SCHEMA.OBJECT_PRIVILEGES vista no se muestran los controles de acceso de las rutinas.

API

Para obtener la política actual, llama al método routines.getIamPolicy.

Revocar el acceso a una rutina

Para revocar el acceso a una rutina, selecciona una de las siguientes opciones:

Consola

1. Ve a la página BigQuery.

   Ir a BigQuery

2. En el panel Explorador, expande tu proyecto, un conjunto de datos y Rutinas. A continuación, selecciona una rutina.

3. En el panel de detalles, haz clic en Compartir > Permisos.

4. En el cuadro de diálogo Permisos de rutina, despliega la entidad de seguridad cuyo acceso quieras revocar.

5. Haz clic en Eliminar principal.

6. En el cuadro de diálogo ¿Quitar rol del principal?, haz clic en Quitar.

7. Haz clic en Cerrar.

Nota: Si no puedes revocar el acceso, es posible que la entidad de seguridad haya heredado el acceso de un nivel superior de la jerarquía de recursos. Para obtener instrucciones sobre cómo editar el acceso de una entidad de seguridad, consulta Conceder o revocar un solo rol

.

bq

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

2. Para escribir la información de la rutina (incluidos los controles de acceso) en un archivo JSON, usa el comando bq get-iam-policy:

   bq get-iam-policy --routine PROJECT_ID:DATASET.ROUTINE > PATH_TO_FILE

   Haz los cambios siguientes:

   • PROJECT_ID: tu ID de proyecto
   • DATASET: el nombre del conjunto de datos que contiene la rutina que quieres actualizar
   • ROUTINE: el nombre del recurso que se va a actualizar
   • PATH_TO_FILE: la ruta al archivo JSON en tu máquina local
   Precaución: Cuando definas la política, siempre debes obtener la política actual como primer paso para obtener el valor actual de etag. El archivo de política actualizado debe incluir el mismo valor de etag que la política actual que va a sustituir. De lo contrario, la actualización no se completará. Esta función evita que se produzcan actualizaciones simultáneas.

   En el archivo de políticas, el valor de version sigue siendo 1. Este número hace referencia a la versión del esquema de la política de gestión de identidades y accesos, no a la versión de la política. El valor de etag value es el número de versión de la política.

3. Haz cambios en la sección access del archivo JSON. Puedes quitar cualquiera de las entradas de specialGroup: projectOwners, projectWriters, projectReaders y allAuthenticatedUsers. También puedes quitar cualquiera de los siguientes elementos: userByEmail, groupByEmail y domain.

   Por ejemplo, la sección access de un archivo JSON de una rutina tendría el siguiente aspecto:

   {
    "bindings": [
      {
        "role": "roles/bigquery.dataViewer",
        "members": [
          "user:[e-mail]",
          "group:[e-mail]",
          "domain:google.com",
        ]
      },
    ],
    "etag": "BwWWja0YfJA=",
    "version": 1
   }

   Nota: No se permiten enlaces vacíos sin miembros, ya que provocan un error.

4. Para actualizar la política de acceso, usa el comando bq set-iam-policy:

   bq set-iam-policy --routine PROJECT_ID:DATASET.ROUTINE PATH_TO_FILE

5. Para verificar los cambios en el control de acceso, vuelve a usar el comando get-iam-policy sin escribir la información en un archivo:

   bq get-iam-policy --routine --format=prettyjson PROJECT_ID:DATASET.ROUTINE

API

1. Para obtener la política actual, llama al método routines.getIamPolicy.

2. Edita la política para añadir entidades principales o enlaces, o ambos. Para ver el formato que exige la política, consulta el tema de referencia Política.

   Precaución: Cuando definas la política, siempre debes obtener la política actual como primer paso para obtener el valor actual de etag. El archivo de política actualizado debe incluir el mismo valor para etag que la política actual que vas a sustituir. De lo contrario, la actualización no se realizará. Esta función evita que se produzcan actualizaciones simultáneas.
   
   En el archivo de política, el valor de version sigue siendo 1. Este número de versión hace referencia a la versión del esquema de la política de gestión de identidades y accesos, no a la versión de la política. El valor de etag es el número de versión de la política.

Ver los controles de acceso heredados de un recurso

Puedes consultar los roles de gestión de identidades y accesos heredados de un recurso mediante la interfaz web de BigQuery. Necesitarás los permisos adecuados para ver la herencia en la consola. Para examinar la herencia de un conjunto de datos, una tabla, una vista o una rutina, sigue estos pasos:

1. En la Google Cloud consola, ve a la página BigQuery.

   Ir a BigQuery

2. En el panel Explorador, selecciona el conjunto de datos o expándelo y selecciona una tabla, una vista o una rutina.

3. En un conjunto de datos, haz clic en Compartir. En el caso de una tabla, una vista o una rutina, haz clic en Compartir.

4. Comprueba que la opción Mostrar roles heredados en la tabla esté habilitada.

   

5. Despliega un rol de la tabla.

6. En la columna Herencia, el icono hexagonal indica si el rol se ha heredado de un recurso superior.

   

Denegar el acceso a un recurso

Vista previa

Esta función está sujetas a los "Términos de las Ofertas de Acceso Previo a la Disponibilidad General" de la sección Términos Generales de los Servicios de los Términos Específicos de los Servicios. Las funciones previas a la disponibilidad general están disponibles tal cual y pueden tener una compatibilidad y asistencia limitadas. Para obtener más información, consulta las descripciones de las fases de lanzamiento.

Nota: Para enviar comentarios o hacer preguntas relacionadas con esta versión preliminar, ponte en contacto con [e-mail].

Las políticas de denegación de gestión de identidades y accesos te permiten definir medidas de protección para el acceso a los recursos de BigQuery. Puedes definir reglas de denegación que impidan que las principales seleccionadas usen determinados permisos, independientemente de los roles que tengan asignados.

Para obtener información sobre cómo crear, actualizar y eliminar políticas de denegación, consulta el artículo Denegar el acceso a recursos.

Casos especiales

Tenga en cuenta las siguientes situaciones al crear políticas de denegación de IAM en algunos permisos de BigQuery:

• El acceso a recursos autorizados (vistas, rutinas, conjuntos de datos o procedimientos almacenados) te permite crear, eliminar o manipular una tabla, así como leer y modificar los datos de la tabla, aunque no tengas permiso directo para realizar esas operaciones. También puede obtener datos o metadatos del modelo e invocar otros procedimientos almacenados en la tabla subyacente. Esta función implica que los recursos autorizados tienen los siguientes permisos:

  • bigquery.tables.get
  • bigquery.tables.list
  • bigquery.tables.getData
  • bigquery.tables.updateData
  • bigquery.tables.create
  • bigquery.tables.delete
  • bigquery.routines.get
  • bigquery.routines.list
  • bigquery.datasets.get
  • bigquery.models.getData
  • bigquery.models.getMetadata

  Para denegar el acceso a estos recursos autorizados, añade uno de los siguientes valores al campo deniedPrincipal al crear la política de denegación:

  Valor	Caso práctico
  principalSet://goog/public:all	Bloquea todas las entidades, incluidos los recursos autorizados.
  principalSet://bigquery.googleapis.com/projects/PROJECT_NUMBER/*	Bloquea todos los recursos autorizados de BigQuery del proyecto especificado. PROJECT_NUMBER es un identificador único generado automáticamente para tu proyecto de tipo INT64.

• Para eximir a determinadas entidades de la política de denegación, especifícalas en el campo exceptionPrincipals de la política de denegación. Por ejemplo, exceptionPrincipals: "principalSet://bigquery.googleapis.com/projects/1234/*".

• BigQuery almacena en caché los resultados de las consultas del propietario de un trabajo durante 24 horas, a los que puede acceder sin necesidad del permiso bigquery.tables.getData en la tabla que contiene los datos. Por lo tanto, añadir una política de denegación de gestión de identidades y accesos al permiso bigquery.tables.getData no bloquea el acceso a los resultados almacenados en caché para el propietario del trabajo hasta que caduque la caché. Para bloquear el acceso del propietario del trabajo a los resultados almacenados en caché, crea una política de denegación independiente en el permiso bigquery.jobs.create.

• Para evitar el acceso no intencionado a los datos al usar políticas de denegación para bloquear las operaciones de lectura de datos, te recomendamos que también revises y revoques las suscripciones que haya en el conjunto de datos.

• Para crear una política de gestión de identidades y accesos de denegación para ver los controles de acceso de un conjunto de datos, deniega los siguientes permisos:

  • bigquery.datasets.get
  • bigquery.datasets.getIamPolicy

• Para crear una política de gestión de identidades y accesos de denegación para actualizar los controles de acceso al conjunto de datos, deniega los siguientes permisos:

  • bigquery.datasets.update
  • bigquery.datasets.setIamPolicy

Siguientes pasos

Consulta cómo usar el método projects.testIamPermissions para probar el acceso de los usuarios a un recurso.