Como proteger dados com chaves do Cloud KMS

Por padrão, o BigQuery criptografa o conteúdo do cliente armazenado em repouso. O BigQuery lida e gerencia essa criptografia padrão para você sem nenhuma ação adicional da sua parte. Primeiro, os dados de uma tabela do BigQuery são criptografados usando uma chave de criptografia de dados. Em seguida, essas chaves de criptografia de dados são criptografadas com chaves de criptografia de chaves, o que é conhecido como criptografia de envelope. Em vez de criptografarem diretamente seus dados, as chaves de criptografia de chaves são usadas para criptografar as chaves de criptografia de dados que o Google usa para criptografar seus dados. Para mais informações, consulte Gerenciamento de chaves.

Para você controlar a criptografia, use as chaves de criptografia gerenciadas pelo cliente (CMEK) para o BigQuery. Em vez de o Google gerenciar as chaves de criptografia de chaves que protegem seus dados, você controla e gerencia as chaves de criptografia de chaves no Cloud KMS. Este tópico fornece detalhes sobre essa técnica.

Saiba mais sobre opções de criptografia no Google Cloud.

Antes de começar

  1. Entenda conjuntos de dados, tabelas e consultas.

  2. Decida se você executará o BigQuery e o Cloud KMS no mesmo projeto do Google Cloud ou em projetos diferentes. Para fins de exemplo de documentação, usamos a convenção a seguir:

    • project_id é o código do projeto que executa o BigQuery
    • project_number é o número do projeto que executa o BigQuery
    • kms_project_id é o código do projeto que executa o Cloud KMS, mesmo que seja o mesmo projeto que executa o BigQuery
    Para informações sobre os códigos de projeto e os números de projeto do Google Cloud, consulte Como identificar projetos.

  3. O BigQuery é ativado automaticamente em novos projetos. Se você estiver usando um projeto pré-existente para executar o BigQuery, ative a API BigQuery.

  4. Para o projeto do Google Cloud que executa o Cloud KMS:

    1. Ative a API Cloud KMS.
    2. Crie um keyring e uma chave, conforme descrito em Como criar keyrings e chaves. Crie o keyring em um local que corresponda ao local do conjunto de dados do BigQuery:
      • Qualquer conjunto de dados multirregional deve usar um keyring multirregional do local correspondente. Para exemplos, um conjunto de dados na região US deve ser protegido com um keyring da região us e um conjunto de dados na região EU deve ser protegido com um keyring da região europe.
      • Conjuntos de dados regionais devem usar as chaves regionais correspondentes. Por exemplo, um conjunto de dados na região asia-northeast1 deve ser protegido com um keyring da região asia-northeast1.
      • A região global não é compatível com o BigQuery.
      Para mais informações sobre os locais compatíveis com o BigQuery e o Cloud KMS, consulte Locais do Cloud.

Especificação de criptografia

As chaves do Cloud KMS usadas para proteger seus dados no BigQuery são chaves AES-256. Elas são usadas como chaves de criptografia de chaves no BigQuery porque criptografam as chaves de criptografia de dados que criptografam seus dados.

Conceder permissões de criptografia e descriptografia

Use o Console do Google Cloud para determinar o código da conta de serviço do BigQuery e forneça à conta de serviço a função apropriada para criptografar e descriptografar usando o Cloud KMS.

Determinar o código da conta de serviço

IU clássica

  1. Acesse a IU da Web do BigQuery.

    Acesse a IU da Web do BigQuery

  2. Clique no ícone de seta para baixo ícone de seta para baixo ao lado do nome do projeto na navegação e, em seguida, clique em Criptografia gerenciada pelo cliente.

  3. Uma caixa de diálogo do usuário é aberta para mostrar a conta de serviço que exige permissão de criptografia e descriptografia:

    Código da conta de serviço

  4. Clique em Copiar para copiar o código da conta de serviço para a área de transferência e clique em OK para fechar a caixa de diálogo do usuário.

CLI

É possível usar o comando bq show com a sinalização --encryption_service_account para determinar o código da conta de serviço:

bq show --encryption_service_account

