Chaves do Cloud KMS geridas pelo cliente

Nota: esta funcionalidade pode não estar disponível quando usa reservas criadas com determinadas edições do BigQuery. Para mais informações sobre as funcionalidades ativadas em cada edição, consulte o artigo Introdução às edições do BigQuery.

Por predefinição, o BigQuery encripta o seu conteúdo armazenado em repouso. O BigQuery processa e gere esta encriptação predefinida por si sem ações adicionais da sua parte. Primeiro, os dados numa tabela do BigQuery são encriptados com uma chave de encriptação de dados. Em seguida, essas chaves de encriptação de dados são encriptadas com chaves de encriptação de chaves, o que é conhecido como encriptação de envelope. As chaves de encriptação de chaves não encriptam diretamente os seus dados, mas são usadas para encriptar as chaves de encriptação de dados que a Google usa para encriptar os seus dados.

Se quiser controlar a encriptação, pode usar chaves de encriptação geridas pelo cliente (CMEK) para o BigQuery. Em vez de a Google possuir e gerir as chaves de encriptação de chaves que protegem os seus dados, controla e gere as chaves de encriptação de chaves no Cloud KMS. Este documento fornece detalhes sobre a criação manual de chaves do Cloud KMS para o BigQuery.

Saiba mais acerca das opções de encriptação no Google Cloud. Para informações específicas sobre a CMEK, incluindo as respetivas vantagens e limitações, consulte o artigo Chaves de encriptação geridas pelo cliente.

Antes de começar

• Todos os recursos de dados residentes no armazenamento gerido do BigQuery suportam CMEK. No entanto, se também estiver a consultar dados armazenados numa origem de dados externa, como o Cloud Storage, que tenha dados encriptados com CMEK, a encriptação de dados é gerida pelo Cloud Storage. Por exemplo, as tabelas BigLake suportam dados encriptados com CMEK no Cloud Storage.

  O BigQuery e as tabelas do BigLake não suportam chaves de encriptação fornecidas pelo cliente (CSEK).

• Decida se vai executar o BigQuery e o Cloud KMS no mesmo Google Cloud projeto ou em projetos diferentes. Para fins de exemplos de documentação, é usada a seguinte convenção:

  • PROJECT_ID: o ID do projeto do projeto que executa o BigQuery
  • PROJECT_NUMBER: o número do projeto do projeto que executa o BigQuery
  • KMS_PROJECT_ID: o ID do projeto do projeto que executa o Cloud KMS (mesmo que seja o mesmo projeto que executa o BigQuery)
  Para obter informações sobre os Google Cloud IDs e os números dos projetos, consulte o artigo Identificar projetos.

• O BigQuery é ativado automaticamente em novos projetos. Se estiver a usar um projeto pré-existente para executar o BigQuery, ative a API BigQuery.

• Para o Google Cloud projeto que executa o Cloud KMS, ative a API Cloud Key Management Service.

É feita uma chamada de desencriptação através do Cloud KMS uma vez por consulta a uma tabela encriptada com CMEK. Para mais informações, consulte os preços do Cloud KMS.

Especificação de encriptação

As chaves do Cloud KMS usadas para proteger os seus dados no BigQuery são chaves AES-256. Estas chaves são usadas como chaves de encriptação de chaves no BigQuery, uma vez que encriptam as chaves de encriptação de dados que encriptam os seus dados.

Criação de chaves manual ou automática

Pode criar as suas chaves CMEK manualmente ou usar a chave automática do Cloud KMS. A funcionalidade Autokey simplifica a criação e a gestão das suas chaves CMEK através da automatização do aprovisionamento e da atribuição. Com o Autokey, não precisa de aprovisionar conjuntos de chaves, chaves e contas de serviço antecipadamente. Em vez disso, são gerados a pedido como parte da criação de recursos do BigQuery. Para mais informações, consulte a Vista geral do Autokey.

Crie manualmente um conjunto de chaves e uma chave

Para o Google Cloud projeto que executa o Cloud KMS, crie um conjunto de chaves e uma chave, conforme descrito em Criar conjuntos de chaves e chaves. Crie o anel de chaves numa localização que corresponda à localização do seu conjunto de dados do BigQuery:

• Qualquer conjunto de dados multirregional deve usar um anel de chaves multirregional de uma localização correspondente. Por exemplo, um conjunto de dados na região US deve ser protegido com um conjunto de chaves da região us, e um conjunto de dados na região EU deve ser protegido com um conjunto de chaves da região europe.

• Os conjuntos de dados regionais devem usar chaves regionais correspondentes. Por exemplo, um conjunto de dados na região asia-northeast1 deve ser protegido com um conjunto de chaves da região asia-northeast1.

• Não pode usar a região global quando configurar a CMEK para o BigQuery na Google Cloud consola. No entanto, pode usar a região global ao configurar a CMEK para o BigQuery através da ferramenta de linha de comandos bq ou do GoogleSQL.

Para mais informações sobre as localizações suportadas para o BigQuery e o Cloud KMS, consulte o artigo Localizações na nuvem.

Conceda autorização de encriptação e desencriptação

Para proteger os seus dados do BigQuery com uma chave CMEK, conceda à conta de serviço do BigQuery autorização para encriptar e desencriptar com essa chave. A função Encriptador/desencriptador de CryptoKey do Cloud KMS concede esta autorização.

Certifique-se de que a conta de serviço foi criada e, em seguida, use a Google Cloud consola para determinar o ID da conta de serviço do BigQuery. Em seguida, atribua à conta de serviço a função adequada para encriptar e desencriptar através do Cloud KMS.

Acione a criação da sua conta de serviço

A sua conta de serviço do BigQuery não é criada inicialmente quando cria um projeto. Para acionar a criação da sua conta de serviço, introduza um comando que a use, como o comando bq show --encryption_service_account, ou chame o método da API projects.getServiceAccount. Por exemplo:

bq show --encryption_service_account --project_id=PROJECT_ID

Determine o ID da conta de serviço

O ID da conta de serviço do BigQuery tem o seguinte formato:

[e-mail]

As técnicas seguintes mostram como pode determinar o ID da conta de serviço do BigQuery para o seu projeto.

Consola

1. Aceda à página Painel de controlo na Google Cloud consola.

   Aceda à página Painel de controlo

2. Clique na lista pendente Selecionar a partir de na parte superior da página. Na janela Selecionar de apresentada, selecione o seu projeto.

3. O ID do projeto e o número do projeto são apresentados no cartão Informações do projeto do painel de controlo do projeto:

   

4. Na string seguinte, substitua PROJECT_NUMBER pelo número do seu projeto. A nova string identifica o ID da conta de serviço do BigQuery.

   [e-mail]
   

bq

Use o comando bq show com a flag --encryption_service_account para determinar o ID da conta de serviço:

bq show --encryption_service_account

O comando apresenta o ID da conta de serviço:

                  ServiceAccountID
-------------------------------------------------------------
[e-mail]

Atribua a função de encriptador/desencriptador

Atribua a função de encriptar/desencriptar do CryptoKey do Cloud KMS à conta de serviço do sistema do BigQuery que copiou para a área de transferência. Esta conta tem o seguinte formato:

[e-mail]

