Como criar visualizações autorizadas

Neste documento, descrevemos como criar visualizações autorizadas no BigQuery.

Para criar uma visualização autorizada no BigQuery, faça o seguinte:

  • Use o Console do GCP ou a IU clássica da Web do BigQuery.
  • Use manualmente o comando bq mk da ferramenta de linha de comando.
  • Chame o método da API tables.insert.
  • Envie uma instrução de Linguagem de definição de dados (DDL, na sigla em inglês) CREATE VIEW.

Visão geral

A concessão de acesso de visualização a um conjunto de dados também é conhecida como criação de visualização autorizada no BigQuery. Uma visualização autorizada permite compartilhar resultados de consultas com determinados usuários e grupos sem que eles possam acessar as tabelas subjacentes. Você também pode usar a consulta SQL da visualização para restringir as colunas (campos) que os usuários podem consultar.

Ao fazer isso, é necessário criar um conjunto de dados separado do conjunto de dados de origem consultado pela visualização. Como só é possível atribuir controles de acesso no nível do conjunto de dados, se a visualização for criada no mesmo conjunto de dados que os dados de origem, seus usuários terão acesso aos dois.

Consulte: Como criar uma visualização autorizada no BigQuery para ver um tutorial sobre o assunto.

Permissões exigidas

Para conceder acesso de visualização a um conjunto de dados, é necessário ter o 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 saber mais informações sobre os papéis no nível do conjunto de dados, consulte Papéis primários para conjuntos de dados.

Como conceder acesso de visualização a conjuntos de dados

Para conceder acesso de visualização a um conjunto de dados, faça o seguinte:

Console

  1. No painel de navegação, na seção Recursos, expanda seu projeto e selecione um conjunto de dados.

  2. Clique em Compartilhar conjunto de dados no lado direito da janela.

  3. No painel de Permissões do conjunto de dados, selecione a guia Visualizações autorizadas.

  4. Na seção Compartilhar visualização autorizada, faça o seguinte:

    • Verifique o nome do projeto em Selecionar projeto. Se a visualização estiver em um projeto diferente, selecione-o.
    • Em Selecionar conjunto de dados, escolha o conjunto de dados que contém a visualização.
    • Em Selecionar visualização, escolha a visualização a ser autorizada.
  5. Clique em Adicionar e depois em Concluído.

IU clássica

  1. Clique na seta suspensa à direita do conjunto de dados que contém as tabelas de origem 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 selecione Visualização autorizada.

  3. Clique em Selecionar visualização.

  4. Na caixa de diálogo Selecionar visualização:

    • Projeto: verifique o nome do projeto. Se a visualização estiver em um projeto diferente, selecione-o.
    • Conjunto de dados: escolha o conjunto de dados que contém a visualização.
    • Código da tabela: digite o nome da visualização que você está autorizando.
    • Clique em OK.

      Selecionar visualização autorizada

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

Linha de comando

  1. Grave as informações atuais 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. Adicione a visualização autorizada à seção “access” do arquivo JSON.

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

  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.patch e use a propriedade access para atualizar seus controles de acesso. Para mais informações, consulte Conjuntos de dados.

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

Go

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

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

# 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

Como aplicar acesso no nível da linha com uma visualização

As visualizações podem ser usadas para restringir o acesso a colunas (campos) específicas. Se quiser restringir o acesso a linhas individuais na tabela, não será preciso criar visualizações separadas para cada usuário ou grupo. Em vez disso, use o papel SESSION_USER() para retornar o endereço de e-mail do usuário atual.

Para exibir linhas diferentes para diferentes usuários, adicione outro campo à sua tabela, contendo o usuário que está autorizado a ver a linha. Em seguida, crie uma visualização que usa o papel SESSION_USER(). No exemplo a seguir, os nomes de usuário são armazenados no campo allowed_viewer:

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

A limitação dessa abordagem é que você pode conceder acesso a apenas um usuário por vez. Você pode contornar essa limitação ao tornar allowed_viewer um campo repetido. Essa abordagem permite que você forneça uma lista de usuários a cada linha, mas, mesmo que você use um campo repetido, o armazenamento de nomes de usuários na tabela ainda exigirá que você rastreie manualmente os usuários individuais que têm acesso a cada linha.

Em vez disso, preencha o campo allowed_viewer com nomes de grupo e crie uma tabela separada que mapeie grupos para usuários. Essa tabela teria um esquema que armazena nomes de grupos e nomes de usuários. Por exemplo: {group:string, user_name:string}. Essa abordagem permite administrar as informações de grupo e usuário separadamente da tabela que contém os dados.

Se a tabela de mapeamento fosse denominada private.access_control, a consulta SQL utilizada para criar a visualização autorizada seria:

#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

Próximas etapas

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

Enviar comentários sobre…

Precisa de ajuda? Acesse nossa página de suporte.