Chiavi Cloud KMS gestite dal cliente

Per impostazione predefinita, BigQuery cripta i contenuti archiviati at-rest. BigQuery gestisce questa crittografia predefinita per conto tuo senza che tu debba fare altro. Innanzitutto, i dati in una tabella BigQuery vengono criptati utilizzando una chiave di crittografia dei dati. Successivamente, queste chiavi di crittografia dei dati vengono criptate con chiavi di crittografia delle chiavi, un processo noto come crittografia envelope. Le chiavi di crittografia delle chiavi non criptano direttamente i tuoi dati, ma vengono utilizzate per criptare le chiavi di crittografia dei dati che Google utilizza per criptare i tuoi dati.

Se vuoi controllare personalmente la crittografia, puoi utilizzare le chiavi di crittografia gestite dal cliente (CMEK) per BigQuery. Anziché essere di proprietà di Google e gestire le chiavi di crittografia delle chiavi che proteggono i tuoi dati, controlli e gestisci le chiavi di crittografia delle chiavi in Cloud KMS. Questo documento fornisce dettagli sulla creazione manuale delle chiavi Cloud KMS per BigQuery.

Scopri di più sulle opzioni di crittografia su Google Cloud. Per informazioni specifiche su CMEK, inclusi vantaggi e limitazioni, consulta Chiavi di crittografia gestite dal cliente.

Prima di iniziare

• Tutti gli asset di dati che risiedono nello spazio di archiviazione gestito di BigQuery supportano CMEK. Tuttavia, se esegui query anche sui dati archiviati in un'origine dati esterna come Cloud Storage che contiene dati criptati con CMEK, la crittografia dei dati viene gestita da Cloud Storage. Ad esempio, le tabelle BigLake supportano i dati criptati con CMEK in Cloud Storage.

  BigQuery e le tabelle BigLake non supportano le chiavi di crittografia fornite dal cliente (CSEK).

• Decidi se eseguire BigQuery e Cloud KMS nello stesso progetto Google Cloud o in progetti diversi. Ai fini degli esempi di documentazione, viene utilizzata la seguente convenzione:

  • PROJECT_ID: l'ID progetto del progetto che esegue BigQuery
  • PROJECT_NUMBER: il numero di progetto del progetto che esegue BigQuery
  • KMS_PROJECT_ID: l'ID progetto del progetto che esegue Cloud KMS (anche se si tratta dello stesso progetto che esegue BigQuery)
  Per informazioni sugli ID progetto e sui numeri di progetto, consulta Identificazione dei progetti. Google Cloud

• BigQuery viene attivato automaticamente nei nuovi progetti. Se utilizzi un progetto preesistente per eseguire BigQuery, abilita l'API BigQuery.

• Per il progetto Google Cloud che esegue Cloud KMS, abilita l'API Cloud Key Management Service.

Una chiamata di decriptazione viene eseguita utilizzando Cloud KMS una volta per query a una tabella criptata con CMEK. Per maggiori informazioni, consulta la pagina Prezzi di Cloud KMS.

Specifica di crittografia

Le chiavi Cloud KMS utilizzate per proteggere i dati in BigQuery sono chiavi AES-256. Queste chiavi vengono utilizzate come chiavi di crittografia della chiave in BigQuery, in quanto criptano le chiavi di crittografia dei dati che criptano i tuoi dati.

Creazione manuale o automatica delle chiavi

Puoi creare le chiavi CMEK manualmente o utilizzare Cloud KMS Autokey. Autokey semplifica la creazione e la gestione delle chiavi CMEK automatizzando il provisioning e l'assegnazione. Con Autokey, non devi eseguire il provisioning di chiavi automatizzate, chiavi e service account in anticipo. Vengono invece generati on demand nell'ambito della creazione di risorse BigQuery. Per ulteriori informazioni, consulta la panoramica di Autokey.

Creare manualmente chiavi automatizzate e chiave