Consola

1. Abra a página Chaves criptográficas na Google Cloud consola.

   Abra a página Chaves criptográficas

2. Clique no nome do conjunto de chaves que contém a chave.

3. Clique na caixa de verificação da chave de encriptação à qual quer adicionar a função. É aberto o separador Permissões.

4. Clique em Adicionar membro.

5. Introduza o endereço de email da conta de serviço, [e-mail].

   • Se a conta de serviço já estiver na lista de membros, tem funções existentes. Clique na lista pendente da função atual para a conta de serviço [e-mail].

6. Clique na lista pendente Selecionar uma função, clique em Cloud KMS e, de seguida, clique na função Encriptador/desencriptador de CryptoKey do Cloud KMS.

7. Clique em Guardar para aplicar a função à conta de serviço [e-mail].

gcloud

Pode usar a Google Cloud CLI para atribuir a função:

gcloud kms keys add-iam-policy-binding \
--project=KMS_PROJECT_ID \
--member serviceAccount:[e-mail] \
--role roles/cloudkms.cryptoKeyEncrypterDecrypter \
--location=KMS_KEY_LOCATION \
--keyring=KMS_KEY_RING \
KMS_KEY

Substitua o seguinte:

• KMS_PROJECT_ID: o ID do seu Google Cloud projeto que está a executar o Cloud KMS
• PROJECT_NUMBER: o número do projeto (não o ID do projeto) do seu projeto que está a executar o BigQuery Google Cloud
• KMS_KEY_LOCATION: o nome da localização da sua chave do Cloud KMS
• KMS_KEY_RING: o nome do conjunto de chaves da sua chave do Cloud KMS
• KMS_KEY: o nome da chave da sua chave do Cloud KMS

ID de recurso da chave

O ID de recurso da chave do Cloud KMS é necessário para a utilização da CMEK, conforme mostrado nos exemplos. Esta chave é sensível a maiúsculas e minúsculas e tem o seguinte formato:

projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY

Nota: não pode especificar um ID de recurso da chave que inclua o token /cryptoKeyVersions/. O BigQuery usa sempre a versão da chave marcada como primary para proteger uma tabela quando é criada.

Recupere o ID de recurso da chave

1. Abra a página Chaves criptográficas na Google Cloud consola.

   Abra a página Chaves criptográficas

2. Clique no nome do conjunto de chaves que contém a chave.

3. Para a chave cujo ID de recurso está a obter, clique em Mais .

4. Clique em Copiar nome do recurso. O ID do recurso da chave é copiado para a área de transferência. O ID do recurso também é conhecido como o nome do recurso.

Crie uma tabela protegida pelo Cloud KMS

Para criar uma tabela protegida pelo Cloud KMS:

Consola

1. Abra a página do BigQuery na Google Cloud consola.

   Aceda à página do BigQuery

2. No painel Explorador, expanda o projeto e selecione um conjunto de dados.

3. Expanda a opção Ações e clique em Abrir.

4. No painel de detalhes, clique em Criar tabela .

5. 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, defina o tipo de encriptação e especifique a chave do Cloud KMS a usar com a tabela:

   1. Clique em Opções avançadas.
   2. Clique em Chave gerida pelo cliente.
   3. Selecione a chave. Se a chave que quer usar não estiver listada, introduza o ID do recurso da chave.

6. Clique em Criar tabela.

SQL

Use a declaração CREATE TABLE com a opção kms_key_name:

1. Na Google Cloud consola, aceda à página BigQuery.

   Aceda ao BigQuery

2. No editor de consultas, introduza a seguinte declaração:

   CREATE TABLE DATASET_ID.TABLE_ID (
     name STRING, value INT64
   ) OPTIONS (
       kms_key_name
         = 'projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY');

3. Clique em Executar.

Para mais informações sobre como executar consultas, consulte o artigo Execute uma consulta interativa.

bq

Pode usar a ferramenta de linhas de comando bq com a flag --destination_kms_key para criar a tabela. A flag --destination_kms_key especifica o ID de recurso da chave a usar com a tabela.

Para criar uma tabela vazia com um esquema:

bq mk --schema name:string,value:integer -t \
--destination_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
DATASET_ID.TABLE_ID

Para criar uma tabela a partir de uma consulta:

bq query --destination_table=DATASET_ID.TABLE_ID \
--destination_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
"SELECT name,count FROM DATASET_ID.TABLE_ID WHERE gender = 'M' ORDER BY count DESC LIMIT 6"

Para mais informações sobre a ferramenta de linhas de comando bq, consulte o artigo Usar a ferramenta de linhas de comando bq.

Terraform

Use o recurso google_bigquery_table.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

O exemplo seguinte cria uma tabela denominada mytable e também usa os recursos google_kms_crypto_key e google_kms_key_ring para especificar uma chave do Cloud Key Management Service para a tabela.

Para executar este exemplo, tem de ativar a API Cloud Resource Manager e a API Cloud Key Management Service.

resource "google_bigquery_dataset" "default" {
  dataset_id                      = "mydataset"
  default_partition_expiration_ms = 2592000000  # 30 days
  default_table_expiration_ms     = 31536000000 # 365 days
  description                     = "dataset description"
  location                        = "US"
  max_time_travel_hours           = 96 # 4 days

  labels = {
    billing_group = "accounting",
    pii           = "sensitive"
  }
}

resource "google_bigquery_table" "default" {
  dataset_id          = google_bigquery_dataset.default.dataset_id
  table_id            = "mytable"
  deletion_protection = false # set to "true" in production

  schema = <<EOF
[
  {
    "name": "ID",
    "type": "INT64",
    "mode": "NULLABLE",
    "description": "Item ID"
  },
  {
    "name": "Item",
    "type": "STRING",
    "mode": "NULLABLE"
  }
]
EOF

  encryption_configuration {
    kms_key_name = google_kms_crypto_key.crypto_key.id
  }

  depends_on = [google_project_iam_member.service_account_access]
}

resource "google_kms_crypto_key" "crypto_key" {
  name     = "example-key"
  key_ring = google_kms_key_ring.key_ring.id
}

resource "random_id" "default" {
  byte_length = 8
}

resource "google_kms_key_ring" "key_ring" {
  name     = "${random_id.default.hex}-example-keyring"
  location = "us"
}

# Enable the BigQuery service account to encrypt/decrypt Cloud KMS keys
data "google_project" "project" {
}

resource "google_project_iam_member" "service_account_access" {
  project = data.google_project.project.project_id
  role    = "roles/cloudkms.cryptoKeyEncrypterDecrypter"
  member  = "serviceAccount:bq-${data.google_project.project.number}@bigquery-encryption.iam.gserviceaccount.com"
}

Para aplicar a configuração do Terraform num Google Cloud projeto, conclua os passos nas secções seguintes.

Prepare o Cloud Shell

1. Inicie o Cloud Shell.

2. Defina o Google Cloud projeto predefinido onde quer aplicar as suas configurações do Terraform.

   Só tem de executar este comando uma vez por projeto e pode executá-lo em qualquer diretório.

   export GOOGLE_CLOUD_PROJECT=PROJECT_ID

   As variáveis de ambiente são substituídas se definir valores explícitos no ficheiro de configuração do Terraform.