O comando exibe o código da conta de serviço:

                       ServiceAccountID
     -------------------------------------------------------------
      bq-project_number@bigquery-encryption.iam.gserviceaccount.com

Atribuir o papel criptografador/descriptografador

Atribua a função Cloud KMS CryptoKey Encrypter/Decrypter à conta de serviço do sistema do BigQuery que você copiou para sua área de transferência. Essa conta está no formato

bq-project_number@bigquery-encryption.iam.gserviceaccount.com

Console

  1. Abra a página Segurança no Console do Cloud.

    Abrir a página Chaves criptográficas de segurança

  2. Selecione o projeto e clique em Continuar.

  3. Identifique a chave de criptografia para atribuir a função.

    • Se a conta de serviço de bq-project_number@bigquery-encryption.iam.gserviceaccount.com ainda não estiver na lista de membros, ela não terá nenhuma função atribuída a ela. Clique em Adicionar membro e insira o endereço de e-mail da conta de serviço, bq-project_number@bigquery-encryption.iam.gserviceaccount.com.
    • Se já estiver na lista de membros, a conta de serviço tem funções. Clique na lista suspensa de funções atual para a conta de serviço bq-project_number@bigquery-encryption.iam.gserviceaccount.com.
  4. Clique na lista suspensa Função e em Cloud KMS. Por último, clique na função Criptografador/Descriptografador de CryptoKey do Cloud KMS.

  5. Clique em Adicionar ou Salvar para aplicar a função à conta de serviço bq-project_number@bigquery-encryption.iam.gserviceaccount.com.

CLI

Use a ferramenta de linha de comando gcloud para atribuir a função:

gcloud kms keys add-iam-policy-binding \
--project=kms_project_id \
--member serviceAccount:bq-project_number@bigquery-encryption.iam.gserviceaccount.com \
--role roles/cloudkms.cryptoKeyEncrypterDecrypter \
--location=kms_key_location \
--keyring=kms_key_ring \
kms_key

Substitua kms_project_id pelo código do projeto do Google Cloud que está executando o Cloud KMS, substitua project_number pelo número do projeto (não o código do projeto) do projeto do Google Cloud que está executando o BigQuery e substitua kms_key_location, kms_key_ring, kms_key pelo local, keyring e nomes de chaves de sua chave do Cloud KMS.

Código de recurso da chave

O código do recurso da chave do Cloud KMS é necessário para uso de CMEK, como mostrado nos exemplos deste tópico. Essa chave está no formato:

projects/project_id/locations/location/keyRings/key_ring/cryptoKeys/key

Para informações sobre como recuperar o código de recurso da chave, consulte Código de recurso da chave.

Criar uma tabela protegida pelo Cloud KMS

Criar uma tabela vazia protegida pelo Cloud KMS

Para criar uma tabela protegida pelo Cloud KMS:

IU clássica

  1. Clique no ícone de seta para baixo ícone de seta para baixo ao lado do nome do conjunto de dados na interface do usuário da Web do BigQuery e clique em Criar nova tabela.

  2. Na página Criar tabela, preencha as informações necessárias para criar uma tabela vazia com uma definição de esquema. Antes de clicar em Criar tabela, configure o tipo de criptografia e especifique a chave do Cloud KMS a ser usada com a tabela:

    1. Clique na lista suspensa Tipo de criptografia e selecione Criptografia gerenciada pelo cliente.
    2. Para a Chave de criptografia gerenciada pelo cliente, insira o Código do recurso para a chave.
  3. Clique em Criar tabela.

CLI

É possível usar a ferramenta de linha de comando bq com a sinalização --destination_kms_key para criar a tabela. A sinalização --destination_kms_key especifica o código de recurso da chave a ser usada com a tabela.

Para criar uma tabela vazia com um esquema:

bq mk --schema name:string,value:integer -t \
--destination_kms_key projects/project_id/locations/location/keyRings/key_ring/cryptoKeys/key \
mydataset.newtable

Como alternativa, é possível usar uma instrução DDL:

bq query --use_legacy_sql=false "
  CREATE TABLE mydataset.newtable (name STRING, value INT64)
  OPTIONS(
    kms_key_name='projects/project_id/locations/location/keyRings/key_ring/cryptoKeys/key'
  )