Per il progetto Google Cloud che esegue Cloud KMS, crea un keyring e una chiave come descritto in Creazione di keyring e chiavi. Crea il portachiavi in una posizione che corrisponda a quella del tuo set di dati BigQuery:

• Qualsiasi set di dati multiregionale deve utilizzare un portachiavi multiregionale proveniente da una località corrispondente. Ad esempio, un set di dati nella regione US deve essere protetto con un portachiavi della regione us e un set di dati nella regione EU deve essere protetto con un portachiavi della regione europe.

• I set di dati regionali devono utilizzare chiavi regionali corrispondenti. Ad esempio, un set di dati nella regione asia-northeast1 deve essere protetto con un portachiavi della regione asia-northeast1.

• Non puoi utilizzare la regione global quando configuri CMEK per BigQuery nella console Google Cloud . Tuttavia, puoi utilizzare la regione global quando configuri CMEK per BigQuery utilizzando lo strumento a riga di comando bq o GoogleSQL.

Per ulteriori informazioni sulle località supportate per BigQuery e Cloud KMS, consulta Località cloud.

Concedere l'autorizzazione di crittografia e decrittografia

Per proteggere i tuoi dati BigQuery con una chiave CMEK, concedi all'account di servizio BigQuery l'autorizzazione per criptare e decriptare utilizzando questa chiave. Il ruolo Cloud KMS CryptoKey Encrypter/Decrypter concede questa autorizzazione.

Assicurati che il account di servizio sia stato creato, quindi utilizza la consoleGoogle Cloud per determinare l'ID service account BigQuery. Successivamente, fornisci all'account di servizio il ruolo appropriato per criptare e decriptare utilizzando Cloud KMS.

Attiva la creazione del account di servizio

L'account di servizio BigQuery non viene creato inizialmente quando crei un progetto. Per attivare la creazione del service account, inserisci un comando che lo utilizzi, ad esempio il comando bq show --encryption_service_account o chiama il metodo API projects.getServiceAccount. Ad esempio:

bq show --encryption_service_account --project_id=PROJECT_ID

Determinare l'ID account di servizio

L'ID account di servizio BigQuery ha il seguente formato:

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

Le seguenti tecniche mostrano come determinare l'ID account di servizio BigQuery per il tuo progetto.

bq show --encryption_service_account

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

Assegnare il ruolo Crittografo/Decrittografo

Assegna il ruolo Autore crittografia/decrittografia CryptoKey Cloud KMS all'account di servizio di sistema BigQuery che hai copiato negli appunti. Questo account ha il seguente formato:

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

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

ID risorsa della chiave

Per l'utilizzo di CMEK è necessario l'ID risorsa per la chiave Cloud KMS, come mostrato negli esempi. Questa chiave è sensibile alle maiuscole e minuscole e ha il seguente formato:

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

Recupera l'ID risorsa della chiave

1. Apri la pagina Chiavi crittografiche nella console Google Cloud .

   Apri la pagina Chiavi crittografiche

2. Fai clic sul nome della chiave automatizzata che contiene la chiave.

3. Per la chiave di cui stai recuperando l'ID risorsa, fai clic su Altro more_vert.

4. Fai clic su Copia nome risorsa. L'ID risorsa della chiave viene copiato negli appunti. L'ID risorsa è noto anche come nome della risorsa.

Crea una tabella protetta da Cloud KMS

Per creare una tabella protetta da Cloud KMS:

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

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"

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

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
}

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());
    }
  }
}

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

Esegui una query su una tabella protetta da una chiave Cloud KMS

Non sono necessari accordi speciali per eseguire query su una tabella protetta da Cloud KMS. BigQuery archivia il nome della chiave utilizzata per criptare i contenuti della tabella e la utilizza quando viene eseguita una query su una tabella protetta da Cloud KMS.

