Crea vistas autorizadas

En este documento, se describe cómo crear vistas en BigQuery.

Para crear una vista autorizada en BigQuery, debes seguir estos pasos:

  • Usar GCP Console o la IU web clásica de BigQuery
  • Usar el comando bq mk de la herramienta de línea de comandos
  • Llamar al método de API tables.insert
  • Enviar una declaración de lenguaje de definición de datos (DDL) CREATE VIEW

Descripción general

En BigQuery, la acción de otorgar acceso parar ver un conjunto de datos también se conoce como crear una vista autorizada. Una vista autorizada te permite compartir resultados de consultas con usuarios y grupos específicos sin darles acceso a las tablas subyacentes. También puedes usar la consulta de SQL de la vista para restringir las columnas (campos) que los usuarios pueden consultar.

Cuando creas la vista, se debe crear en un conjunto de datos independiente de los datos de origen que consulta la vista. Debido a que puedes asignar controles de acceso solo en el nivel del conjunto de datos, si la vista se crea en el mismo conjunto de datos que los datos de origen, tus usuarios tendrán acceso tanto a la vista como a los datos.

Para obtener un instructivo sobre cómo crear una vista autorizada, consulta: Crea una vista autorizada en BigQuery.

Permisos necesarios

Para otorgar un acceso de visualización a un conjunto de datos, debes tener acceso de OWNER a nivel de conjunto de datos o tener asignada una función de IAM a nivel de proyecto que incluya permisos bigquery.datasets.update. En las funciones de IAM a nivel de proyecto predefinidas siguientes, se incluyen los permisos bigquery.datasets.update:

Además, debido a que la función bigquery.user tiene los permisos bigquery.datasets.create, un usuario asignado a la función bigquery.user puede actualizar cualquier conjunto de datos que cree el usuario. Cuando un usuario asignado a la función bigquery.user crea un conjunto de datos, se le otorga acceso de OWNER al conjunto de datos. El acceso OWNER a un conjunto de datos otorga al usuario un control total sobre este.

Para obtener más información sobre las funciones de IAM y los permisos en BigQuery, consulta Control de acceso. A fin de obtener más información sobre las funciones a nivel de conjunto de datos, consulta Funciones básicas para conjuntos de datos.

Otorga acceso de visualización a los conjuntos de datos

Para otorgar acceso de visualización a un conjunto de datos, sigue estos pasos:

Console

  1. En el panel de navegación, en la sección Recursos, expande tu proyecto y selecciona un conjunto de datos.

  2. Haz clic en Compartir conjunto de datos, en el lado derecho de la ventana.

  3. En el panel Permisos del conjunto de datos, selecciona la pestaña Vistas autorizadas.

  4. En la sección Compartir vista autorizada, haz lo siguiente:

    • En Seleccionar proyecto, verifica el nombre. Si la vista está en un proyecto diferente, asegúrate de seleccionarlo.
    • En Seleccionar conjunto de datos, elige el conjunto de datos que contenga la vista.
    • En Seleccionar vista, elige la vista que quieres autorizar.
  5. Haz clic en Agregar y, luego, en Listo.

IU clásica

  1. Haz clic en la flecha desplegable a la derecha del conjunto de datos que contiene las tablas fuente y elige Compartir conjunto de datos.

  2. En el cuadro de diálogo Compartir conjunto de datos para Add People (Agregar personas), haz clic en el menú desplegable a la izquierda del campo y selecciona Authorized View (Vista autorizada).

  3. Haz clic en Select View (Seleccionar vista).

  4. En el cuadro de diálogo Seleccionar vista, realiza estas acciones:

    • Para Project (Proyecto), verifica el nombre del proyecto. Si la vista está en un proyecto diferente, asegúrate de seleccionarlo.
    • Para Dataset (Conjunto de datos), elige el conjunto de datos que contiene la vista.
    • Para Table ID (ID de tabla), ingresa el nombre de la vista que autorizas.
    • Haga clic en OK (Aceptar).

      Selecciona vista autorizada

  5. Haz clic en Add (Agregar) y, luego, en Save changes (Guardar cambios).

