Como proteger dados com chaves do Cloud KMS

Por padrão, o BigQuery criptografa o conteúdo do cliente armazenado em repouso. O BigQuery trata e gerencia essa criptografia padrão, sem ações adicionais da sua parte. Primeiro, os dados de uma tabela BigQuery são criptografados usando uma chave de criptografia de dados. Em seguida, essas chaves são criptografadas com chaves de criptografia de chaves, conhecidas como criptografia de envelope. Os dados não são diretamente criptografados com a criptografia de envelope. Esse método codifica as chaves de criptografia de dados, usadas pelo Google para encriptar 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ê 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, a convenção a seguir é usada:

    • [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 de projetos do GCP e números de projetos, 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.
    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 Localizações em nuvem.

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

  2. Clique no ícone de seta para baixo ícone de seta para baixo ao lado do nome do seu projeto na navegação e 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 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 BigQuery copiada 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 um papel.

    • Se a conta de serviço bq-[PROJECT_NUMBER]@bigquery-encryption.iam.gserviceaccount.com ainda não estiver na lista de membros, ela não terá 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 estiver na lista de membros, a conta de serviço já terá papéis. Clique na lista suspensa do papel atual da 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

É possível usar 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 está executando o Cloud KMS, substitua [PROJECT_NUMBER] pelo número do projeto (não pelo código do projeto) do GCP que está executando o BigQuery e substitua [KMS_KEY_LOCATION], [KMS_KEY_RING] e [KMS_KEY] pelo local, keyring e nomes de chaves da sua chave do Cloud KMS.

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, em seguida, 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. Em Chave de criptografia gerenciada pelo cliente, insira o código de recurso para a chave. Essa chave está no formato:
      projects/[PROJECT_ID]/locations/[LOCATION]/keyRings/[KEYRING]/cryptoKeys/[KEY]
      
      Para informações sobre como recuperar o código do recurso da chave, veja Código do 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 do recurso da chave a ser usada com a tabela. Essa chave está no formato:

projects/[PROJECT_ID]/locations/[LOCATION]/keyRings/[KEYRING]/cryptoKeys/[KEY]
Para informações sobre como recuperar o código do recurso da chave, veja Código do recurso da chave.
bq mk --schema name:string,value:integer -t \
--destination_kms_key projects/[PROJECT_ID]/locations/[LOCATION]/keyRings/[KEYRING]/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/[KEYRING]/cryptoKeys/[KEY]'
  )
"

Para criar uma tabela de uma consulta:

bq query --destination_table=mydataset.newtable \
--destination_kms_key projects/[PROJECT_ID]/locations/[LOCATION]/keyRings/[KEYRING]/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 o tópico 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 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-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 da Web

  1. Clique no botão Escrever consulta na interface do usuário 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 do recurso da chave. Essa chave está no formato:

    projects/[PROJECT_ID]/locations/[LOCATION]/keyRings/[KEYRING]/cryptoKeys/[KEY]
    
    Para informações sobre como recuperar o código do recurso da chave, veja Código do recurso da chave.

  5. Clique em RunQuery.

Linha de comando

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

projects/[PROJECT_ID]/locations/[LOCATION]/keyRings/[KEYRING]/cryptoKeys/[KEY]
Para informações sobre como recuperar o código do recurso da chave, consulte [Código do recurso da chave](/kms/docs/object-hierarchy#key_resource_id). Você também pode usar o sinalizador `--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/[KEYRING]/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 o tópico 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 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:

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 de job de carga 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-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 o 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

Linha de comando

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 do recurso da chave a ser usada com a tabela de destino. Essa chave está no formato:

projects/[PROJECT_ID]/locations/[LOCATION]/keyRings/[KEYRING]/cryptoKeys/[KEY]

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

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/[KEYRING]/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/[KEYRING]/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 o tópico 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 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 está protegida pelo Cloud KMS

  1. Na interface do usuário da Web do BigQuery, clique na seta azul à esquerda do conjunto de dados para expandi-lo ou clique duas vezes no nome do conjunto de dados. 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. Com update, a chave do Cloud KMS utilizada para uma tabela protegida pelo KMS será alterada. Com cp, a chave do Cloud KMS utilizada para uma tabela protegida pelo CMEK será alterada, uma tabela da criptografia padrão será alterada para a proteção do CMEK e uma tabela de proteção do CMEK será alterada 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

Essa chave está no formato:

projects/[PROJECT_ID]/locations/[LOCATION]/keyRings/[KEYRING]/cryptoKeys/[KEY]

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

  1. Acesse a IU da Web do BigQuery.

    Acessar a IU da Web do BigQuery

  2. Clique em Escrever consulta.

  3. Digite a instrução DDL na área de texto Nova consulta.

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

Linha de comando

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 do recurso da chave a ser usada com a tabela. Essa chave está no formato:

projects/[PROJECT_ID]/locations/[LOCATION]/keyRings/[KEYRING]/cryptoKeys/[KEY]

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

bq update \
--destination_kms_key projects/[PROJECT_ID]/locations/[LOCATION]/keyRings/[KEYRING]/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 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

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 Fazer streaming de dados no 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

Observe que uma lógica semelhante é aplicada a <time2> quando é usado 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.

Também é usada, no BigQuery, a chave para manutenção de dados e tarefas de otimização de armazenamento, como a conversão de dados em formato otimizado para leitura.

Como receber mais ajuda?

Para dúvidas não 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 de uma região que corresponda ao seu conjunto de dados ou carregue para um conjunto de dados que corresponda à região da chave.

Problemas conhecidos

  • As bibliotecas de cliente do BigQuery ainda não são compatíveis com os comandos de configuração de chaves de criptografia gerenciadas pelo cliente.
Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

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