Como proteger dados com chaves do Cloud KMS

Por padrão, o BigQuery criptografa o conteúdo do cliente armazenado em repouso. O BigQuery processa e gerencia essa criptografia padrão, sem mais ações da sua parte. Primeiro, os dados de uma tabela do BigQuery são criptografados por meio de uma chave de criptografia de dados. Em seguida, essas chaves 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, na sigla em inglês) do BigQuery. Em vez de o Google gerenciar as chaves de criptografia de chaves que protegem seus dados, é você quem as controla e gerencia no Cloud KMS. Neste tópico, você conhecerá os detalhes sobre esta técnica.

Saiba mais sobre as opções de criptografia do Google Cloud Platform.

Antes de começar

  1. Entenda conjuntos de dados, tabelas e consultas.

  2. Decida entre executar o BigQuery e o Cloud KMS no mesmo projeto do GCP 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 códigos e números de projetos do GCP, 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 BigQuery API.

  4. Para o projeto GCP que executa o Cloud KMS:

    1. Ative a API Cloud KMS (em inglês).
    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. Por exemplo, um conjunto de dados na região US precisa ser protegido com um keyring da região us, e um conjunto de dados na região EU precisa 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, veja 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 Platform para determinar o código da conta de serviço do BigQuery e forneça à conta de serviço o papel apropriado para criptografia e descriptografia usando o Cloud KMS.

Determinar o ID da conta de serviço

IU clássica

  1. Acesse a IU da Web do BigQuery.

    Acessar a IU da Web do BigQuery (em inglês)

  2. Clique no ícone da seta para baixo ícone de seta para baixo ao lado do nome do projeto na navegação e clique em Customer-Managed Encryption.

  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 Copy para copiar o código da conta de serviço para a área de transferência e, em seguida, em OK para fechar a caixa de diálogo do usuário.

CLI

Use 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 o papel Cloud KMS CryptoKey Encrypter/Decrypter à conta de serviço do sistema do BigQuery que você copiou para a á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 GCP.

    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 o papel.

    • Se a conta de serviço bq-project_number@bigquery-encryption.iam.gserviceaccount.com ainda não estiver na lista de membros, não há nenhum papel atribuído 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 papéis. Clique na lista suspensa do papel atual referente à conta de serviço bq-project_number@bigquery-encryption.iam.gserviceaccount.com.
  4. Clique na lista suspensa Papel e em Cloud KMS. Por último, clique no papel Criptografador/Descriptografador de CryptoKey do Cloud KMS.

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

CLI

Use a ferramenta de linha de comando gcloud para atribuir o papel:

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 GCP que executa o Cloud KMS. Substitua project_number pelo número do projeto (não é o código do projeto) do projeto do GCP que executa o BigQuery. Substitua kms_key_location, kms_key_ring e kms_key pelo local, pelo keyring e pelos nomes de chave da 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 seu conjunto de dados na interface do usuário da Web do BigQuery e selecione 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. Em Chave de criptografia gerenciada pelo cliente, insira o código de recurso da 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, use 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 a partir de 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

// 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")
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-central1/keyRings/test/cryptoKeys/test",
	},
}
if err := tableRef.Create(ctx, meta); err != nil {
	return err
}

Python

Para proteger uma nova tabela com uma chave de criptografia gerenciada pelo cliente, defina a propriedade Table.encryption_configuration com um objeto EncryptionConfiguration (ambos em inglês) 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-central1', '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 que esteja 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 sará usada quando houver uma consulta a uma tabela protegida pelo Cloud KMS.

Todas as ferramentas existentes, o console do BigQuery e a interface da linha de comando bq, são executadas da mesma forma 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. Em Chave de criptografia gerenciada pelo cliente, insira o código de recurso da 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.

Outra opção é usar a sinalização --destination_table para especificar o destino dos resultados da consulta. Se --destination_table não for usada, 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

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(destDatasetID).Table(destTableID)
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",
}
return runAndRead(ctx, client, q)
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.Println(row)
}

Python

Para proteger uma tabela de destino de consulta com uma chave de criptografia gerenciada pelo cliente, defina a propriedade QueryJobConfig.destination_encryption_configuration como EncryptionConfiguration (ambos em inglês) e execute a consulta.

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

job_config = bigquery.QueryJobConfig()