"

Para criar uma tabela com base em uma consulta:

bq query --destination_table=mydataset.newtable \
--destination_kms_key projects/project_id/locations/location/keyRings/key_ring/cryptoKeys/key \
"SELECT name,count FROM mydataset.babynames WHERE gender = 'M' ORDER BY count DESC LIMIT 6"

Para mais informações sobre a ferramenta de linha de comando bq, consulte Ferramenta de linha de comando bq.

Go

import (
	"context"
	"fmt"

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

// createTableWithCMEK demonstrates creating a table protected with a customer managed encryption key.
func createTableWithCMEK(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydatasetid"
	// tableID := "mytableid"
	ctx := context.Background()

	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	tableRef := client.Dataset(datasetID).Table(tableID)
	meta := &bigquery.TableMetadata{
		EncryptionConfig: &bigquery.EncryptionConfig{
			// TODO: Replace this key with a key you have created in Cloud KMS.
			KMSKeyName: "projects/cloud-samples-tests/locations/us/keyRings/test/cryptoKeys/test",
		},
	}
	if err := tableRef.Create(ctx, meta); err != nil {
		return err
	}
	return nil
}

Python

Proteja uma nova tabela com uma chave de criptografia gerenciada pelo cliente definindo a propriedade Table.encryption_configuration como um objeto EncryptionConfiguration antes de criar a tabela.

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

table_ref = client.dataset(dataset_id).table("my_table")
table = bigquery.Table(table_ref)

# Set the encryption key to use for the table.
# TODO: Replace this key with a key you have created in Cloud KMS.
kms_key_name = "projects/{}/locations/{}/keyRings/{}/cryptoKeys/{}".format(
    "cloud-samples-tests", "us", "test", "test"
)
table.encryption_configuration = bigquery.EncryptionConfiguration(
    kms_key_name=kms_key_name
)

table = client.create_table(table)  # API request

assert table.encryption_configuration.kms_key_name == kms_key_name

Consultar uma tabela protegida por uma chave do Cloud KMS

Nenhuma disposição especial é obrigatória para consultar uma tabela protegida pelo Cloud KMS. O nome da chave usada para criptografar o conteúdo da tabela é armazenado no BigQuery e essa chave será usada quando houver uma consulta a uma tabela protegida pelo Cloud KMS.

Todas as ferramentas, o console do BigQuery e a interface de linha de comando bq são executados da mesma maneira que as tabelas criptografadas por padrão, desde que o BigQuery tenha acesso à chave do Cloud KMS usada para criptografar o conteúdo da tabela.

Proteger os resultados da consulta com a chave do Cloud KMS

IU clássica

  1. Clique no botão Escrever consulta na IU da Web do BigQuery.

  2. Insira uma consulta SQL do BigQuery válida na área de texto Nova consulta.

  3. Clique em Tipo de criptografia e selecione Criptografia gerenciada pelo cliente.

  4. Para a Chave de criptografia gerenciada pelo cliente, insira o Código do recurso para a chave.

  5. Clique em Executar consulta.

CLI

Especifique a sinalização --destination_kms_key para proteger a tabela de destino ou os resultados da consulta (se estiver usando uma tabela temporária) com a chave do Cloud KMS. A sinalização --destination_kms_key especifica o código de recurso da chave a ser usada com a tabela de destino ou resultante.

Se preferir, use a sinalização --destination_table para especificar o destino dos resultados da consulta. Se --destination_table não for usado, os resultados da consulta serão gravados em uma tabela temporária.

Para consultar uma tabela:

bq query \
--destination_table=mydataset.newtable \
--destination_kms_key projects/project_id/locations/location/keyRings/key_ring/cryptoKeys/key \
"SELECT name,count FROM mydataset.babynames WHERE gender = 'M' ORDER BY count DESC LIMIT 6"

Para mais informações sobre a ferramenta de linha de comando bq, consulte Ferramenta de linha de comando bq.

Go

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/bigquery"
	"google.golang.org/api/iterator"
)