Prepare o diretório

Cada ficheiro de configuração do Terraform tem de ter o seu próprio diretório (também denominado módulo raiz).

1. No Cloud Shell, crie um diretório e um novo ficheiro nesse diretório. O nome do ficheiro tem de ter a extensão .tf, por exemplo, main.tf. Neste tutorial, o ficheiro é denominado main.tf.

   mkdir DIRECTORY && cd DIRECTORY && touch main.tf

2. Se estiver a seguir um tutorial, pode copiar o código de exemplo em cada secção ou passo.

   Copie o exemplo de código para o ficheiro main.tf criado recentemente.

   Opcionalmente, copie o código do GitHub. Isto é recomendado quando o fragmento do Terraform faz parte de uma solução completa.

3. Reveja e modifique os parâmetros de exemplo para aplicar ao seu ambiente.
4. Guarde as alterações.
5. Inicialize o Terraform. Só tem de fazer isto uma vez por diretório.

   terraform init

   Opcionalmente, para usar a versão mais recente do fornecedor Google, inclua a opção -upgrade:

   terraform init -upgrade

Aplique as alterações

1. Reveja a configuração e verifique se os recursos que o Terraform vai criar ou atualizar correspondem às suas expetativas:

   terraform plan

   Faça as correções necessárias à configuração.

2. Aplique a configuração do Terraform executando o seguinte comando e introduzindo yes no comando:

   terraform apply

   Aguarde até que o Terraform apresente a mensagem "Apply complete!" (Aplicação concluída!).

3. Abra o seu Google Cloud projeto para ver os resultados. Na Google Cloud consola, navegue para os seus recursos na IU para se certificar de que o Terraform os criou ou atualizou.

Nota: os exemplos do Terraform partem geralmente do princípio de que as APIs necessárias estão ativadas no seu Google Cloud projeto.

Go

Antes de experimentar este exemplo, siga as Goinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Go BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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
}

Java

Antes de experimentar este exemplo, siga as Javainstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Java BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.EncryptionConfiguration;
import com.google.cloud.bigquery.Field;
import com.google.cloud.bigquery.Schema;
import com.google.cloud.bigquery.StandardSQLTypeName;
import com.google.cloud.bigquery.StandardTableDefinition;
import com.google.cloud.bigquery.TableDefinition;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableInfo;

// Sample to create a cmek table
public class CreateTableCMEK {

  public static void runCreateTableCMEK() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String kmsKeyName = "MY_KEY_NAME";
    Schema schema =
        Schema.of(
            Field.of("stringField", StandardSQLTypeName.STRING),
            Field.of("booleanField", StandardSQLTypeName.BOOL));
    // i.e. projects/{project}/locations/{location}/keyRings/{key_ring}/cryptoKeys/{cryptoKey}
    EncryptionConfiguration encryption =
        EncryptionConfiguration.newBuilder().setKmsKeyName(kmsKeyName).build();
    createTableCMEK(datasetName, tableName, schema, encryption);
  }

  public static void createTableCMEK(
      String datasetName, String tableName, Schema schema, EncryptionConfiguration configuration) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(datasetName, tableName);
      TableDefinition tableDefinition = StandardTableDefinition.of(schema);
      TableInfo tableInfo =
          TableInfo.newBuilder(tableId, tableDefinition)
              .setEncryptionConfiguration(configuration)
              .build();

      bigquery.create(tableInfo);
      System.out.println("Table cmek created successfully");
    } catch (BigQueryException e) {
      System.out.println("Table cmek was not created. \n" + e.toString());
    }
  }
}

Python

Antes de experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Python BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

Proteja uma nova tabela com uma chave de encriptação gerida pelo cliente definindo a propriedade Table.encryption_configuration para um objeto EncryptionConfiguration antes de criar a tabela.

from google.cloud import bigquery

client = bigquery.Client()

# TODO(dev): Change table_id to the full name of the table you want to create.
table_id = "your-project.your_dataset.your_table_name"

# 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/your-project/locations/us/keyRings/test/cryptoKeys/test"

table = bigquery.Table(table_id)
table.encryption_configuration = bigquery.EncryptionConfiguration(
    kms_key_name=kms_key_name
)
table = client.create_table(table)  # API request

print(f"Created {table_id}.")
print(f"Key: {table.encryption_configuration.kms_key_name}.")

Consultar uma tabela protegida por uma chave do Cloud KMS

Não são necessários procedimentos especiais para consultar uma tabela protegida pelo Cloud KMS. O BigQuery armazena o nome da chave usada para encriptar o conteúdo da tabela e usa essa chave quando é consultada uma tabela protegida pelo Cloud KMS.

Todas as ferramentas existentes, a consola do BigQuery e a ferramenta de linha de comandos bq são executadas da mesma forma que com as tabelas encriptadas por predefinição, desde que o BigQuery tenha acesso à chave do Cloud KMS usada para encriptar o conteúdo da tabela.

Proteja os resultados das consultas com uma chave do Cloud KMS

Por predefinição, os resultados da consulta são armazenados numa tabela temporária encriptada com um Google-owned and Google-managed encryption key. Se o projeto já tiver uma chave predefinida, a chave é aplicada à tabela de resultados da consulta temporária (predefinida). Em alternativa, para usar uma chave do Cloud KMS para encriptar os resultados da consulta, selecione uma das seguintes opções:

Consola

1. Abra a página do BigQuery na Google Cloud consola.

   Aceda à página do BigQuery

2. Clique em Redigir nova consulta.

3. Introduza uma consulta GoogleSQL válida na área de texto da consulta.

4. Clique em Mais, clique em Definições de consulta e, de seguida, clique em Opções avançadas.

5. Selecione Encriptação gerida pelo cliente.

6. Selecione a chave. Se a chave que quer usar não estiver listada, introduza o ID do recurso da chave.

7. Clique em Guardar.

8. Clique em Executar.

bq

Especifique a flag --destination_kms_key para proteger a tabela de destino ou os resultados da consulta (se usar uma tabela temporária) com a sua chave do Cloud KMS. A flag --destination_kms_key especifica o ID do recurso da chave a usar com o destino ou a tabela resultante.

Opcionalmente, use a flag --destination_table para especificar o destino dos resultados da consulta. Se --destination_table não for usado, os resultados da consulta são escritos numa tabela temporária.

Para consultar uma tabela:

bq query \
--destination_table=DATASET_ID.TABLE_ID \
--destination_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
"SELECT name,count FROM DATASET_ID.TABLE_ID WHERE gender = 'M' ORDER BY count DESC LIMIT 6"

Para mais informações sobre a ferramenta de linhas de comando bq, consulte o artigo Usar a ferramenta de linhas de comando bq.

Go

Antes de experimentar este exemplo, siga as Goinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Go BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

Proteja uma nova tabela com uma chave de encriptação gerida pelo cliente definindo a propriedade Table.encryption_configuration para um objeto EncryptionConfiguration antes de criar a tabela.

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
}

Java

Antes de experimentar este exemplo, siga as Javainstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Java BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