Línea de comandos

  1. Escribe la información del conjunto de datos existente (incluidos los controles de acceso) en un archivo JSON con el comando show. Si el conjunto de datos se encuentra en otro proyecto que no sea el predeterminado, agrega el ID del proyecto al nombre del conjunto de datos en el formato siguiente: [PROJECT_ID]:[DATASET].

    bq show --format=prettyjson [PROJECT_ID]:[DATASET] > [PATH_TO_FILE]
    

    Donde:

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

      Ejemplos:

      Ingresa el comando siguiente a fin de escribir los controles de acceso para mydataset en un archivo JSON. mydataset se encuentra en tu proyecto predeterminado.

      bq show --format=prettyjson mydataset > /tmp/mydataset.json

      Ingresa el comando siguiente a fin de escribir los controles de acceso para mydataset en un archivo JSON. mydataset se encuentra en myotherproject.

      bq show --format=prettyjson myotherproject:mydataset > /tmp/mydataset.json

  2. Agrega la vista autorizada a la sección "acceso" del archivo JSON.

    Por ejemplo, la sección de acceso del archivo JSON de un conjunto de datos se vería de la manera siguiente:

    {
     "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]"
      },
      {
       "view":{
       "datasetId": "[DATASET_NAME]",
       "projectId": "[PROJECT_NAME]",
       "tableId": "[VIEW_NAME]"
       }
      }
     ],
    }
    

  3. Cuando tus ediciones estén completas, usa el comando update y también incluye el archivo JSON con la marca --source. Si el conjunto de datos se encuentra en otro proyecto que no sea el predeterminado, agrega el ID del proyecto al nombre del conjunto de datos en el formato siguiente: [PROJECT_ID]:[DATASET].

    bq update --source [PATH_TO_FILE] [PROJECT_ID]:[DATASET]
    

    Donde:

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

      Ejemplos:

      Ingresa el comando siguiente a fin de actualizar los controles de acceso para mydataset. mydataset se encuentra en tu proyecto predeterminado.

      bq update --source /tmp/mydataset.json mydataset
      

      Ingresa el comando siguiente a fin de actualizar los controles de acceso para mydataset. mydataset se encuentra en myotherproject.

      bq update --source /tmp/mydataset.json myotherproject:mydataset
      
  4. Para verificar los cambios del control de acceso, ingresa otra vez el comando show sin escribir la información en un archivo.

    bq show --format=prettyjson [DATASET]
    

    o

    bq show --format=prettyjson [PROJECT_ID]:[DATASET]
    

API

Llama a datasets.patch y usa la propiedad access para actualizar tus controles de acceso. Para obtener más información, consulta Conjuntos de datos.

Debido a que el método datasets.update reemplaza todo el recurso del conjunto de datos, datasets.patch es el método preferido para actualizar los controles de acceso.

Go

Antes de probar esta muestra, sigue las instrucciones de configuración para Go de la Guía de inicio rápido de BigQuery con bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para Go.

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
srcDataset := client.Dataset(srcDatasetID)
viewDataset := client.Dataset(viewDatasetID)
view := viewDataset.Table(viewID)

// First, we'll add a group to the ACL for the dataset containing the view.  This will allow users within
// that group to query the view, but they must have direct access to any tables referenced by the view.
vMeta, err := viewDataset.Metadata(ctx)
if err != nil {
	return err
}
vUpdateMeta := bigquery.DatasetMetadataToUpdate{
	Access: append(vMeta.Access, &bigquery.AccessEntry{
		Role:       bigquery.ReaderRole,
		EntityType: bigquery.GroupEmailEntity,
		Entity:     "example-analyst-group@google.com",
	}),
}
if _, err := viewDataset.Update(ctx, vUpdateMeta, vMeta.ETag); err != nil {
	return err
}

