Como criar visualizações autorizadas

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

Para criar uma visualização autorizada no BigQuery:

  • 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 de API tables.insert.
  • Envie uma instrução CREATE VIEW de linguagem de definição de dados (DDL, na sigla em inglês).
  • Use bibliotecas de cliente.

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 criar uma visualização autorizada, você precisa de permissões no conjunto de dados que contém a visualização e no conjunto de dados que fornece acesso a ela.

Conjunto de dados que contém a visualização

As visualizações são tratadas como recursos de tabela no BigQuery. Portanto, para criá-las, são necessárias as mesmas permissões usadas para criar uma tabela. Para criar uma visualização, você precisa ter pelo menos as permissões bigquery.tables.create. Os papéis predefinidos do Cloud IAM a seguir incluem as permissões bigquery.tables.create:

  • bigquery.dataEditor
  • bigquery.dataOwner
  • bigquery.admin

Além disso, quando um usuário com permissões bigquery.datasets.create cria um conjunto de dados, recebe o acesso bigquery.dataOwner a ele. Com o acesso bigquery.dataOwner, o usuário consegue criar visualizações no conjunto de dados.

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

Conjunto de dados que dá acesso à visualização

Para atualizar as propriedades do conjunto de dados, você precisa ter pelo menos as permissões bigquery.datasets.update e bigquery.datasets.get. Os papéis predefinidos do Cloud IAM a seguir incluem permissões bigquery.datasets.update e bigquery.datasets.get:

  • bigquery.dataOwner
  • bigquery.admin

Além disso, quando um usuário com permissões bigquery.datasets.create cria um conjunto de dados, ele recebe o acesso de bigquery.dataOwner ao conjunto. Com o acesso bigquery.dataOwner, os usuários conseguem atualizar as propriedades dos conjuntos de dados criados por eles.

Para mais informações sobre papéis e permissões do Cloud IAM no BigQuery, consulte Controle de acesso.

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. Na seção Recursos do painel de navegação, expanda o projeto e selecione um conjunto de dados.

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

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

  4. Na seção Compartilhar visualização autorizada:

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

CLI

  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 ID do projeto ao nome do conjunto de dados no 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 de mydataset em um arquivo JSON. O mydataset está no projeto padrão.

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

    Insira 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 ID do projeto ao nome do conjunto de dados no 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 de mydataset. O mydataset está no projeto padrão.

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

    Insira 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, 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

Chame o 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 este exemplo, 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.

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

# 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:

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:

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.