Proteja uma nova tabela com uma chave de encriptação gerida pelo cliente definindo a propriedade Table.encryption_configuration para um objeto EncryptionConfiguration antes de criar a tabela.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.EncryptionConfiguration;
import com.google.cloud.bigquery.QueryJobConfiguration;
import com.google.cloud.bigquery.TableResult;

// Sample to query on destination table with encryption key
public class QueryDestinationTableCMEK {

  public static void runQueryDestinationTableCMEK() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String kmsKeyName = "MY_KMS_KEY_NAME";
    String query =
        String.format("SELECT stringField, booleanField FROM %s.%s", datasetName, tableName);
    EncryptionConfiguration encryption =
        EncryptionConfiguration.newBuilder().setKmsKeyName(kmsKeyName).build();
    queryDestinationTableCMEK(query, encryption);
  }

  public static void queryDestinationTableCMEK(String query, EncryptionConfiguration encryption) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      QueryJobConfiguration config =
          QueryJobConfiguration.newBuilder(query)
              // Set the encryption key to use for the destination.
              .setDestinationEncryptionConfiguration(encryption)
              .build();

      TableResult results = bigquery.query(config);

      results
          .iterateAll()
          .forEach(row -> row.forEach(val -> System.out.printf("%s,", val.toString())));
      System.out.println("Query performed successfully with encryption key.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Query not performed \n" + e.toString());
    }
  }
}

Python

Antes de experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Python BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

Proteja uma tabela de destino de consulta com uma chave de encriptação gerida pelo cliente definindo a propriedade QueryJobConfig.destination_encryption_configuration como uma EncryptionConfiguration e execute a consulta.

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

Carregue uma tabela protegida pelo Cloud KMS

Para carregar um ficheiro de dados numa tabela protegida pelo Cloud KMS:

Consola

Proteja uma tabela de destino de uma tarefa de carregamento com uma chave de encriptação gerida pelo cliente especificando a chave quando carregar a tabela.

1. Abra a página do BigQuery na Google Cloud consola.

   Aceda à página do BigQuery

2. No painel Explorador, expanda o projeto e selecione um conjunto de dados.

3. No painel de detalhes, clique em Criar tabela.

4. Introduza as opções que quer usar para carregar a tabela, mas antes de clicar em Criar tabela, clique em Opções avançadas.

5. Em Encriptação, selecione Chave gerida pelo cliente.

6. Clique na lista pendente Selecionar uma chave gerida pelo cliente e selecione a chave a usar. Se não vir nenhuma chave disponível, introduza um ID do recurso da chave.

   

7. Clique em Criar tabela.

bq

Proteja uma tabela de destino de uma tarefa de carregamento com uma chave de encriptação gerida pelo cliente definindo a flag --destination_kms_key.

bq --location=LOCATION load \
--autodetect \
--source_format=FORMAT \
--destination_kms_key projects/KMS_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/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
test2.table4 \
gs://cloud-samples-data/bigquery/us-states/us-states.json

Go

Antes de experimentar este exemplo, siga as Goinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Go BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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
}

Java

Antes de experimentar este exemplo, siga as Javainstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Java BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.EncryptionConfiguration;
import com.google.cloud.bigquery.FormatOptions;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.LoadJobConfiguration;
import com.google.cloud.bigquery.TableId;

// Sample to load JSON data with configuration key from Cloud Storage into a new BigQuery table
public class LoadJsonFromGCSCMEK {

  public static void runLoadJsonFromGCSCMEK() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String kmsKeyName = "MY_KMS_KEY_NAME";
    String sourceUri = "gs://cloud-samples-data/bigquery/us-states/us-states.json";
    // i.e. projects/{project}/locations/{location}/keyRings/{key_ring}/cryptoKeys/{cryptoKey}
    EncryptionConfiguration encryption =
        EncryptionConfiguration.newBuilder().setKmsKeyName(kmsKeyName).build();
    loadJsonFromGCSCMEK(datasetName, tableName, sourceUri, encryption);
  }

  public static void loadJsonFromGCSCMEK(
      String datasetName, String tableName, String sourceUri, EncryptionConfiguration encryption) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId tableId = TableId.of(datasetName, tableName);
      LoadJobConfiguration loadConfig =
          LoadJobConfiguration.newBuilder(tableId, sourceUri)
              // Set the encryption key to use for the destination.
              .setDestinationEncryptionConfiguration(encryption)
              .setFormatOptions(FormatOptions.json())
              .setAutodetect(true)
              .build();

      // Load data from a GCS JSON file into the table
      Job job = bigquery.create(JobInfo.of(loadConfig));
      // Blocks until this load table job completes its execution, either failing or succeeding.
      job = job.waitFor();
      if (job.isDone()) {
        System.out.println("Table loaded succesfully from GCS with configuration key");
      } else {
        System.out.println(
            "BigQuery was unable to load into the table due to an error:"
                + job.getStatus().getError());
      }
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Column not added during load append \n" + e.toString());
    }
  }
}

Python

Antes de experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Python BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

Proteja uma tabela de destino de uma tarefa de carregamento com uma chave de encriptação gerida pelo cliente definindo a propriedade LoadJobConfig.destination_encryption_configuration para uma EncryptionConfiguration e carregue a tabela.

from google.cloud import bigquery

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

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

# 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"
# )

job_config = bigquery.LoadJobConfig(
    autodetect=True,
    source_format=bigquery.SourceFormat.NEWLINE_DELIMITED_JSON,
    destination_encryption_configuration=bigquery.EncryptionConfiguration(
        kms_key_name=kms_key_name
    ),
)

uri = "gs://cloud-samples-data/bigquery/us-states/us-states.json"

load_job = client.load_table_from_uri(
    uri,
    table_id,
    location="US",  # Must match the destination dataset location.
    job_config=job_config,
)  # Make an API request.

assert load_job.job_type == "load"

load_job.result()  # Waits for the job to complete.

assert load_job.state == "DONE"
table = client.get_table(table_id)

if table.encryption_configuration.kms_key_name == kms_key_name:
    print("A table loaded with encryption configuration key")

Fazer stream para uma tabela protegida pelo Cloud KMS

Pode transmitir dados para a sua tabela do BigQuery protegida pela CMEK sem especificar parâmetros adicionais. Tenha em atenção que estes dados são encriptados com a sua chave do Cloud KMS na memória intermédia, bem como na localização final. Antes de usar o streaming com uma tabela CMEK, reveja os requisitos de disponibilidade e acessibilidade das chaves.

Saiba mais sobre o streaming em Streaming de dados com a API Storage Write do BigQuery.

Altere uma tabela da encriptação predefinida para a proteção do Cloud KMS

bq

Pode usar o comando bq cp com a flag --destination_kms_key para copiar uma tabela protegida pela encriptação predefinida para uma nova tabela ou para a tabela original, protegida pelo Cloud KMS. A flag --destination_kms_key especifica o ID do recurso da chave a usar com a tabela de destino.

Para copiar uma tabela com encriptação predefinida para uma nova tabela com proteção do Cloud KMS:

bq cp \
--destination_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
SOURCE_DATASET_ID.SOURCE_TABLE_ID DESTINATION_DATASET_ID.DESTINATION_TABLE_ID

Se quiser copiar uma tabela com encriptação predefinida para a mesma tabela com proteção do Cloud KMS:

bq cp -f \
--destination_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
DATASET_ID.TABLE_ID DATASET_ID.TABLE_ID

Se quiser alterar uma tabela da proteção do Cloud KMS para a encriptação predefinida, copie o ficheiro para si próprio executando bq cp sem usar a flag --destination_kms_key.

Para mais informações sobre a ferramenta de linhas de comando bq, consulte o artigo Usar a ferramenta de linhas de comando bq.

Go

Antes de experimentar este exemplo, siga as Goinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Go BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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
}

Java

Antes de experimentar este exemplo, siga as Javainstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Java BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.CopyJobConfiguration;
import com.google.cloud.bigquery.EncryptionConfiguration;
import com.google.cloud.bigquery.Job;
import com.google.cloud.bigquery.JobInfo;
import com.google.cloud.bigquery.TableId;

// Sample to copy a cmek table
public class CopyTableCMEK {

  public static void runCopyTableCMEK() {
    // TODO(developer): Replace these variables before running the sample.
    String destinationDatasetName = "MY_DESTINATION_DATASET_NAME";
    String destinationTableId = "MY_DESTINATION_TABLE_NAME";
    String sourceDatasetName = "MY_SOURCE_DATASET_NAME";
    String sourceTableId = "MY_SOURCE_TABLE_NAME";
    String kmsKeyName = "MY_KMS_KEY_NAME";
    EncryptionConfiguration encryption =
        EncryptionConfiguration.newBuilder().setKmsKeyName(kmsKeyName).build();
    copyTableCMEK(
        sourceDatasetName, sourceTableId, destinationDatasetName, destinationTableId, encryption);
  }

  public static void copyTableCMEK(
      String sourceDatasetName,
      String sourceTableId,
      String destinationDatasetName,
      String destinationTableId,
      EncryptionConfiguration encryption) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      TableId sourceTable = TableId.of(sourceDatasetName, sourceTableId);
      TableId destinationTable = TableId.of(destinationDatasetName, destinationTableId);

      // For more information on CopyJobConfiguration see:
      // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/bigquery/JobConfiguration.html
      CopyJobConfiguration configuration =
          CopyJobConfiguration.newBuilder(destinationTable, sourceTable)
              .setDestinationEncryptionConfiguration(encryption)
              .build();

      // For more information on Job see:
      // https://googleapis.dev/java/google-cloud-clients/latest/index.html?com/google/cloud/bigquery/package-summary.html
      Job job = bigquery.create(JobInfo.of(configuration));

      // Blocks until this job completes its execution, either failing or succeeding.
      Job completedJob = job.waitFor();
      if (completedJob == null) {
        System.out.println("Job not executed since it no longer exists.");
        return;
      } else if (completedJob.getStatus().getError() != null) {
        System.out.println(
            "BigQuery was unable to copy table due to an error: \n" + job.getStatus().getError());
        return;
      }
      System.out.println("Table cmek copied successfully.");
    } catch (BigQueryException | InterruptedException e) {
      System.out.println("Table cmek copying job was interrupted. \n" + e.toString());
    }
  }
}

Python

Antes de experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Python BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

Proteja o destino de uma cópia de tabela com uma chave de encriptação gerida pelo cliente definindo a propriedade QueryJobConfig.destination_encryption_configuration para uma 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")

Determine se uma tabela está protegida pelo Cloud KMS

1. Na Google Cloud consola, clique na seta azul à esquerda do conjunto de dados para o expandir ou clique duas vezes no nome do conjunto de dados. São apresentadas as tabelas e as vistas no conjunto de dados.

2. Clique no nome da tabela.

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

4. Se a tabela estiver protegida pelo Cloud KMS, o campo Chave de encriptação gerida pelo cliente apresenta o ID do recurso da chave.

   

Para cada uma das chaves que criou ou que protegem as suas tabelas, pode ver que recursos essa chave protege com a monitorização da utilização de chaves. Para mais informações, consulte o artigo Veja a utilização de chaves.

Altere a chave do Cloud KMS para uma tabela do BigQuery

Para alterar a chave do Cloud KMS de uma tabela protegida pela CMEK existente, pode executar uma consulta ALTER TABLE, usar a API ou usar a ferramenta de linha de comandos bq. Existem duas formas de modificar a chave do Cloud KMS através da API e da ferramenta de linha de comandos bq: update ou cp.

Se usar o update, pode alterar a chave do Cloud KMS usada para uma tabela protegida por CMEK.

Se usar o cp, pode alterar a chave do Cloud KMS usada para uma tabela protegida por CMEK, alterar uma tabela da encriptação predefinida para a proteção por CMEK ou alterar uma tabela da proteção por CMEK para a encriptação predefinida.

Uma vantagem do update é que é mais rápido do que o cp e permite-lhe usar decoradores de tabelas.

SQL

Use a declaração ALTER TABLE SET OPTIONS para atualizar o campo kms_key_name de uma tabela:

1. Na Google Cloud consola, aceda à página BigQuery.

   Aceda ao BigQuery

2. No editor de consultas, introduza a seguinte declaração:

   ALTER TABLE DATASET_ID.mytable
   SET OPTIONS (
     kms_key_name
       = 'projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY');

3. Clique em Executar.

Para mais informações sobre como executar consultas, consulte o artigo Execute uma consulta interativa.

bq

Pode usar o comando bq cp com a flag --destination_kms_key para alterar a chave de uma tabela protegida pelo Cloud KMS. A flag --destination_kms_key especifica o ID de recurso da chave a usar com a tabela.

bq update \
--destination_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
-t DATASET_ID.TABLE_ID

Go

Antes de experimentar este exemplo, siga as Goinstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Go BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

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
}

Java

Antes de experimentar este exemplo, siga as Javainstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Java BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.EncryptionConfiguration;
import com.google.cloud.bigquery.Table;
import com.google.cloud.bigquery.TableId;

// Sample to update a cmek table
public class UpdateTableCMEK {

  public static void runUpdateTableCMEK() {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    String tableName = "MY_TABLE_NAME";
    String kmsKeyName = "MY_KEY_NAME";
    // Set a new encryption key to use for the destination.
    // i.e. projects/{project}/locations/{location}/keyRings/{key_ring}/cryptoKeys/{cryptoKey}
    EncryptionConfiguration encryption =
        EncryptionConfiguration.newBuilder().setKmsKeyName(kmsKeyName).build();
    updateTableCMEK(datasetName, tableName, encryption);
  }

  public static void updateTableCMEK(
      String datasetName, String tableName, EncryptionConfiguration encryption) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      Table table = bigquery.getTable(TableId.of(datasetName, tableName));
      bigquery.update(table.toBuilder().setEncryptionConfiguration(encryption).build());
      System.out.println("Table cmek updated successfully");
    } catch (BigQueryException e) {
      System.out.println("Table cmek was not updated. \n" + e.toString());
    }
  }
}

Python

Altere a chave de encriptação gerida pelo cliente de uma tabela alterando a propriedade Table.encryption_configuration para um novo objeto EncryptionConfiguration e atualize a tabela.

Antes de experimentar este exemplo, siga as Pythoninstruções de configuração no início rápido do BigQuery com bibliotecas cliente. Para mais informações, consulte a API Python BigQuery documentação de referência.

