Como controlar o acesso a conjuntos de dados

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

É possível aplicar controles de acesso durante a criação do conjunto de dados. Para fazer isso, chame o método de API datasets.insert.

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

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

  • use a IU clássica da Web do BigQuery;

    • No momento, não é possível atribuir controles de acesso no Console do GCP.

  • use o comando bq update da CLI;

  • chame o método de API datasets.patch.

Visão geral

Para compartilhar o acesso às tabelas e visualizações do BigQuery, use papéis do IAM para envolvidos no projeto e controles de acesso no nível do conjunto de dados. Atualmente, não é possível aplicar controles de acesso diretamente a tabelas ou visualizações.

Os controles de acesso no nível do projeto determinam os usuários, os grupos e as contas de serviço com permissão para acessar todos os conjuntos de dados, tabelas, visualizações e dados de tabela dentro de um projeto. Os controles de acesso no nível do conjunto de dados determinam os usuários, grupos e contas de serviço podem acessar as tabelas, visualizações e dados de tabela em um conjunto de dados específico.

Por exemplo, se você atribui o papel bigquery.dataOwner a um usuário no nível do projeto, esse usuário pode criar, atualizar e excluir tabelas e visualizações em todos os conjuntos de dados do projeto. Se o papel OWNER for atribuído no nível do conjunto de dados, o usuário poderá criar, atualizar e excluir tabelas e visualizações somente nesse conjunto. O papel primitivo OWNER no nível do conjunto de dados é equivalente à concessão do papel bigquery.dataOwner ao conjunto de dados.

Se você atribui usuários ou grupos a um papel mais restritivo no nível do projeto, também é necessário conceder acesso a conjuntos de dados individuais. Por exemplo, se você conceder a um usuário ou grupo o papel bigquery.user no nível do projeto, ele poderá criar conjuntos de dados e executar jobs de consulta em tabelas nesses conjuntos de dados. Para consultar tabelas em conjuntos de dados que o usuário não criou, você precisa atribuir um mínimo de acesso READER no nível de conjunto de dados ao usuário para cada conjunto de dados que o usuário precisa consultar. O papel primário de READER no nível do conjunto de dados é equivalente à concessão do papel bigquery.dataViewer ao conjunto.

Para mais informações sobre os papéis de IAM predefinidos e os controles de acesso no nível do conjunto de dados, consulte Controle de acesso.

Permissões exigidas

Para atribuir ou atualizar os controles de acesso ao conjunto de dados, é necessário ter acesso de OWNER no nível do conjunto ou um papel de IAM no projeto que inclua permissões bigquery.datasets.update. Os seguintes papéis de IAM predefinidos no nível do projeto incluem permissões bigquery.datasets.update:

Além disso, como o papel bigquery.user tem permissões bigquery.datasets.create, um usuário com bigquery.user pode atualizar qualquer conjunto de dados criado por ele. Quando um usuário com papel bigquery.user cria um conjunto de dados, recebe acesso de OWNER ao conjunto. Com o acesso de OWNER, o usuário tem controle total sobre o conjunto de dados.

Para mais informações sobre os papéis e as permissões do IAM no BigQuery, consulte Controle de acesso. Para mais informações sobre os papéis no nível do conjunto de dados, consulte Papéis primitivos para conjuntos de dados.

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 a partir de 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, digite os endereços de e-mail das pessoas ou grupos que você quer adicionar à caixa de texto Novos membros.

  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 Salvar e, depois, 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, em 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 do Google individual.
    • Grupo por e-mail: fornece a todos os membros de um grupo do Google acesso ao conjunto de dados.
    • 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 a todos os titulares de contas do Google acesso ao conjunto de dados, tornando-o público.
    • Proprietários do projeto: permite que todos os proprietários do projeto acessem o conjunto de dados.
    • Project Viewers: oferece a todos os visualizadores do projeto acesso ao conjunto de dados.
    • Project Editors: permite que todos os editores do projeto acessem o conjunto de dados.

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

Linha de comando

  1. Grave as informações existentes do conjunto de dados, incluindo controles de acesso, em um arquivo JSON usando o comando show. Se o conjunto de dados estiver em um projeto diferente do padrão, adicione o código do projeto ao nome do conjunto no seguinte formato: [PROJECT_ID]:[DATASET].

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

    Em que:

    • [PROJECT_ID] é o código do projeto;
    • [DATASET] é o nome do conjunto de dados;

    • [PATH_TO_FILE] é o caminho do arquivo JSON na sua máquina local.

      Exemplos:

      Digite o comando a seguir para gravar os controles de acesso de mydataset em um arquivo JSON. O 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 de mydataset em um arquivo JSON. O 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 entrada de specialGroup: projectOwners, projectWriters, projectReaders e allAuthenticatedUsers. Você também pode adicionar, remover ou modificar qualquer um destes itens: userByEmail, groupByEmail e domain.

    Por exemplo, a seção de acesso 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 suas 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 código do projeto ao nome do conjunto no seguinte formato: [PROJECT_ID]:[DATASET].

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

    Em que:

    • [PATH_TO_FILE] é o caminho do arquivo JSON na sua máquina local;
    • [PROJECT_ID] é o código do projeto;

    • [DATASET] é o nome do conjunto de dados.

      Exemplos:

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

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

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

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

  4. Para verificar as alterações no controle de acesso, digite 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

Chame datasets.insert com um recurso de conjunto de dados definido para aplicar controles de acesso ao criar o conjunto. Chame datasets.patch e use a propriedade access no recurso do conjunto de dados para atualizar os controles de acesso.

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

Para mais informações, consulte Conjuntos de dados.

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.

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

Python

Antes de testar esta amostra, siga as instruções de configuração do Python em 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 (em inglês).

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

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"])  # API request

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

Próximas etapas

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Esta página
Comentários sobre a documentação
BigQuery
Comentários sobre o produto
Precisa de ajuda? Acesse nossa página de suporte.