Tutti gli strumenti esistenti, la console BigQuery e lo strumento a riga di comando bq vengono eseguiti allo stesso modo delle tabelle criptate per impostazione predefinita, a condizione che BigQuery abbia accesso alla chiave Cloud KMS utilizzata per criptare il contenuto della tabella.

Proteggere i risultati delle query con una chiave Cloud KMS

Per impostazione predefinita, i risultati della query vengono archiviati in una tabella temporanea criptata con un Google-owned and Google-managed encryption key. Se il progetto ha già una chiave predefinita, la chiave viene applicata alla tabella temporanea (predefinita) dei risultati della query. Per utilizzare una chiave Cloud KMS per criptare i risultati della query, seleziona una delle seguenti opzioni:

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"

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
}

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());
    }
  }
}

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

Carica una tabella protetta da Cloud KMS

Per caricare un file di dati in una tabella protetta da Cloud KMS:

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

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

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
}

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());
    }
  }
}

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

Trasmettere in streaming in una tabella protetta da Cloud KMS

Puoi trasmettere i dati in streaming nella tabella BigQuery protetta da CMEK senza specificare parametri aggiuntivi. Tieni presente che questi dati vengono criptati utilizzando la chiave Cloud KMS nel buffer e nella posizione finale. Prima di utilizzare lo streaming con una tabella CMEK, esamina i requisiti relativi alla disponibilità e all'accessibilità delle chiavi.

Scopri di più sullo streaming in Streaming di dati utilizzando l'API BigQuery Storage Write.

Cambia una tabella dalla crittografia predefinita alla protezione di 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

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

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
}

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());
    }
  }
}

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

Determinare se una tabella è protetta da Cloud KMS

1. Nella console Google Cloud , fai clic sulla freccia blu a sinistra del set di dati per espanderlo oppure fai doppio clic sul nome del set di dati. Vengono visualizzate le tabelle e le visualizzazioni nel set di dati.

2. Fai clic sul nome della tabella.

3. Fai clic su Dettagli. La pagina Dettagli tabella mostra la descrizione e le informazioni della tabella.

4. Se la tabella è protetta da Cloud KMS, il campo Chiave di crittografia gestita dal cliente mostra l'ID risorsa della chiave.

   

Per ciascuna delle chiavi che hai creato o che proteggono le tue tabelle, puoi vedere quali risorse protegge la chiave con il monitoraggio dell'utilizzo delle chiavi. Per ulteriori informazioni, vedi Visualizzare l'utilizzo delle chiavi.

Modificare la chiave Cloud KMS per una tabella BigQuery

Per modificare la chiave Cloud KMS di una tabella esistente protetta da CMEK, puoi eseguire una query ALTER TABLE, utilizzare l'API o lo strumento a riga di comando bq. Esistono due modi per modificare la chiave Cloud KMS utilizzando l'API e lo strumento a riga di comando bq: update o cp.

Se utilizzi update, puoi modificare la chiave Cloud KMS utilizzata per una tabella protetta da CMEK.

Se utilizzi cp, puoi modificare la chiave Cloud KMS utilizzata per una tabella protetta da CMEK, modificare una tabella dalla crittografia predefinita alla protezione CMEK o modificare una tabella dalla protezione CMEK alla crittografia predefinita.

Un vantaggio di update è che è più veloce di cp e ti consente di utilizzare decoratori di tabelle.

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

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
}

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());
    }
  }
}

# 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

Impostare una chiave predefinita del set di dati

Puoi impostare una chiave Cloud KMS predefinita a livello di set di dati che si applica a tutte le tabelle appena create all'interno del set di dati, a meno che non venga specificata una chiave Cloud KMS diversa quando crei la tabella. La chiave predefinita non si applica alle tabelle esistenti. La modifica della chiave predefinita non modifica le tabelle esistenti e si applica solo alle nuove tabelle create dopo la modifica.

Puoi applicare, modificare o rimuovere una chiave predefinita del set di dati