// queryWithDestinationCMEK demonstrates saving query results to a destination table and protecting those results
// by specifying a customer managed encryption key.
func queryWithDestinationCMEK(w io.Writer, projectID, dstDatasetID, dstTableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	q := client.Query("SELECT 17 as my_col")
	q.Location = "US" // Location must match the dataset(s) referenced in query.
	q.QueryConfig.Dst = client.Dataset(dstDatasetID).Table(dstTableID)
	q.DestinationEncryptionConfig = &bigquery.EncryptionConfig{
		// TODO: Replace this key with a key you have created in Cloud KMS.
		KMSKeyName: "projects/cloud-samples-tests/locations/us-central1/keyRings/test/cryptoKeys/test",
	}
	// Run the query and print results when the query job is completed.
	job, err := q.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}
	it, err := job.Read(ctx)
	for {
		var row []bigquery.Value
		err := it.Next(&row)
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintln(w, row)
	}
	return nil
}

Python

from google.cloud import bigquery

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

# TODO(developer): Set table_id to the ID of the destination table.
# table_id = "your-project.your_dataset.your_table_name"

# Set the encryption key to use for the destination.
# TODO(developer): Replace this key with a key you have created in KMS.
# kms_key_name = "projects/{}/locations/{}/keyRings/{}/cryptoKeys/{}".format(
#     your-project, location, your-ring, your-key
# )

job_config = bigquery.QueryJobConfig(
    destination=table_id,
    destination_encryption_configuration=bigquery.EncryptionConfiguration(
        kms_key_name=kms_key_name
    ),
)

# Start the query, passing in the extra configuration.
query_job = client.query(
    "SELECT 17 AS my_col;", job_config=job_config
)  # Make an API request.
query_job.result()  # Wait for the job to complete.

table = client.get_table(table_id)  # Make an API request.
if table.encryption_configuration.kms_key_name == kms_key_name:
    print("The destination table is written using the encryption configuration")

Carregar uma tabela protegida pelo Cloud KMS

Para carregar um arquivo de dados em uma tabela protegida pelo Cloud KMS:

Console

Para proteger uma tabela de destino do job de carregamento com uma chave de criptografia gerenciada pelo cliente, especifique a chave ao carregar a tabela.

  1. Abra a IU da Web do BigQuery no Console do Cloud.
    Acesse a IU da Web do BigQuery
  2. Na seção Recursos do painel de navegação, abra o projeto e selecione um conjunto de dados.
  3. No lado direito da janela, no painel de detalhes, clique em Criar tabela.
  4. Insira as opções a serem usadas no carregamento da tabela antes de clicar em Criar tabela e Opções avançadas.
  5. Em Criptografia, selecione Chave gerenciada pelo cliente.
  6. Clique na lista suspensa Selecione uma chave gerenciada pelo cliente e selecione a chave a ser usada. Caso não veja nenhuma chave disponível, insira um código de recurso de chave.

    Opções avançadas

  7. Clique em Criar tabela.

CLI

Para proteger uma tabela de destino do job de carregamento com uma chave de criptografia gerenciada pelo cliente, defina a sinalização --destination_kms_key.

bq --location=location load \
--autodetect \
--source_format=format \
--destination_kms_key projects/project_id/locations/location/keyRings/key_ring/cryptoKeys/key \
dataset.table \
path_to_source
Por exemplo:
bq load \
--autodetect \
--source_format=NEWLINE_DELIMITED_JSON \
--destination_kms_key projects/project_id/locations/location/keyRings/key_ring/cryptoKeys/key \
test2.table4 \
gs://cloud-samples-data/bigquery/us-states/us-states.json

Go

import (
	"context"
	"fmt"

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

// importJSONWithCMEK demonstrates loading newline-delimited JSON from Cloud Storage,
// and protecting the data with a customer-managed encryption key.
func importJSONWithCMEK(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	gcsRef := bigquery.NewGCSReference("gs://cloud-samples-data/bigquery/us-states/us-states.json")
	gcsRef.SourceFormat = bigquery.JSON
	gcsRef.AutoDetect = true
	loader := client.Dataset(datasetID).Table(tableID).LoaderFrom(gcsRef)
	loader.WriteDisposition = bigquery.WriteEmpty
	loader.DestinationEncryptionConfig = &bigquery.EncryptionConfig{
		// TODO: Replace this key with a key you have created in KMS.
		KMSKeyName: "projects/cloud-samples-tests/locations/us-central1/keyRings/test/cryptoKeys/test",
	}

	job, err := loader.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}

	if status.Err() != nil {
		return fmt.Errorf("job completed with error: %v", status.Err())
	}

	return nil
}