Para se autenticar no BigQuery, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para bibliotecas de cliente.

# 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

Predefina uma chave do conjunto de dados

Pode definir uma chave do Cloud KMS predefinida ao nível do conjunto de dados que se aplica a todas as tabelas criadas recentemente no conjunto de dados, a menos que seja especificada uma chave do Cloud KMS diferente quando criar a tabela. A chave predefinida não se aplica a tabelas existentes. A alteração da chave predefinida não modifica nenhuma tabela existente e aplica-se apenas a novas tabelas criadas após a alteração.

Pode aplicar, alterar ou remover uma chave predefinida do conjunto de dados

• Especificando a chave predefinida no campo EncryptionConfiguration.kmsKeyName quando chama os métodos datasets.insert ou datasets.patch

• especificando a chave predefinida na flag --default_kms_key quando executar o comando bq mk --dataset.

  bq mk \
  --default_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
  --dataset DATASET_ID
  

  bq update \
  --default_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
  --dataset DATASET_ID
  

Nota: num conjunto de dados ao qual foi aplicada uma chave do Cloud KMS predefinida, não é possível encriptar novas tabelas com uma chave que não seja uma chave de encriptação gerida pelo cliente. Ou seja, se o conjunto de dados tiver uma chave do Cloud KMS predefinida, não pode usar uma chave de encriptação não gerida pelo cliente para encriptar novas tabelas no conjunto de dados.

Defina uma chave predefinida do projeto

Pode definir chaves do Cloud KMS predefinidas ao nível do projeto que se aplicam a todos os resultados das consultas e tabelas criadas recentemente no projeto para essa localização, a menos que especifique uma chave do Cloud KMS diferente. A chave predefinida não se aplica a tabelas existentes. A alteração da chave predefinida não modifica nenhuma tabela existente e aplica-se apenas a novas tabelas criadas após a alteração.

SQL

Use a declaração ALTER PROJECT SET OPTIONS para atualizar o campo default_kms_key_name de um projeto. Pode encontrar o nome do recurso da chave na página do Cloud KMS.

1. Na Google Cloud consola, aceda à página BigQuery.

   Aceda ao BigQuery

2. No editor de consultas, introduza a seguinte declaração:

   ALTER PROJECT PROJECT_ID
   SET OPTIONS (
     `region-LOCATION.default_kms_key_name`
       = 'projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY');

3. Clique em Executar.

Para mais informações sobre como executar consultas, consulte o artigo Execute uma consulta interativa.

bq

Pode usar o comando bq para executar uma declaração ALTER PROJECT SET OPTIONS para atualizar o campo default_kms_key_name de um projeto:

bq query --nouse_legacy_sql \
  'ALTER PROJECT PROJECT_ID
  SET OPTIONS (
  `region-LOCATION.default_kms_key_name`
    ="projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY");'

Use a CMEK para proteger os modelos do BigQuery ML

O BigQuery ML é compatível com a CMEK. Juntamente com a encriptação predefinida fornecida pelo BigQuery, pode usar as suas próprias chaves do Cloud Key Management Service para encriptar modelos de aprendizagem automática, incluindo modelos do TensorFlow importados.

Crie um modelo encriptado com uma chave do Cloud KMS

Para criar um modelo encriptado, use a declaração CREATE MODEL e especifique KMS_KEY_NAME nas opções de preparação:

    CREATE MODEL my_dataset.my_model
    OPTIONS(
      model_type='linear_reg',
      input_label_cols=['your_label'],
      kms_key_name='projects/my_project/locations/my_location/keyRings/my_ring/cryptoKeys/my_key')
    AS SELECT * FROM my_dataset.my_data

A mesma sintaxe também se aplica a modelos do TensorFlow importados:

    CREATE MODEL my_dataset.my_model
    OPTIONS(
      model_type='tensorflow',
      path='gs://bucket/path/to/saved_model/*',
      kms_key_name='projects/my_project/locations/my_location/keyRings/my_ring/cryptoKeys/my_key')
    AS SELECT * FROM my_dataset.my_data

Limitações

As chaves de encriptação geridas pelo cliente têm as seguintes restrições quando encriptam modelos de aprendizagem automática:

• As chaves CMEK da região Global não são suportadas para os seguintes tipos de modelos:

  • DNN
  • Wide-and-Deep
  • Autoencoder
  • Árvore otimizada

• As chaves CMEK de região e as chaves CMEK multirregião, por exemplo, EU ou US, não são suportadas quando cria os seguintes tipos de modelos:Global

  • Modelos do AutoML Tables

• As chaves CMEK não são suportadas para modelos remotos:

  • Modelos remotos em vez de modelos integrados do Vertex AI
  • Modelos remotos em modelos alojados do Vertex AI
  • Modelos remotos através dos serviços de IA na nuvem

Altere um modelo da encriptação predefinida para a proteção do Cloud KMS

Pode usar o comando bq cp com o sinalizador --destination_kms_key para copiar um modelo protegido pela encriptação predefinida para um novo modelo protegido pelo Cloud KMS. Em alternativa, pode usar o comando bq cp com a flag -f para substituir um modelo protegido pela encriptação predefinida e atualizá-lo para usar a proteção do Cloud KMS. A flag --destination_kms_key especifica o ID de recurso da chave a usar com o modelo de destino.

Para copiar um modelo com encriptação predefinida para um novo modelo com proteção do Cloud KMS:

bq cp \
--destination_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
SOURCE_DATASET_ID.SOURCE_MODEL_ID DESTINATION_DATASET_ID.DESTINATION_MODEL_ID

Para substituir um modelo que tem a encriptação predefinida pelo mesmo modelo com a proteção do Cloud KMS:

bq cp -f \
--destination_kms_key projects/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
DATASET_ID.MODEL_ID DATASET_ID.MODEL_ID

Para alterar um modelo da proteção do Cloud KMS para a encriptação predefinida:

bq cp -f \
DATASET_ID.MODEL_ID DATASET_ID.MODEL_ID

Para mais informações sobre a ferramenta de linhas de comando bq, consulte o artigo Usar a ferramenta de linhas de comando bq.

Determine se um modelo está protegido pelo Cloud KMS

Use o comando bq show para ver se um modelo está protegido pela chave do Cloud KMS. A chave de encriptação encontra-se no campo kmsKeyName.

bq show -m my_dataset.my_model

Também pode usar a Google Cloud consola para encontrar a chave do Cloud KMS para um modelo encriptado. As informações da CMEK encontram-se no campo Chave gerida pelo cliente na secção Detalhes do modelo do painel Detalhes do modelo.

Altere a chave do Cloud KMS para um modelo encriptado

Use o comando bq update com a flag --destination_kms_key para alterar a chave de um modelo protegido pelo Cloud KMS:

bq update --destination_kms_key \
projects/my_project/locations/my_location/keyRings/my_ring/cryptoKeys/my_key \
-t my_dataset.my_model

Use as chaves do projeto ou do conjunto de dados predefinidas

