Como controlar o acesso a conjuntos de dados

Neste documento, descreveremos como controlar o acesso a conjuntos de dados no BigQuery.

É possível também configurar permissões do BigQuery em um nível superior na hierarquia de recursos do Cloud IAM. Para mais informações sobre a hierarquia de recursos do Cloud IAM, consulte Como usar a hierarquia de recursos para controle de acesso na documentação do Cloud IAM.

Visão geral

No momento, não é possível conceder permissões em tabelas, visualizações, colunas ou linhas. Um conjunto de dados é o recurso de nível mais baixo que oferece suporte a controles de acesso no BigQuery.

As permissões no nível do conjunto de dados determinam os usuários, grupos e contas de serviço que têm permissão para acessar as tabelas, visualizações e dados da tabela em um conjunto de dados específico. Por exemplo, se você conceder o papel de bigquery.dataOwner do Cloud IAM a um usuário em um conjunto de dados específico, esse usuário poderá criar, atualizar e excluir tabelas e visualizações no conjunto de dados.

É possível aplicar controles de acesso durante a criação do conjunto de dados chamando o método da API datasets.insert.

Os controles de acesso não podem ser aplicados durante a criação do conjunto de dados no Cloud Console, na interface do usuário da Web clássica do BigQuery ou na ferramenta de linha de comando.

Para aplicar controles de acesso a um conjunto de dados após ele ser criado:

  • usando o Console do Cloud ou a IU da web clássica do BigQuery;
  • usando o comando bq update da CLI;
  • Chame o método de API datasets.patch.
  • usando as bibliotecas de cliente.

Permissões necessárias

No mínimo, para atribuir ou atualizar controles de acesso ao conjunto de dados, você precisa receber as permissões bigquery.datasets.update e bigquery.datasets.get. Os seguintes papéis predefinidos do Cloud IAM incluem permissões bigquery.datasets.update e bigquery.datasets.get:

  • bigquery.dataOwner
  • bigquery.admin

Além disso, se um usuário tiver permissões bigquery.datasets.create ao criar um conjunto de dados, será concedido o acesso bigquery.dataOwner. O acesso bigquery.dataOwner oferece aos usuários a capacidade de atualizar os conjuntos de dados que eles criaram.

Para mais informações sobre os papéis e permissões do Cloud IAM no BigQuery, consulte Papéis e permissões predefinidos.

Como controlar o acesso a um conjunto de dados

Para atribuir controles de acesso a um conjunto de dados, faça o seguinte:

Console

  1. Selecione um conjunto de dados em Recursos e clique em Compartilhar conjunto de dados no lado direito da janela.

    Adicionar pessoas ao conjunto de dados

  2. No painel Compartilhar conjunto de dados, na guia Permissões do conjunto de dados, clique em Adicionar membros.

  3. No painel Adicionar membros, insira a entidade que você quer adicionar na caixa de texto Novos membros. É possível adicionar qualquer uma das entidades a seguir:

    • E-mail da conta do Google: concede acesso ao conjunto de dados a uma conta individual do Google
    • Grupo do Google: concede acesso ao conjunto de dados a todos os membros de um grupo do Google
    • Domínio do Google Apps: concede acesso ao conjunto de dados a todos os usuários e grupos em um domínio do Google
    • Conta de serviço: concede acesso ao conjunto de dados a uma conta de serviço.
    • Qualquer pessoa: insira "allUsers" para conceder acesso ao público em geral
    • Todas as contas do Google: insira "allAuthenticatedUsers" para conceder acesso a qualquer usuário conectado a uma Conta do Google

  4. Em Selecionar um papel, selecione BigQuery e escolha um papel de IAM predefinido apropriado para os novos membros. Para mais informações sobre as permissões atribuídas a cada papel predefinido do BigQuery, consulte a seção Papéis da página de controle de acesso.

  5. Clique em Concluído.

IU clássica

  1. Clique na seta suspensa à direita do conjunto de dados e escolha Compartilhar conjunto de dados.

  2. Na caixa de diálogo Compartilhar conjunto de dados, para Adicionar pessoas, clique na lista suspensa à esquerda do campo e escolha a opção adequada. Ao aplicar controles de acesso a um conjunto de dados usando a IU clássica da Web, você poderá conceder acesso aos seguintes usuários e grupos:

    • Usuário por e-mail: fornece acesso ao conjunto de dados a uma conta individual do Google
    • Grupo por e-mail: fornece acesso ao conjunto de dados a todos os membros de um grupo do Google
    • Domínio: fornece acesso ao conjunto de dados a todos os usuários e grupos em um domínio do Google
    • Todos os usuários autenticados: fornece acesso ao conjunto de dados a todos os titulares de contas do Google (torna público o conjunto de dados)
    • Proprietários do projeto: fornece acesso ao conjunto de dados a todos os proprietários do projeto
    • Visualizadores do projeto: fornece acesso ao conjunto de dados a todos os visualizadores do projeto
    • Editores do projeto: fornece acesso ao conjunto de dados a todos os editores do projeto

    • Visualização autorizada: fornece acesso de visualização ao conjunto de dados

  3. Digite um valor na caixa de texto. Por exemplo, se você escolher Usuário por e-mail ou Grupo por e-mail, digite o endereço de e-mail do usuário ou grupo.

  4. À direita do campo Adicionar pessoas, clique em Pode ver e escolha o papel apropriado na lista.

    Adicionar pessoas ao conjunto de dados

  5. Clique em Adicionar e em Salvar alterações.