• specificando la chiave predefinita nel campo EncryptionConfiguration.kmsKeyName quando chiami i metodi datasets.insert o datasets.patch.

• specificando la chiave predefinita nel flag --default_kms_key quando esegui il 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
  

Impostare una chiave predefinita del progetto

Puoi impostare chiavi Cloud KMS predefinite per il progetto che si applicano a tutti i risultati delle query e alle tabelle appena create nel progetto per quella località, a meno che tu non specifichi una chiave Cloud KMS diversa. La chiave predefinita non si applica alle tabelle esistenti. La modifica della chiave predefinita non modifica le tabelle esistenti e si applica solo alle nuove tabelle create dopo la modifica.

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

Utilizzare CMEK per proteggere i modelli BigQuery ML

BigQuery ML supporta CMEK. Oltre alla crittografia predefinita fornita da BigQuery, puoi utilizzare le tue chiavi Cloud Key Management Service per criptare i modelli di machine learning, inclusi i modelli TensorFlow importati.

Crea un modello criptato con una chiave Cloud KMS

Per creare un modello criptato, utilizza l'istruzione CREATE MODEL e specifica KMS_KEY_NAME nelle opzioni di addestramento:

    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

La stessa sintassi si applica anche ai modelli TensorFlow importati:

    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

Limitazioni

Le chiavi di crittografia gestite dal cliente presentano le seguenti limitazioni durante la crittografia dei modelli di machine learning:

• Le chiavi CMEK della regione Global non sono supportate per i seguenti tipi di modelli:

  • DNN
  • Wide & Deep
  • Autoencoder
  • Modello boosted tree

• Le chiavi CMEK della regione Global e le chiavi CMEK multiregionali, ad esempio EU o US, non sono supportate durante la creazione dei seguenti tipi di modelli:

  • Modelli AutoML Tables

• Le chiavi CMEK non sono supportate per i modelli remoti:

  • Modelli remoti rispetto ai modelli integrati di Vertex AI
  • Modelli remoti rispetto ai modelli ospitati su Vertex AI
  • Modelli remoti sui servizi Cloud AI

Cambia un modello dalla crittografia predefinita alla protezione di Cloud KMS

Puoi utilizzare il comando bq cp con il flag --destination_kms_key per copiare un modello protetto dalla crittografia predefinita in un nuovo modello protetto da Cloud KMS. In alternativa, puoi utilizzare il comando bq cp con il flag -f per sovrascrivere un modello protetto dalla crittografia predefinita e aggiornarlo in modo che utilizzi la protezione Cloud KMS. Il flag --destination_kms_key specifica l'ID risorsa della chiave da utilizzare con il modello di destinazione.

Per copiare un modello con crittografia predefinita in un nuovo modello con protezione 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

Per sovrascrivere un modello con crittografia predefinita con lo stesso modello con protezione 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

Per modificare un modello dalla protezione Cloud KMS alla crittografia predefinita:

bq cp -f \
DATASET_ID.MODEL_ID DATASET_ID.MODEL_ID

Per saperne di più sullo strumento a riga di comando bq, consulta Utilizzo dello strumento a riga di comando bq.

Determinare se un modello è protetto da Cloud KMS

Utilizza il comando bq show per verificare se un modello è protetto dalla chiave Cloud KMS. La chiave di crittografia si trova nel campo kmsKeyName.

bq show -m my_dataset.my_model

Puoi anche utilizzare la console Google Cloud per trovare la chiave Cloud KMS per un modello criptato. Le informazioni sulla CMEK si trovano nel campo Chiave gestita dal cliente nella sezione Dettagli modello del riquadro Dettagli del modello.

Modificare la chiave Cloud KMS per un modello criptato

Utilizza il comando bq update con il flag --destination_kms_key per modificare la chiave di un modello protetto da Cloud KMS:

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

Utilizzare le chiavi predefinite di progetto o set di dati