Se tiver uma chave do Cloud KMS predefinida definida ao nível do projeto ou do conjunto de dados, o BigQuery ML usa automaticamente esta chave quando cria modelos. Use a declaração CREATE MODEL para especificar uma chave diferente para encriptar o modelo se não quiser usar a chave predefinida.

Use funções do BigQuery ML com modelos encriptados

Pode usar todas as funções do BigQuery ML com um modelo encriptado sem especificar uma chave de encriptação.

Use a CMEK para proteger a API BigQuery Connection

Para ligações do Cloud SQL, pode proteger as credenciais da API BigQuery Connection através da CMEK.

Para mais informações sobre como criar uma ligação protegida por CMEK, consulte o artigo Crie ligações do Cloud SQL.

Remova o acesso do BigQuery à chave do Cloud KMS

Pode remover o acesso do BigQuery à chave do Cloud KMS em qualquer altura, revogando a autorização de gestão de identidade e acesso (IAM) para essa chave.

Nota: se remover o acesso do BigQuery a uma chave, esta alteração não ocorre instantaneamente, mas sim no prazo de uma hora, enquanto a alteração da autorização do IAM é propagada. Se estiver a executar uma consulta no momento em que o limite é atingido, a consulta é concluída, mas os resultados podem não ser visíveis.

Se o BigQuery perder o acesso à chave do Cloud KMS, a experiência do utilizador pode sofrer um impacto significativo e podem ocorrer perdas de dados:

• Já não é possível aceder aos dados nestas tabelas protegidas pela CMEK: query, cp, extract e tabledata.list vão falhar.

• Não é possível adicionar novos dados a estas tabelas protegidas pela CMEK.

• Depois de o acesso ser novamente concedido, o desempenho das consultas a estas tabelas pode ser degradado durante vários dias.

Controle a utilização da CMEK com a política da organização

O BigQuery integra-se com as restrições da política da organização da CMEK para lhe permitir especificar os requisitos de conformidade da encriptação para os recursos do BigQuery na sua organização.

Esta integração permite-lhe fazer o seguinte:

• Exigir CMEKs para todos os recursos do BigQuery num projeto.

• Restrinja as chaves do Cloud KMS que podem ser usadas para proteger recursos num projeto.

Exija CMEKs para todos os recursos

Uma política comum é exigir que as CMEKs sejam usadas para proteger todos os recursos num conjunto específico de projetos. Pode usar a restrição constraints/gcp.restrictNonCmekServices para aplicar esta política no BigQuery.

Se estiver definida, esta política da organização faz com que todos os pedidos de criação de recursos sem uma chave do Cloud KMS especificada falhem.

Depois de definir esta política, aplica-se apenas aos novos recursos no projeto. Todos os recursos existentes sem chaves do Cloud KMS definidas continuam a existir e são acessíveis sem problemas.

Nota: esta restrição aplica-se apenas a recursos que contêm dados. Os recursos que apenas usam a respetiva chave do Cloud KMS especificada como predefinição para novos recursos (por exemplo, conjuntos de dados e configuração do projeto) podem continuar a ser criados ou atualizados sem uma chave do Cloud KMS.

Consola

1. Abra a página Políticas da organização.

   Aceda às políticas da organização

2. No campo Filtro, introduza constraints/gcp.restrictNonCmekServices e, de seguida, clique em Restrinja os serviços que podem criar recursos sem CMEK.

3. Clique em Editar.

4. Selecione Personalizar, selecione Substituir e, de seguida, clique em Adicionar regra.

5. Selecione Personalizado e, de seguida, clique em Recusar.

6. No campo Valor personalizado, introduza is:bigquery.googleapis.com.

7. Clique em Concluído e, de seguida, clique em Guardar.

gcloud

  gcloud resource-manager org-policies --project=PROJECT_ID \
    deny gcp.restrictNonCmekServices is:bigquery.googleapis.com

Para verificar se a política foi aplicada com êxito, pode tentar criar uma tabela no projeto. O processo falha, a menos que especifique uma chave do Cloud KMS.

Esta política também se aplica a tabelas de resultados de consultas no projeto. Pode especificar uma chave predefinida do projeto para que os utilizadores não tenham de especificar manualmente uma chave sempre que executam uma consulta no projeto.

Restrinja as chaves do Cloud KMS para um projeto do BigQuery

Pode usar a restrição constraints/gcp.restrictCmekCryptoKeyProjects para restringir as chaves do Cloud KMS que pode usar para proteger um recurso num projeto do BigQuery.

Pode especificar uma regra, por exemplo, "Para todos os recursos do BigQuery em projects/my-company-data-project, as chaves do Cloud KMS usadas neste projeto têm de ser provenientes de projects/my-company-central-keys OU projects/team-specific-keys".

Consola

1. Abra a página Políticas da organização.

   Aceda às políticas da organização

2. No campo Filtro, introduza constraints/gcp.restrictCmekCryptoKeyProjects e, de seguida, clique em Restrinja os projetos que podem fornecer CryptoKeys do KMS para CMEK.

3. Clique em Editar.

4. Selecione Personalizar, selecione Substituir e, de seguida, clique em Adicionar regra.

5. Selecione Personalizado e, de seguida, clique em Permitir.

6. No campo Valor personalizado, introduza under:projects/<var>KMS_PROJECT_ID</var>.

7. Clique em Concluído e, de seguida, clique em Guardar.

gcloud

  gcloud resource-manager org-policies --project=PROJECT_ID \
    allow gcp.restrictCmekCryptoKeyProjects under:projects/KMS_PROJECT_ID

Para verificar se a política foi aplicada com êxito, pode tentar criar uma tabela com uma chave do Cloud KMS de um projeto diferente. O processo vai falhar.

Limitações das políticas da organização

Existem limitações associadas à definição de uma política da organização.

Atraso de propagação

Depois de definir ou atualizar uma política da organização, a nova política pode demorar até 15 minutos a entrar em vigor. O BigQuery armazena em cache as políticas para não afetar negativamente a latência de criação de consultas e tabelas.

Autorizações necessárias para definir uma política da organização

A autorização para definir ou atualizar a política da organização pode ser difícil de adquirir para fins de teste. Tem de ter a função de administrador da política da organização, que só pode ser concedida ao nível da organização (em vez do nível do projeto ou da pasta).

Embora a função tenha de ser concedida ao nível da organização, ainda é possível especificar uma política que se aplica apenas a um projeto ou uma pasta específicos.

Impacto da rotação de chaves do Cloud KMS

O BigQuery não alterna automaticamente uma chave de encriptação de tabela quando a chave do Cloud KMS associada à tabela é alternada. Todos os dados nas tabelas existentes continuam a ser protegidos pela versão da chave com a qual foram criados.

Todas as tabelas criadas recentemente usam a versão da chave principal no momento da respetiva criação.

Para atualizar uma tabela de modo a usar a versão mais recente da chave, atualize a tabela com a mesma chave do Cloud KMS. Esta atualização não verifica nenhuma política da organização. Apenas a atualização da chave verifica a política da organização.

Impacto na faturação do Cloud KMS

Quando cria ou trunca uma tabela protegida por CMEK, o BigQuery gera uma chave de encriptação de chaves intermédia que é, em seguida, encriptada com a chave do Cloud KMS especificada.