# Set the destination table. Here, dataset_id is a string, such as:
# dataset_id = 'your_dataset_id'
table_ref = client.dataset(dataset_id).table('your_table_id')
job_config.destination = table_ref

# 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-central1', 'test', 'test')
encryption_config = bigquery.EncryptionConfiguration(
    kms_key_name=kms_key_name)
job_config.destination_encryption_configuration = encryption_config

# Start the query, passing in the extra configuration.
query_job = client.query(
    'SELECT 17 AS my_col;',
    # Location must match that of the dataset(s) referenced in the query
    # and of the destination table.
    location='US',
    job_config=job_config)  # API request - starts the query
query_job.result()

# The destination table is written using the encryption configuration.
table = client.get_table(table_ref)
assert table.encryption_configuration.kms_key_name == kms_key_name

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 carga 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 GCP.
    Acessar a IU da Web do BigQuery (em inglês)
  2. Na seção Recursos do painel de navegação, expanda 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. Se não aparecer 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 carga 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
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

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

Python

Para proteger uma tabela de destino do job de carga com uma chave de criptografia gerenciada pelo cliente, defina a propriedade LoadJobConfig.destination_encryption_configuration como EncryptionConfiguration (ambos em inglês) 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-central1', '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

Use o comando bq cp com a sinalização --destination_kms_key para copiar uma tabela protegida por criptografia padrão em uma nova tabela ou na 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

Caso queira alterar uma tabela da proteção do Cloud KMS para a criptografia padrão, copie o arquivo para ele 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

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

Python

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 (ambos em inglês) e copie a tabela.

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

source_dataset = bigquery.DatasetReference(
    'bigquery-public-data', 'samples')
source_table_ref = source_dataset.table('shakespeare')

# dataset_id = 'my_dataset'
dest_dataset_ref = client.dataset(dataset_id)
dest_table_ref = dest_dataset_ref.table('destination_table')

# 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-central1', 'test', 'test')
encryption_config = bigquery.EncryptionConfiguration(
    kms_key_name=kms_key_name)
job_config = bigquery.CopyJobConfig()
job_config.destination_encryption_configuration = encryption_config

job = client.copy_table(
    source_table_ref,
    dest_table_ref,
    # Location must match that of the source and destination tables.
    location='US',
    job_config=job_config)  # API request
job.result()  # Waits for job to complete.

assert job.state == 'DONE'
dest_table = client.get_table(dest_table_ref)
assert dest_table.encryption_configuration.kms_key_name == kms_key_name

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 atual, execute uma consulta ALTER TABLE, use a API ou use 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, terá como alterar a chave do Cloud KMS usada em uma tabela protegida pelo 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. A vantagem de usar update é que ela é mais rápida 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 (em inglês)

  2. Clique em Escrever consulta.

  3. Digite a instrução DDL na área de texto Nova consulta. No 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

Use 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

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

Python

Para modificar a chave de criptografia gerenciada pelo cliente de uma tabela, altere a propriedade Table.encryption_configuration para um novo objeto EncryptionConfiguration (ambos em inglês) 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-central1/'
    '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 atual, ela só se aplica a tabelas novas.

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 serão mais acessados. query, cp, extract e tabledata.list apresentarão falha.

  • Nenhum dado novo 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 nas inserções de streaming

A chave do Cloud KMS permanece 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. Quando ela não está disponível e acessível, os dados de streaming não são totalmente mantidos e talvez sejam perdidos. Para mais informações sobre inserções de streaming, consulte Como fazer streaming de dados para o BigQuery.

Impacto nos dados inacessíveis a 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 de uma tabela protegida pelo Cloud KMS são substituídos pelas operações WRITE_TRUNCATE, load ou cp por meio de disposição de gravação query, a tabela fica inacessível para consulta via decoradores de tabela, dependendo do tempo do decorador de instantâneo.

Supondo que uma tabela tenha sido substituída no período T e o decorador de instantâneo snapshot_time seja de um período inferior a 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

Uma lógica semelhante ocorre com <time2> quando se usa um decorador de intervalo.

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

Por exemplo, pense em três tabelas protegidas pelo CMEK: table1, table2 e table3. Para consultar dados de {project1.table1, project2.table2} com a 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.

Como receber mais ajuda?

Se você tiver perguntas que não foram respondidas aqui, entre em contato com cmek-feedback@google.com, 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 existentes 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.
Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

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