Se hai impostato una chiave Cloud KMS predefinita a livello di progetto o set di dati, BigQuery ML la utilizza automaticamente durante la creazione dei modelli. Utilizza l'istruzione CREATE MODEL per specificare una chiave diversa per criptare il modello se non vuoi utilizzare la chiave predefinita.

Utilizzare le funzioni BigQuery ML con modelli criptati

Puoi utilizzare tutte le funzioni BigQuery ML con un modello criptato senza specificare una chiave di crittografia.

Utilizzare CMEK per proteggere l'API BigQuery Connection

Per le connessioni Cloud SQL, puoi proteggere le credenziali dell'API BigQuery Connection utilizzando CMEK.

Per ulteriori informazioni su come creare una connessione protetta da CMEK, consulta Creare connessioni Cloud SQL.

Rimuovere l'accesso di BigQuery alla chiave Cloud KMS

Puoi rimuovere l'accesso di BigQuery alla chiave Cloud KMS in qualsiasi momento revocando l'autorizzazione Identity and Access Management (IAM) per quella chiave.

Se BigQuery perde l'accesso alla chiave Cloud KMS, l'esperienza utente può risentirne in modo significativo e possono verificarsi perdite di dati:

• Non è più possibile accedere ai dati in queste tabelle protette da CMEK: query, cp, extract e tabledata.list non andranno a buon fine.

• Non è possibile aggiungere nuovi dati a queste tabelle protette da CMEK.

• Una volta ripristinato l'accesso, il rendimento delle query a queste tabelle potrebbe peggiorare per più giorni.

Controllare l'utilizzo di CMEK con i criteri dell'organizzazione

BigQuery si integra con i vincoli dei criteri dell'organizzazione della CMEK per consentirti di specificare i requisiti di conformità alla crittografia per le risorse BigQuery nella tua organizzazione.

Questa integrazione ti consente di:

• Richiedi chiavi CMEK per tutte le risorse BigQuery in un progetto.

• Limita le chiavi Cloud KMS che possono essere utilizzate per proteggere le risorse in un progetto.

Richiedi CMEK per tutte le risorse

Una policy comune consiste nel richiedere l'utilizzo di CMEK per proteggere tutte le risorse in un insieme specifico di progetti. Puoi utilizzare il vincolo constraints/gcp.restrictNonCmekServices per applicare questo criterio in BigQuery.

Se impostato, questo criterio dell'organizzazione causa l'esito negativo di tutte le richieste di creazione di risorse senza una chiave Cloud KMS specificata.

Dopo aver impostato questo criterio, questo si applica solo alle nuove risorse del progetto. Tutte le risorse esistenti senza chiavi Cloud KMS impostate continuano a esistere e sono accessibili senza problemi.

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

Per verificare che il criterio sia stato applicato correttamente, puoi provare a creare una tabella nel progetto. Il processo non va a buon fine a meno che tu non specifichi una chiave Cloud KMS.

Queste norme si applicano anche alle tabelle dei risultati delle query nel progetto. Puoi specificare una chiave predefinita del progetto in modo che gli utenti non debbano specificare manualmente una chiave ogni volta che eseguono una query nel progetto.

Limitare le chiavi Cloud KMS per un progetto BigQuery

Puoi utilizzare il vincolo constraints/gcp.restrictCmekCryptoKeyProjects per limitare le chiavi Cloud KMS che puoi utilizzare per proteggere una risorsa in un progetto BigQuery.

Puoi specificare una regola, ad esempio "Per tutte le risorse BigQuery in projects/my-company-data-project, le chiavi Cloud KMS utilizzate in questo progetto devono provenire da projects/my-company-central-keys O projects/team-specific-keys".

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

Per verificare che il criterio sia stato applicato correttamente, puoi provare a creare una tabella utilizzando una chiave Cloud KMS di un altro progetto. Il processo non andrà a buon fine.

Limitazioni delle policy dell'organizzazione