Para fins de faturação, isto significa que nem as suas chamadas para o Cloud KMS nem os respetivos custos associados são dimensionados com o tamanho da tabela. Para tabelas protegidas por CMEK, pode esperar uma chamada para o Cloud KMS cryptoKeys.encrypt para cada criação ou truncagem de tabelas e uma chamada para o Cloud KMS cryptoKeys.decrypt para cada tabela envolvida numa consulta. Ambos os métodos pertencem à categoria de Operações com chaves: criptográficas apresentadas nos Preços do Cloud KMS.

A leitura ou a escrita numa tabela protegida por CMEK invoca o Cloud KMS cryptoKeys.decrypt porque a chave intermédia tem de ser desencriptada.

Limitações

Acesso do BigQuery à chave do Cloud KMS

Uma chave do Cloud KMS é considerada disponível e acessível pelo BigQuery nas seguintes condições:

• A chave está ativada
• A conta de serviço do BigQuery tem autorizações de encriptação e desencriptação na chave

As secções seguintes descrevem o impacto nos inserções de streaming e nos dados inacessíveis a longo prazo quando uma chave está inacessível.

Impacto nos anúncios de inserção em streaming

A chave do Cloud KMS tem de estar disponível e acessível durante, pelo menos, 24 horas consecutivas no período de 48 horas após um pedido de inserção de streaming. Se a chave não estiver disponível e acessível, os dados transmitidos em fluxo podem não ser totalmente mantidos e podem ser perdidos. Para mais informações sobre inserções por stream, consulte o artigo Transmitir dados para o BigQuery.

Impacto nos dados inacessíveis a longo prazo

Uma vez que o BigQuery oferece armazenamento gerido, os dados inacessíveis a longo prazo não são compatíveis com a arquitetura do BigQuery. Se a chave do Cloud KMS de uma determinada tabela do BigQuery não estiver disponível e não for acessível durante 60 dias consecutivos, o BigQuery pode optar por eliminar a tabela e os respetivos dados associados. Pelo menos 7 dias antes da eliminação dos dados, o BigQuery envia um email para o endereço de email associado à conta de faturação.

Usar origens de dados externas

Se estiver a consultar dados armazenados numa origem de dados externa, como o Cloud Storage, que tenha dados encriptados com CMEK, a encriptação de dados é gerida pelo Cloud Storage. Por exemplo, as tabelas BigLake suportam dados encriptados com CMEK no Cloud Storage.

O BigQuery e as tabelas do BigLake não suportam chaves de encriptação fornecidas pelo cliente (CSEK).

Alternar entre a encriptação predefinida e a encriptação protegida por CMEK

Não pode alternar uma tabela no local entre encriptações predefinidas e encriptação CMEK. Para mudar a encriptação, copie a tabela com as informações de encriptação de destino definidas ou use uma consulta SELECT * para selecionar a tabela em si própria com a disposição WRITE_TRUNCATE.

Usar decoradores de tabelas

Se proteger uma tabela com o Cloud KMS e, em seguida, substituir os dados na tabela usando o valor WRITE_TRUNCATE para uma operação load, cp ou query, os decoradores de intervalo não funcionam no limite da alteração de encriptação. Pode continuar a usar os decoradores de tabelas, incluindo os decoradores de intervalos, para consultar os dados antes ou depois do limite, ou consultar a imagem instantânea num determinado momento.

Consultas de tabelas com carateres universais

Não é possível consultar tabelas protegidas por CMEK com um sufixo de carateres universais.

Suporte de scripts

Os scripts não podem definir tabelas de destino para operações CMEK.

Suporte de edições

O suporte de CMEK para o BigQuery só está disponível para o BigQuery Enterprise, o BigQuery Enterprise Plus e o BigQuery On-Demand.

Nota: é permitido usar a CMEK para consultar dados num projeto do BigQuery a partir de um projeto que não suporta a CMEK. No entanto, o projeto que armazena os dados tem de usar uma edição do BigQuery compatível, e a respetiva conta de serviço tem de ter as autorizações da chave do Cloud KMS adequadas.

Suporte do BigQuery Studio

Os recursos de código do BigQuery Studio, incluindo consultas guardadas e blocos de notas, não suportam a CMEK.

Perguntas frequentes

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

Com as chaves de encriptação geridas pelo cliente, não é necessário especificar autorizações repetidamente. Desde que a conta de serviço do BigQuery tenha autorização para usar a chave do Cloud KMS para encriptar e desencriptar, qualquer pessoa com autorização para a tabela do BigQuery pode aceder aos dados, mesmo que não tenha acesso direto à chave do Cloud KMS.

Que conta de serviço é usada?

A conta de serviço do BigQuery associada ao Google Cloud projeto da tabela é usada para desencriptar os dados dessa tabela. As contas de serviço do BigQuery são únicas para cada projeto. Para uma tarefa que escreve dados numa tabela anónima protegida pelo Cloud KMS, é usada a conta de serviço do projeto da tarefa.

Por exemplo, considere três tabelas protegidas por 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

De que formas o BigQuery pode usar a minha chave do Cloud KMS?

O BigQuery usa a chave do KMS da nuvem para desencriptar dados em resposta a uma consulta do utilizador, por exemplo, tabledata.list ou jobs.insert.

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

Que bibliotecas de criptografia são usadas?

O BigQuery baseia-se no Cloud KMS para a funcionalidade CMEK. O Cloud KMS usa o Tink para a encriptação.

Como receber mais ajuda?

Se tiver perguntas que não estejam respondidas aqui, consulte o apoio técnico do BigQuery.

Resolução de problemas de erros

Segue-se uma descrição dos erros comuns e das mitigações recomendadas.

Erro	Recomendação
Conceda a função de encriptador/desencriptador de CryptoKey do Cloud KMS	A conta de serviço do BigQuery associada ao seu projeto não tem autorização IAM suficiente para operar na chave do Cloud KMS especificada. Siga as instruções no erro ou nesta documentação para conceder a autorização IAM adequada.
As definições de encriptação da tabela existentes não correspondem às definições de encriptação especificadas no pedido	Isto pode ocorrer em cenários em que a tabela de destino tem definições de encriptação que não correspondem às definições de encriptação no seu pedido. Como mitigação, use a disposição de escrita TRUNCATE para substituir a tabela ou especifique uma tabela de destino diferente.
Esta região não é suportada	A região da chave do Cloud KMS não corresponde à região do conjunto de dados do BigQuery da tabela de destino. Como mitigação, selecione uma chave numa região que corresponda ao seu conjunto de dados ou carregue-a num conjunto de dados que corresponda à região da chave.
O seu administrador requer que especifique uma chave de encriptação para consultas no projeto PROJECT_ID.	Uma política de organização impediu a criação de um recurso ou a execução de uma consulta. Para saber mais acerca desta política, consulte o artigo Exigir CMEKs para todos os recursos num projeto do BigQuery.
O seu administrador impede a utilização de chaves do KMS do projeto KMS_PROJECT_ID para proteger recursos no projeto PROJECT_ID.	Uma política de organização impediu a criação de um recurso ou a execução de uma consulta. Para saber mais acerca desta política, consulte o artigo Restrinja as chaves do Cloud KMS para um projeto do BigQuery.