Python

Para proteger uma tabela de destino da tarefa de carregamento com uma chave de criptografia gerenciada pelo cliente, defina a propriedade LoadJobConfig.destination_encryption_configuration como EncryptionConfiguration e carregue a tabela.

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

dataset_ref = client.dataset(dataset_id)
job_config = bigquery.LoadJobConfig()
job_config.autodetect = True
job_config.source_format = bigquery.SourceFormat.NEWLINE_DELIMITED_JSON

# Set the encryption key to use for the destination.
# TODO: Replace this key with a key you have created in KMS.
kms_key_name = "projects/{}/locations/{}/keyRings/{}/cryptoKeys/{}".format(
    "cloud-samples-tests", "us", "test", "test"
)
encryption_config = bigquery.EncryptionConfiguration(kms_key_name=kms_key_name)
job_config.destination_encryption_configuration = encryption_config
uri = "gs://cloud-samples-data/bigquery/us-states/us-states.json"

load_job = client.load_table_from_uri(
    uri,
    dataset_ref.table("us_states"),
    location="US",  # Location must match that of the destination dataset.
    job_config=job_config,
)  # API request

assert load_job.job_type == "load"

load_job.result()  # Waits for table load to complete.

assert load_job.state == "DONE"
table = client.get_table(dataset_ref.table("us_states"))
assert table.encryption_configuration.kms_key_name == kms_key_name

Fazer streaming em uma tabela protegida pelo Cloud KMS

Faça o streaming de dados na sua tabela do BigQuery protegida pelo CMEK sem especificar um parâmetro adicional. Observe que esses dados são criptografados usando sua chave do Cloud KMS no buffer e no local final. Antes de usar streaming com uma tabela CMEK, revise os requisitos em disponibilidade e acessibilidade da chave.

Saiba mais sobre streaming em Como fazer streaming de dados no BigQuery.

Alterar uma tabela da criptografia padrão para proteção do Cloud KMS

CLI

É possível usar o comando bq cp com a sinalização --destination_kms_key para copiar uma tabela protegida por criptografia padrão para uma nova tabela ou para a tabela original, protegida pelo Cloud KMS. A sinalização --destination_kms_key especifica o código de recurso da chave a ser usada com a tabela de destino.

Para copiar uma tabela com criptografia padrão para uma nova tabela com proteção do Cloud KMS:

bq cp \
--destination_kms_key projects/project_id/locations/location/keyRings/key_ring/cryptoKeys/key \
sourceDataset.sourceTableId destinationDataset.destinationTableId

Caso você queira copiar uma tabela com criptografia padrão para a mesma tabela com proteção do Cloud KMS:

bq cp -f \
--destination_kms_key projects/project_id/locations/location/keyRings/key_ring/cryptoKeys/key \
sourceDataset.sourceTableId sourceDataset.sourceTableId

Se quiser alterar uma tabela da proteção do Cloud KMS para a criptografia padrão, copie o arquivo para si mesmo executando bq cp sem usar a sinalização --destination_kms_key.

Para mais informações sobre a ferramenta de linha de comando bq, consulte Ferramenta de linha de comando bq.

Go