// Now, we'll authorize a specific view against a source dataset, delegating access enforcement.
// Once this has been completed, members of the group previously added to the view dataset's ACL
// no longer require access to the source dataset to successfully query the view.
srcMeta, err := srcDataset.Metadata(ctx)
if err != nil {
	return err
}
srcUpdateMeta := bigquery.DatasetMetadataToUpdate{
	Access: append(srcMeta.Access, &bigquery.AccessEntry{
		EntityType: bigquery.ViewEntity,
		View:       view,
	}),
}
if _, err := srcDataset.Update(ctx, srcUpdateMeta, srcMeta.ETag); err != nil {
	return err
}

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para Python que se encuentran en la Guía de inicio rápido de BigQuery con bibliotecas cliente. A fin de obtener más información, consulta la documentación de referencia de la API de BigQuery para Python.

# from google.cloud import bigquery
# client = bigquery.Client()

# Assign access controls to the dataset containing the view
# shared_dataset_id = 'my_shared_dataset'
# analyst_group_email = 'data_analysts@example.com'
shared_dataset = client.get_dataset(
    client.dataset(shared_dataset_id)
)  # API request
access_entries = shared_dataset.access_entries
access_entries.append(
    bigquery.AccessEntry("READER", "groupByEmail", analyst_group_email)
)
shared_dataset.access_entries = access_entries
shared_dataset = client.update_dataset(
    shared_dataset, ["access_entries"]
)  # API request

# Authorize the view to access the source dataset
# project = 'my-project'
# source_dataset_id = 'my_source_dataset'
source_dataset = client.get_dataset(
    client.dataset(source_dataset_id)
)  # API request
view_reference = {
    "projectId": project,
    "datasetId": shared_dataset_id,
    "tableId": "my_shared_view",
}
access_entries = source_dataset.access_entries
access_entries.append(bigquery.AccessEntry(None, "view", view_reference))
source_dataset.access_entries = access_entries
source_dataset = client.update_dataset(
    source_dataset, ["access_entries"]
)  # API request

Aplica accesos a nivel de fila con una vista

Las vistas se pueden usar para restringir el acceso a columnas específicas (campos). Si deseas restringir el acceso a las filas individuales en tu tabla, no necesitas crear vistas por separado para cada usuario o grupo. En su lugar, puedes usar la función SESSION_USER() para mostrar la dirección de correo electrónico del usuario actual.

A fin de mostrar filas diferentes a diversos usuarios, agrega otro campo a la tabla que contiene el usuario que tiene permiso para ver la fila. Luego, crea una vista que use la función SESSION_USER(). En el ejemplo siguiente, los nombres de usuario se almacenan en el campo allowed_viewer:

#standardSQL
SELECT [COLUMN_1, COLUMN_2]
FROM `[DATASET.VIEW]`
WHERE allowed_viewer = SESSION_USER()

La limitación de este método es que puedes otorgar acceso a un solo usuario a la vez. Puedes evitar esta limitación si haces de allowed_viewer un campo repetido. Este método te permite proporcionar una lista de usuarios para cada fila, sin embargo, incluso si usas un campo repetido, almacenar los nombres de usuario en la tabla requerirá que realices el seguimiento manual de los usuarios individuales que tienen acceso a cada fila.

En su lugar, propaga el campo allowed_viewer con nombres de grupos y crea una tabla por separado que asigne los grupos a los usuarios. La tabla que asigna los grupos a los usuarios tendría un esquema que almacene los nombres de grupos y de usuarios. Por ejemplo: {group:string, user_name:string}. Este método te permite administrar la información del usuario y del grupo por separado desde la tabla que contiene los datos.

Si la tabla de asignación se llama private.access_control, la consulta de SQL que se usa para crear la vista autorizada sería como la que se ve a continuación:

#standardSQL
SELECT c.customer, c.id
FROM `private.customers` c
INNER JOIN (
    SELECT group
    FROM `private.access_control`
    WHERE SESSION_USER() = user_name) g
ON c.allowed_group = g.group

Pasos siguientes

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...

Si necesitas ayuda, visita nuestra página de asistencia.