Esistono limitazioni associate all'impostazione di un criterio dell'organizzazione.

Ritardo di propagazione

Dopo aver impostato o aggiornato una norma dell'organizzazione, l'applicazione della nuova norma può richiedere fino a 15 minuti. BigQuery memorizza nella cache i criteri per non influire negativamente sulla latenza di creazione di query e tabelle.

Autorizzazioni richieste per impostare una policy dell'organizzazione

L'autorizzazione per impostare o aggiornare la policy dell'organizzazione potrebbe essere difficile da ottenere a scopo di test. Devi disporre del ruolo Amministratore criteri dell'organizzazione, che può essere concesso solo a livello di organizzazione (anziché a livello di progetto o cartella).

Sebbene il ruolo debba essere concesso a livello di organizzazione, è comunque possibile specificare un criterio che si applichi solo a un progetto o a una cartella specifici.

Impatto della rotazione della chiave Cloud KMS

BigQuery non ruota automaticamente la chiave di crittografia di una tabella quando viene ruotata la chiave Cloud KMS associata alla tabella. Tutti i dati nelle tabelle esistenti continuano a essere protetti dalla versione della chiave con cui sono stati creati.

Tutte le tabelle appena create utilizzano la versione della chiave primaria al momento della creazione.

Per aggiornare una tabella in modo che utilizzi la versione più recente della chiave, modificala in modo che utilizzi una chiave Cloud KMS diversa e poi ripristina quella originale.

Impatto sulla fatturazione di Cloud KMS

Quando crei o tronchi una tabella protetta da CMEK, BigQuery genera una chiave di crittografia intermedia che viene poi criptata con la chiave Cloud KMS specificata.

Ai fini della fatturazione, ciò significa che né le chiamate a Cloud KMS né i relativi costi aumentano in base alle dimensioni della tabella. Per le tabelle protette da CMEK, puoi prevedere una chiamata a Cloud KMS cryptoKeys.encrypt per ogni creazione o troncamento di tabella e una chiamata a Cloud KMS cryptoKeys.decrypt per ogni tabella coinvolta in una query. Questi metodi appartengono entrambi alla categoria Operazioni con le chiavi: crittografiche elencata in Prezzi di Cloud KMS.

La lettura o la scrittura in una tabella esistente protetta da CMEK richiama Cloud KMS cryptoKeys.decrypt perché la chiave intermedia deve essere decriptata.

Limitazioni

Accesso a BigQuery alla chiave Cloud KMS

Una chiave Cloud KMS è considerata disponibile e accessibile da BigQuery alle seguenti condizioni:

• La chiave è abilitata
• Il account di servizio BigQuery dispone delle autorizzazioni di crittografia e decrittografia sulla chiave

Le sezioni seguenti descrivono l'impatto sugli inserimenti in streaming e sui dati inaccessibili a lungo termine quando una chiave non è accessibile.

Impatto sugli inserimenti di flussi di dati

La chiave Cloud KMS deve essere disponibile e accessibile per almeno 24 ore consecutive nel periodo di 48 ore successivo a una richiesta di inserimento dello streaming. Se la chiave non è disponibile e accessibile, i dati in streaming potrebbero non essere completamente persistenti e potrebbero andare persi. Per ulteriori informazioni sugli inserimenti di flussi di dati, consulta la sezione Inserimento di flussi di dati in BigQuery.

Impatto sui dati inaccessibili a lungo termine

Poiché BigQuery fornisce spazio di archiviazione gestito, i dati inaccessibili a lungo termine non sono compatibili con l'architettura di BigQuery. Se la chiave Cloud KMS di una determinata tabella BigQuery non è disponibile e non è accessibile per 60 giorni consecutivi, BigQuery potrebbe scegliere di eliminare la tabella e i relativi dati. Almeno 7 giorni prima dell'eliminazione dei dati, BigQuery invia un'email all'indirizzo email associato all'account di fatturazione.