import (
	"context"
	"fmt"

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

// copyTableWithCMEK demonstrates creating a copy of a table and ensuring the copied data is
// protected with a customer managed encryption key.
func copyTableWithCMEK(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// tableID := "mytable"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	srcTable := client.DatasetInProject("bigquery-public-data", "samples").Table("shakespeare")
	copier := client.Dataset(datasetID).Table(tableID).CopierFrom(srcTable)
	copier.DestinationEncryptionConfig = &bigquery.EncryptionConfig{
		// TODO: Replace this key with a key you have created in Cloud KMS.
		KMSKeyName: "projects/cloud-samples-tests/locations/us-central1/keyRings/test/cryptoKeys/test",
	}
	job, err := copier.Run(ctx)
	if err != nil {
		return err
	}
	status, err := job.Wait(ctx)
	if err != nil {
		return err
	}
	if err := status.Err(); err != nil {
		return err
	}
	return nil
}

Python

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

Para proteger o destino de uma cópia de tabela com uma chave de criptografia gerenciada pelo cliente, defina a propriedade QueryJobConfig.destination_encryption_configuration como EncryptionConfiguration e copie a tabela.

from google.cloud import bigquery

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

# TODO(developer): Set dest_table_id to the ID of the destination table.
# dest_table_id = "your-project.your_dataset.your_table_name"

# TODO(developer): Set orig_table_id to the ID of the original table.
# orig_table_id = "your-project.your_dataset.your_table_name"

# Set the encryption key to use for the destination.
# TODO(developer): Replace this key with a key you have created in KMS.
# kms_key_name = "projects/{}/locations/{}/keyRings/{}/cryptoKeys/{}".format(
#     your-project, location, your-ring, your-key
# )

job_config = bigquery.CopyJobConfig(
    destination_encryption_configuration=bigquery.EncryptionConfiguration(
        kms_key_name=kms_key_name
    )
)
job = client.copy_table(orig_table_id, dest_table_id, job_config=job_config)
job.result()  # Wait for the job to complete.

dest_table = client.get_table(dest_table_id)  # Make an API request.
if dest_table.encryption_configuration.kms_key_name == kms_key_name:
    print("A copy of the table created")

Determinar se uma tabela é protegida pelo Cloud KMS

  1. Na IU da Web do BigQuery, clique na seta azul à esquerda do conjunto de dados para expandi-lo ou clique duas vezes no nome dele. Isso exibe as tabelas e visualizações no conjunto de dados.

  2. Clique no nome da tabela.

  3. Clique em Detalhes. A página Detalhes da tabela exibe a descrição e as informações da tabela.

  4. Caso a tabela esteja protegida pelo Cloud KMS, o campo Chave de criptografia gerenciada pelo cliente exibirá o código do recurso da chave.

    Tabela protegida

Alterar a chave do Cloud KMS para uma tabela do BigQuery

Para alterar a chave do Cloud KMS de uma tabela protegida pelo CMEK, é possível realizar uma consulta ALTER TABLE, usar a API ou usar a ferramenta de linha de comando bq. Há duas maneiras de modificar a chave do Cloud KMS usando a API e a ferramenta de linha de comando: update ou cp. Se você usar update, poderá alterar a chave do KMS usada para uma tabela protegida pelo Cloud KMS. Se você usar cp, terá como alterar a chave do Cloud KMS usada em uma tabela protegida pelo CMEK, alterar uma tabela da criptografia padrão para a proteção de CMEK e alterar uma tabela da proteção de CMEK para a criptografia padrão. Uma vantagem de update é que ele é mais rápido que cp e permite o uso de decoradores de tabela.

IU clássica

  1. Acesse a IU da Web do BigQuery.

    Acessar a IU da Web do BigQuery

  2. Clique em Redigir consulta.

  3. Digite a instrução DDL na área de texto Nova consulta. Para o valor kms_key_name, especifique o código de recurso da chave que você quer usar para proteger a tabela.

    #standardSQL
    ALTER TABLE mydataset.mytable
    SET OPTIONS (
    kms_key_name="projects/[PROJECT_ID]/locations/[LOCATION]/keyRings/[KEYRING]/cryptoKeys/[KEY]"
    )
    

CLI

É possível usar o comando bq cp com a sinalização --destination_kms_key para alterar a chave de uma tabela protegida pelo Cloud KMS. A sinalização --destination_kms_key especifica o código de recurso da chave a ser usada com a tabela.

bq update \
--destination_kms_key projects/project_id/locations/location/keyRings/key_ring/cryptoKeys/key \
-t dataset_id.table_id

Go

import (
	"context"
	"fmt"

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

// updateTableChangeCMEK demonstrates how to change the customer managed encryption key that protects a table.
func updateTableChangeCMEK(projectID, datasetID, tableID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydatasetid"
	// tableID := "mytableid"
	ctx := context.Background()

	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	tableRef := client.Dataset(datasetID).Table(tableID)
	meta, err := tableRef.Metadata(ctx)
	if err != nil {
		return err
	}
	update := bigquery.TableMetadataToUpdate{
		EncryptionConfig: &bigquery.EncryptionConfig{
			// TODO: Replace this key with a key you have created in Cloud KMS.
			KMSKeyName: "projects/cloud-samples-tests/locations/us-central1/keyRings/test/cryptoKeys/otherkey",
		},
	}
	if _, err := tableRef.Update(ctx, update, meta.ETag); err != nil {
		return err
	}
	return nil
}

Python

Altere a chave de criptografia gerenciada pelo cliente de uma tabela alterando a propriedade Table.encryption_configuration para um novo objeto EncryptionConfiguration e atualize a tabela.

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

assert table.encryption_configuration.kms_key_name == original_kms_key_name

# Set a new encryption key to use for the destination.
# TODO: Replace this key with a key you have created in KMS.
updated_kms_key_name = (
    "projects/cloud-samples-tests/locations/us/keyRings/test/cryptoKeys/otherkey"
)
table.encryption_configuration = bigquery.EncryptionConfiguration(
    kms_key_name=updated_kms_key_name
)

table = client.update_table(table, ["encryption_configuration"])  # API request

assert table.encryption_configuration.kms_key_name == updated_kms_key_name
assert original_kms_key_name != updated_kms_key_name

Definir a chave padrão de um conjunto de dados

É possível definir uma chave padrão do Cloud KMS para o conjunto de dados inteiro. Ela será aplicada a todas as tabelas recém-criadas nesse conjunto, exceto se outra chave do Cloud KMS for especificada na criação da tabela. A chave padrão não se aplica a tabelas preexistentes. A alteração da chave padrão não modifica nenhuma tabela e se aplica somente às novas tabelas criadas após a alteração.

Para aplicar, alterar ou remover uma chave padrão do conjunto de dados

Remover o acesso do BigQuery à chave do Cloud KMS

Remova o acesso do BigQuery à chave do Cloud KMS a qualquer momento, revogando a permissão do IAM para essa chave.

Se o BigQuery perder o acesso à chave do Cloud KMS, a experiência do usuário provavelmente será afetada e poderá ocorrer perda de dados:

  • Os dados nessas tabelas protegidas pelo CMEK não podem mais ser acessados: query, cp, extract e tabledata.list falharão.

  • Nenhum dado novo pode ser adicionado a essas tabelas protegidas pelo CMEK.

  • Mesmo que o acesso volte a ser concedido, o desempenho das consultas a essas tabelas será degradado por vários dias.

Impacto do rodízio de chaves do Cloud KMS

O BigQuery não alterna automaticamente a chave criptográfica de uma tabela quando a chave do Cloud KMS associada à tabela é alternada. As tabelas atuais continuam usando a versão da chave com que foram criadas. As novas tabelas usarão a versão atual da chave.

Limitações

Acesso do BigQuery à chave do Cloud KMS

Uma chave do Cloud KMS é considerada disponível e acessível pelo BigQuery quando:

  • a chave está ativada
  • a conta de serviço do BigQuery tem permissões de criptografia e descriptografia na chave.

As próximas seções descrevem o impacto nas inserções de streaming e nos dados inacessíveis a longo prazo quando uma chave está inacessível.

Impacto em inserções de streaming

A chave do Cloud KMS precisa estar disponível e acessível por pelo menos 24 horas consecutivas no período de 48 horas após uma solicitação de inserção de streaming. Se a chave não estiver disponível e acessível, é possível que os dados transmitidos não sejam totalmente persistidos e possam ser perdidos. Para mais informações sobre inserções de streaming, consulte Como fazer streaming de dados para o BigQuery.

Impacto nos dados inacessíveis em longo prazo

Como o BigQuery fornece armazenamento gerenciado, os dados inacessíveis a longo prazo não são compatíveis com a arquitetura dele. Caso a chave do Cloud KMS de uma determinada tabela do BigQuery não esteja disponível e acessível por 60 dias seguidos, o BigQuery optará por excluir a tabela e os dados associados. Um e-mail será enviado pelo BigQuery para o endereço de e-mail associado à conta de faturamento pelo menos 7 dias antes da exclusão dos dados.

Como usar decoradores de tabela

Quando os dados em uma tabela protegida pelo Cloud KMS são substituídos por disposição de gravação WRITE_TRUNCATE para operações load, cp ou query, a tabela fica inacessível para consulta por meio de decoradores de tabelas dependendo do tempo do decorador do snapshot.

Supondo que uma tabela foi substituída no momento de T e o decorador de snapshot snapshot_time é para um tempo menor que T, a tabela a seguir mostra se é possível consultar snapshot_time:

Tipo de criptografia anterior a T Tipo de criptografia após T snapshot_time
Cloud KMS criptografado Cloud KMS criptografado A consulta não é possível
Padrão criptografado Cloud KMS criptografado Consulta possível
Cloud KMS criptografado Padrão criptografado A consulta não é possível

Observe que uma lógica semelhante se aplica a <time2> quando um decorador de intervalos é usado.

Perguntas frequentes

Quem precisa de permissão para a chave do Cloud KMS?

Com as chaves de criptografia gerenciadas pelo cliente, não é necessário especificar permissões repetidamente. Enquanto a conta de serviço do BigQuery tiver permissão para usar a chave do Cloud KMS para criptografia e descriptografia, qualquer pessoa com permissão para a tabela do BigQuery terá acesso aos dados, mesmo sem acesso direto a essa chave.

Qual conta de serviço é usada?

A conta de serviço do BigQuery associada ao projeto do Google Cloud da tabela é usada para descriptografar os dados dessa tabela. As contas de serviço do BigQuery são exclusivas para cada projeto. Para um job que grava dados em uma tabela anônima protegida pelo Cloud KMS, é usada a conta de serviço do projeto desse job.

Como exemplo, considere três tabelas protegidas pelo CMEK: table1, table2 e table3. Para consultar dados de {project1.table1, project2.table2} com tabela de destino {project3.table3}:

  • Use a conta de serviço project1 para project1.table1
  • Use a conta de serviço project2 para project2.table2
  • Use a conta de serviço project3 para project3.table3

Como o BigQuery usa minha chave do Cloud KMS?

O BigQuery usará a chave do Cloud KMS para descriptografar dados em resposta a uma consulta do usuário, por exemplo, tabledata.list ou jobs.insert.

O BigQuery também pode usar a chave para tarefas de manutenção de dados e otimização de armazenamento, como a conversão de dados em formato otimizado para leitura.

Quais bibliotecas de criptografia são usadas?

O BigQuery usa a funcionalidade de CMEK do Cloud KMS. O Cloud KMS usa a Tink (em inglês) para criptografia.

Como receber mais ajuda?

Se você tiver perguntas que não foram respondidas aqui, consulte o suporte do BigQuery ou o suporte do Cloud KMS.

Como solucionar erros

Veja a seguir os erros comuns e as mitigações recomendadas.

Erro Recomendação
Atribua o papel criptografador/descriptografador da CryptoKey do Cloud KMS A conta de serviço do BigQuery associada ao projeto não tem permissão suficiente do Cloud IAM para operar na chave do Cloud KMS especificada. Siga as instruções do erro ou nesta documentação para conceder a permissão adequada do Cloud IAM.
As configurações de criptografia de tabela atuais não correspondem às configurações de criptografia especificadas na solicitação Isso ocorre quando as configurações de criptografia da tabela de destino não correspondem às da sua solicitação. Como mitigação, use a disposição de gravação TRUNCATE para substituir a tabela ou especifique uma tabela de destino diferente.
Esta região não é compatível A região da chave do Cloud KMS não corresponde à do conjunto de dados do BigQuery da tabela de destino. Como mitigação, selecione a chave em uma região que corresponda ao seu conjunto de dados ou carregue em um conjunto de dados que corresponda à região da chave.