CLI

  1. Use o comando show para gravar as informações atuais do conjunto de dados, incluindo controles de acesso, em um arquivo JSON. Se o conjunto de dados estiver em um projeto diferente do padrão, adicione o ID do projeto ao nome do conjunto de dados no seguinte formato: project_id:dataset.

    bq show \
--format=prettyjson \
project_id:dataset > path_to_file

    Em que:

    • project_id é o ID do projeto.
    • dataset é o nome do seu conjunto de dados;
    • path_to_file é o caminho para o arquivo JSON em sua máquina local.

    Exemplos:

    Digite o comando a seguir para gravar os controles de acesso para mydataset em um arquivo JSON. mydataset está no projeto padrão.

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

    Digite o comando a seguir para gravar os controles de acesso para mydataset em um arquivo JSON. mydataset está em myotherproject.

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

  2. Faça suas alterações na seção "access" do arquivo JSON. É possível adicionar ou remover qualquer uma das entradas specialGroup: projectOwners, projectWriters, projectReaders e allAuthenticatedUsers. É possível adicionar, remover ou modificar qualquer uma destas opções: userByEmail, groupByEmail e domain.

    Por exemplo, a seção "access" do arquivo JSON de um conjunto de dados tem esta aparência:

    {
 "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"
  }
 ],
 ...
}

  3. Quando as edições estiverem concluídas, use o comando update e inclua o arquivo JSON usando a sinalização --source. Se o conjunto de dados estiver em um projeto diferente do padrão, adicione o ID do projeto ao nome do conjunto de dados no seguinte formato: project_id:dataset.

    bq update \
--source path_to_file \
project_id:dataset

    Em que:

    • path_to_file é o caminho para o arquivo JSON em sua máquina local.
    • project_id é o ID do projeto.
    • dataset é o nome do seu conjunto de dados.

    Exemplos:

    Digite o comando a seguir para atualizar os controles de acesso para mydataset. mydataset está no projeto padrão.

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

    Digite o comando a seguir para atualizar os controles de acesso para mydataset. mydataset está em myotherproject.

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

  4. Para verificar as alterações no controle de acesso, insira o comando show novamente sem gravar as informações em um arquivo.

    bq show --format=prettyjson dataset

    ou

    bq show --format=prettyjson project_id:dataset

API

Ligue para datasets.insertcom um recurso de conjunto de dados definido para aplicar controles de acesso quando o conjunto de dados for criado. Ligue para datasets.patch e use a propriedade access no recurso do conjunto de dados para atualizar seus controles de acesso.

Como datasets.update substitui todo o recurso do conjunto de dados, é melhor usar o método datasets.patch para atualizar os controles de acesso.

Go

Antes de testar esta amostra, siga as instruções de configuração do Go no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Go .

Defina a propriedade dataset.access_entries com os controles de acesso de um conjunto de dados. Em seguida, chame a função client.update_dataset() para atualizar a propriedade (links em inglês).

import (
	"context"
	"fmt"

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

// updateDatasetAccessControl demonstrates how the access control policy of a dataset
// can be amended by adding an additional entry corresponding to a specific user identity.
func updateDatasetAccessControl(projectID, datasetID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}

	ds := client.Dataset(datasetID)
	meta, err := ds.Metadata(ctx)
	if err != nil {
		return err
	}
	// Append a new access control entry to the existing access list.
	update := bigquery.DatasetMetadataToUpdate{
		Access: append(meta.Access, &bigquery.AccessEntry{
			Role:       bigquery.ReaderRole,
			EntityType: bigquery.UserEmailEntity,
			Entity:     "sample.bigquery.dev@gmail.com"},
		),
	}

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

Python

Antes de testar esta amostra, siga as instruções de configuração do Python no Guia de início rápido do BigQuery: como usar bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API BigQuery Python.

Defina a propriedade dataset.access_entries com os controles de acesso de um conjunto de dados. Em seguida, chame a função client.update_dataset() para atualizar a propriedade (links em inglês). 
from google.cloud import bigquery

# TODO(developer): Construct a BigQuery client object.
# client = bigquery.Client()

# TODO(developer): Set dataset_id to the ID of the dataset to fetch.
# dataset_id = 'your-project.your_dataset'

dataset = client.get_dataset(dataset_id)  # Make an API request.

entry = bigquery.AccessEntry(
    role="READER",
    entity_type="userByEmail",
    entity_id="sample.bigquery.dev@gmail.com",
)

entries = list(dataset.access_entries)
entries.append(entry)
dataset.access_entries = entries

dataset = client.update_dataset(dataset, ["access_entries"])  # Make an API request.

full_dataset_id = "{}.{}".format(dataset.project, dataset.dataset_id)
print(
    "Updated dataset '{}' with modified user permissions.".format(full_dataset_id)
)

A seguir