Utilizzo di origini dati esterne

Se esegui query sui dati archiviati in un'origine dati esterna come Cloud Storage con dati criptati con CMEK, la crittografia dei dati viene gestita da Cloud Storage. Ad esempio, le tabelle BigLake supportano i dati criptati con CMEK in Cloud Storage.

BigQuery e le tabelle BigLake non supportano le chiavi di crittografia fornite dal cliente (CSEK).

Passare dalla crittografia protetta da CMEK a quella predefinita

Non puoi scambiare una tabella in loco tra le crittografie predefinite e la crittografia CMEK. Per cambiare la crittografia, copia la tabella con le informazioni di crittografia di destinazione impostate o utilizza una query SELECT * per selezionare la tabella in se stessa con la disposizione WRITE_TRUNCATE.

Utilizzo dei decorator per tabelle

Se proteggi una tabella con Cloud KMS e poi sostituisci i dati nella tabella utilizzando il valore WRITE_TRUNCATE per un'operazione load, cp o query, i decoratori di intervallo non funzionano oltre il limite di modifica della crittografia. Puoi comunque utilizzare i decoratori di tabelle, inclusi i decoratori di intervalli, per eseguire query sui dati prima o dopo il limite oppure eseguire query sullo snapshot in un determinato momento.

Query sulle tabelle con caratteri jolly

Non è possibile eseguire query sulle tabelle protette da CMEK con un suffisso con caratteri jolly.

Supporto per gli script

Gli script non possono definire tabelle di destinazione per le operazioni CMEK.

Versioni supportate

Il supporto di CMEK per BigQuery è disponibile solo per BigQuery Enterprise, BigQuery Enterprise Plus e BigQuery On-Demand.

Supporto di BigQuery Studio

Gli asset di codice di BigQuery Studio, tra cui le query salvate e i blocchi note, non supportano CMEK.

Domande frequenti

Chi ha bisogno dell'autorizzazione per la chiave Cloud KMS?

Con le chiavi di crittografia gestite dal cliente, non è necessario specificare ripetutamente le autorizzazioni. Se il account di servizio BigQuery è autorizzato a utilizzare la chiave Cloud KMS per la crittografia e la decrittografia, chiunque abbia l'autorizzazione per la tabella BigQuery può accedere ai dati, anche se non ha accesso diretto alla chiave Cloud KMS.

Quale account di servizio viene utilizzato?

L'account di servizio BigQuery associato al progettoGoogle Cloud della tabella viene utilizzato per decriptare i dati della tabella. Gli account di servizio BigQuery sono univoci per ogni progetto. Per un job che scrive dati in una tabella anonima protetta da Cloud KMS, viene utilizzato il account di servizio del progetto del job.

Ad esempio, considera tre tabelle protette da CMEK: table1, table2 e table3. Per eseguire query sui dati da {project1.table1, project2.table2} con la tabella di destinazione {project3.table3}:

• Utilizza l'account di servizio project1 per project1.table1
• Utilizza l'account di servizio project2 per project2.table2
• Utilizza l'account di servizio project3 per project3.table3

In che modo BigQuery può utilizzare la mia chiave Cloud KMS?

BigQuery utilizza la chiave Cloud KMS per decriptare i dati in risposta a una query utente, ad esempio tabledata.list o jobs.insert.

BigQuery può anche utilizzare la chiave per le attività di manutenzione e ottimizzazione dell'archiviazione dei dati, come la conversione dei dati in un formato ottimizzato per la lettura.

Quali librerie di crittografia vengono utilizzate?

BigQuery si basa su Cloud KMS per la funzionalità CMEK. Cloud KMS utilizza Tink per la crittografia.

Come ricevere ulteriore assistenza?

Se hai domande a cui non è stata data risposta qui, consulta Assistenza BigQuery.

Risolvere gli errori

Di seguito sono descritti gli errori comuni e le mitigazioni consigliate.