Chiavi Cloud KMS gestite dal cliente

Nota: questa funzionalità potrebbe non essere disponibile quando utilizzi le prenotazioni create con alcune versioni di BigQuery. Per ulteriori informazioni su quali sono abilitate in ogni versione, consulta Introduzione alle Versioni di BigQuery.

Per impostazione predefinita, BigQuery cripta i contenuti archiviati inattivi. BigQuery gestisce e gestisce questa crittografia predefinita per te senza che tu debba fare altro. In primo luogo, i dati in un La tabella BigQuery è criptata usando una chiave di crittografia dei dati. Poi, le chiavi di crittografia dei dati sono criptate con chiavi di crittografia della chiave, ovvero nota come crittografia busta. Crittografia delle chiavi Le chiavi non criptano direttamente i tuoi dati, ma sono utilizzate per criptarli chiavi di crittografia utilizzate da Google per criptare i tuoi dati.

Se vuoi controllare personalmente la crittografia, puoi utilizzare le opzioni chiavi di crittografia (CMEK) per BigQuery. Invece di lasciare che sia Google a possedere le chiavi di crittografia della chiave che proteggono i tuoi dati, tu controlli e gestisci delle chiavi di crittografia delle chiavi in Cloud KMS. Questo documento fornisce su questa tecnica.

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

Prima di iniziare

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

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

• Decidi se eseguire BigQuery Cloud KMS nello stesso progetto Google Cloud o in diversi in modo programmatico a gestire i progetti. Ai fini della documentazione di esempio, viene utilizzata la seguente convenzione:

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

• BigQuery viene abilitato automaticamente nei nuovi progetti. Se utilizzando un progetto preesistente per eseguire BigQuery, abilitare l'API BigQuery.

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

Viene eseguita una chiamata di decriptazione utilizzando Cloud KMS una volta per query su Tabella criptata con CMEK. Per ulteriori informazioni, consulta i prezzi di Cloud KMS.

Specifica della crittografia

Le chiavi Cloud KMS utilizzate per proteggere i dati in BigQuery Chiavi AES-256. Queste chiavi vengono utilizzate come chiavi di crittografia delle chiavi BigQuery, in quanto criptano le chiavi di crittografia dei dati che crittografare i dati.

Creazione manuale o automatica delle chiavi

Puoi creare le chiavi CMEK manualmente o utilizzare Cloud KMS Autokey (anteprima). Autokey semplifica la creazione e gestire le chiavi CMEK automatizzando il provisioning e l'assegnazione. Con Autokey, non devi eseguire il provisioning di keyring, chiavi account in anticipo. Vengono invece generati on demand come parte Creazione di risorse BigQuery. Per ulteriori informazioni, consulta Panoramica di Autokey.

Crea manualmente keyring e chiave

Crea un keyring per il progetto Google Cloud che esegue Cloud KMS e una chiave come descritto Creazione di keyring e chiavi. Crea il keyring in un località che corrisponde a quella del set di dati BigQuery:

• Qualsiasi set di dati multiregionale deve utilizzare un keyring multiregionale di un località corrispondente. Ad esempio, un set di dati nella regione US deve essere protetto con un keyring della regione us e un set di dati nella regione EU deve essere protetta con un keyring 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 una chiave squilla dalla regione asia-northeast1.

• Non puoi utilizzare la regione global durante la configurazione di CMEK per in BigQuery nella console Google Cloud. Tuttavia, puoi usa la regione global durante la configurazione di CMEK per in BigQuery con lo strumento a riga di comando bq o GoogleSQL.

Per saperne di più sulle località supportate per BigQuery e Cloud KMS, vedi Località cloud.

Concedi l'autorizzazione per crittografia e decriptazione

Per proteggere i tuoi dati BigQuery con una chiave CMEK, concedi la Autorizzazione dell'account di servizio BigQuery per criptare e decriptare tramite chiave. La Autore crittografia/decrittografia CryptoKey Cloud KMS ruolo concede questa autorizzazione.

Assicurati che l'account di servizio sia stato creato, quindi utilizza il metodo Console Google Cloud per determinare il servizio BigQuery dell'account di servizio. Quindi, fornisci all'account di servizio il ruolo appropriato criptare e decriptarli con Cloud KMS.

Creazione del trigger dell'account di servizio

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

bq show --encryption_service_account --project_id=PROJECT_ID

Determinare l'ID account di servizio

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

[e-mail]

Le seguenti tecniche mostrano come determinare il valore di BigQuery per il tuo progetto.

Console

1. Vai alla pagina Dashboard nella console Google Cloud.

   Vai alla pagina Dashboard

2. Nella parte superiore della pagina, fai clic sull'elenco a discesa Seleziona da. Nella Seleziona il tuo progetto nella finestra Seleziona da visualizzata.

3. L'ID e il numero del progetto sono visualizzati nella dashboard del progetto Scheda Informazioni sul progetto:

   

4. Nella stringa seguente, sostituisci PROJECT_NUMBER con il tuo del progetto. La nuova stringa identifica i dati o l'ID account di servizio.

   [e-mail]
   

bq

Usa il comando bq show con il flag --encryption_service_account per determina l'ID account di servizio:

bq show --encryption_service_account

Il comando visualizza l'ID dell'account di servizio:

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

Assegna il ruolo Autore crittografia/decrittografia

Assegna l'autore della crittografia/decrittografia CryptoKey Cloud KMS role al L'account di servizio di sistema BigQuery che hai copiato appunti. Questo account ha il seguente formato:

[e-mail]

Console

1. Apri la pagina Chiavi di crittografia nella console Google Cloud.

   Aperto alla pagina Chiavi di crittografia

2. Fai clic sul nome del keyring che contiene la chiave.

3. Fai clic sulla casella di controllo della chiave di crittografia a cui vuoi aggiungere la chiave ruolo. Si apre la scheda Autorizzazioni.

4. Fai clic su Aggiungi membro.

5. Inserisci l'indirizzo email dell'account di servizio, [e-mail].

   • Se l'account di servizio è già nell'elenco dei membri, deve ruoli esistenti. Fai clic sull'elenco a discesa del ruolo corrente per Account di servizio [e-mail].

6. Fai clic sull'elenco a discesa per Seleziona un ruolo, fai clic su Cloud KMS e quindi fai clic sul ruolo Autore crittografia/decrittografia CryptoKey Cloud KMS.

7. Fai clic su Salva per applicare il ruolo al servizio [e-mail] .

gcloud

Puoi utilizzare Google Cloud CLI per assegnare il ruolo:

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

Sostituisci quanto segue:

• KMS_PROJECT_ID: l'ID del tuo account Google Cloud che esegue Cloud KMS
• PROJECT_NUMBER: il numero del progetto (non il progetto) ID) del progetto Google Cloud che esegue BigQuery
• KMS_KEY_LOCATION: il nome della località Chiave Cloud KMS
• KMS_KEY_RING: il nome del keyring della tua Chiave Cloud KMS
• KMS_KEY: il nome della chiave Chiave Cloud KMS

ID risorsa della chiave

L'ID risorsa per la chiave Cloud KMS è richiesto per l'utilizzo di CMEK, come mostrato negli esempi. Questa chiave è sensibile alle maiuscole e nel formato:

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

Nota: non puoi specificare un ID risorsa della chiave che includa il parametro /cryptoKeyVersions/. BigQuery utilizza sempre la versione della chiave contrassegnata come primary per proteggere una tabella quando viene creata.

Recupera l'ID risorsa della chiave

1. Apri la pagina Chiavi di crittografia nella console Google Cloud.

   Aperto alla pagina Chiavi di crittografia

2. Fai clic sul nome del keyring che contiene la chiave.

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

4. Fai clic su Copia nome risorsa. L'ID risorsa per la chiave viene copiato appunti. L'ID risorsa è chiamato anche nome risorsa.

Crea una tabella protetta da Cloud KMS

Per creare una tabella protetta da Cloud KMS:

Console

1. Apri la pagina BigQuery nella console Google Cloud.

   Vai alla pagina di BigQuery

2. Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.

3. Espandi Azioni e fai clic su Apri.

4. Nel riquadro dei dettagli, fai clic su Crea tabella. .

5. Nella pagina Crea tabella, inserisci le informazioni necessarie per crea una tabella vuota con una definizione di schema. Prima di fare clic su Crea tabella, imposta il tipo di crittografia e specifica Chiave Cloud KMS da utilizzare con la tabella:

   1. Fai clic su Opzioni avanzate.
   2. Fai clic su Chiave gestita dal cliente.
   3. Seleziona la chiave. Se la chiave che vuoi utilizzare non è in elenco, inserisci il ID risorsa della chiave.

6. Fai clic su Crea tabella.

SQL

Utilizza la Dichiarazione CREATE TABLE con l'opzione kms_key_name:

1. Nella console Google Cloud, vai alla pagina BigQuery.

   Vai a BigQuery

2. Nell'editor query, inserisci la seguente istruzione:

   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. Fai clic su Esegui.

Per ulteriori informazioni su come eseguire le query, vedi Eseguire una query interattiva.

bq

Puoi utilizzare lo strumento a riga di comando bq con il flag --destination_kms_key per creare la tabella. Il flag --destination_kms_key specifica ID risorsa della chiave da utilizzare con la tabella.

Per creare una tabella vuota con uno schema:

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

Per creare una tabella da una query:

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"

Per ulteriori informazioni sullo strumento a riga di comando bq, vedi Utilizzo dello strumento a riga di comando bq.

Terraform

Utilizza la google_bigquery_table risorsa.

Per eseguire l'autenticazione in BigQuery, configura il valore predefinito dell'applicazione Credenziali. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

L'esempio seguente crea una tabella denominata mytable e utilizza anche google_kms_crypto_key e google_kms_key_ring per specificare Chiave Cloud Key Management Service per .

Per eseguire questo esempio, devi abilitare la funzione API Cloud Resource Manager e ai 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"
}

Per applicare la configurazione Terraform a un progetto Google Cloud, completa i passaggi nella le sezioni seguenti.

Prepara Cloud Shell

1. Avvia Cloud Shell.

2. Imposta il progetto Google Cloud predefinito dove vuoi applicare le configurazioni Terraform.

   Devi eseguire questo comando una sola volta per progetto e puoi eseguirlo in qualsiasi directory.

   export GOOGLE_CLOUD_PROJECT=PROJECT_ID

   Le variabili di ambiente vengono sostituite se imposti valori espliciti in Terraform di configurazione del deployment.

Prepara la directory

Ogni file di configurazione Terraform deve avere una directory (inoltre chiamato modulo principale).

1. In Cloud Shell, crea una directory e un nuovo all'interno di quella directory. Il nome del file deve contenere .tf, ad esempio main.tf. In questo tutorial, il file è denominato main.tf.

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

2. Se stai seguendo un tutorial, puoi copiare il codice campione in ogni sezione o passaggio.

   Copia il codice campione nel nuovo oggetto main.tf.

   Facoltativamente, copia il codice da GitHub. Opzione consigliata quando lo snippet Terraform fa parte di una soluzione end-to-end.

3. Esamina e modifica i parametri di esempio da applicare al tuo ambiente.
4. Salva le modifiche.
5. Inizializza Terraform. Devi eseguire questa operazione una sola volta per directory.

   terraform init

   Facoltativamente, per utilizzare la versione più recente del provider Google, includi -upgrade :

   terraform init -upgrade

Applica le modifiche

1. Rivedi la configurazione e verifica che le risorse che Terraform creerà o che l'aggiornamento soddisfi le tue aspettative:

   terraform plan

   Apporta le correzioni necessarie alla configurazione.

2. Applica la configurazione Terraform eseguendo questo comando e inserendo yes alla richiesta:

   terraform apply

   Attendi finché Terraform non visualizzi il messaggio "Applicazione completata!". .

3. Apri il progetto Google Cloud per visualizzare i risultati. Nella console Google Cloud, vai alle risorse nella UI per assicurarti create o aggiornate da Terraform.

Nota: gli esempi di Terraform in genere presuppongono che le API richieste siano nel tuo progetto Google Cloud.

Vai

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Python BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

Proteggi una nuova tabella con una chiave di crittografia gestita dal cliente impostando il valore Table.encryption_configuration in una proprietà EncryptionConfiguration prima di creare la tabella.

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

Query su una tabella protetta da una chiave Cloud KMS

Non è richiesta nessuna disposizione speciale per eseguire query su una tabella protetta da di Cloud KMS. BigQuery archivia il nome della chiave utilizzata cripta il contenuto della tabella e la utilizza quando una tabella protetta Viene eseguita una query su 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, purché BigQuery ha accesso alla chiave Cloud KMS utilizzata per criptare i contenuti della tabella.

Proteggi i risultati delle query con una chiave Cloud KMS

Per impostazione predefinita, i risultati delle query vengono archiviati in una tabella temporanea criptata con Chiave di proprietà di Google e gestita da Google. Se il progetto ha già un oggetto chiave predefinita, la chiave viene applicata alla tabella dei risultati della query temporanea (predefinita). Per utilizzare un chiave Cloud KMS per criptare i risultati della query, seleziona una delle le seguenti opzioni:

Console

1. Apri la pagina BigQuery nella console Google Cloud.

   Vai alla pagina di BigQuery

2. Fai clic su Crea nuova query.

3. Inserisci una query GoogleSQL valida nell'area di testo della query.

4. Fai clic su Altro, poi su Impostazioni query e infine su Opzioni avanzate.

5. Seleziona Crittografia gestita dal cliente.

6. Seleziona la chiave. Se la chiave che vuoi utilizzare non è in elenco, inserisci il ID risorsa della chiave.

7. Fai clic su Salva.

8. Fai clic su Esegui.

bq

Specifica il flag --destination_kms_key per proteggere la tabella di destinazione oppure (se utilizzi una tabella temporanea) con la chiave Cloud KMS. Il flag --destination_kms_key specifica ID risorsa della chiave da utilizzare con la destinazione tabella risultante.

Facoltativamente, usa il flag --destination_table per specificare la destinazione per i risultati della query. Se non viene utilizzato --destination_table, i risultati della query vengono vengono scritte in una tabella temporanea.

Per eseguire una query su una tabella:

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"

Per ulteriori informazioni sullo strumento a riga di comando bq, vedi Utilizzo dello strumento a riga di comando bq.

Vai

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

Proteggi una nuova tabella con una chiave di crittografia gestita dal cliente impostando il valore Table.encryption_configuration in una proprietà EncryptionConfiguration prima di creare la tabella.

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

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

Proteggi una nuova tabella con una chiave di crittografia gestita dal cliente impostando il valore Table.encryption_configuration in una proprietà EncryptionConfiguration prima di creare la tabella.

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

Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Python BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

Proteggi una tabella di destinazione delle query con una chiave di crittografia gestita dal cliente impostando QueryJobConfig.destination_encryption_configuration a un EncryptionConfiguration ed esegui la query.

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:

Console

Proteggi una tabella di destinazione del job di caricamento con una chiave di crittografia gestita dal cliente specificando la chiave quando carichi la tabella.

1. Apri la pagina BigQuery nella console Google Cloud.

   Vai alla pagina di BigQuery

2. Nel riquadro Spazio di esplorazione, espandi il progetto e seleziona un set di dati.

3. Nel riquadro dei dettagli, fai clic su Crea tabella.

4. Inserisci le opzioni che vuoi utilizzare per caricare la tabella, ma prima di Fai clic su Crea tabella e poi su Opzioni avanzate.

5. In Crittografia, seleziona Chiave gestita dal cliente.

6. Fai clic sull'elenco a discesa Seleziona una chiave gestita dal cliente e seleziona la chiave da utilizzare. Se non vedi alcun tasto disponibile, inserisci un ID risorsa della chiave.

   

7. Fai clic su Crea tabella.

bq

Proteggi una tabella di destinazione dei job di caricamento con una crittografia gestita dal cliente impostando il 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

Ad esempio:

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

Vai

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Python BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

Proteggi una tabella di destinazione dei job di caricamento con una crittografia gestita dal cliente impostando il parametro LoadJobConfig.destination_encryption_configuration in una proprietà EncryptionConfiguration e carica la tabella.

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

Inserimento di flussi in una tabella protetta da Cloud KMS

Puoi inserire flussi di dati nella tua tabella BigQuery protetta da CMEK senza specificare parametri aggiuntivi. Tieni presente che questi dati sono criptati la chiave Cloud KMS nel buffer e nella configurazione in ogni località. Prima di utilizzare lo streaming con una tabella CMEK, esamina i requisiti su di disponibilità e accessibilità delle chiavi.

Scopri di più sullo streaming all'indirizzo Flusso di dati con l'API BigQuery Storage Writer.

Cambia la crittografia di una tabella dalla crittografia predefinita alla protezione di Cloud KMS

bq

Puoi utilizzare il comando bq cp con il flag --destination_kms_key per copiare in una nuova tabella una tabella protetta per impostazione predefinita, oppure in la tabella originale, protetta da Cloud KMS. La Il flag --destination_kms_key specifica l'ID risorsa della chiave da utilizzare con la tabella di destinazione.

Per copiare una tabella con crittografia predefinita in una nuova tabella con 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

Se vuoi copiare una tabella con crittografia predefinita nella stessa tabella, con la protezione di 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 vuoi modificare una tabella dalla protezione di Cloud KMS a quella predefinita crittografia, copia il file eseguendo bq cp senza utilizzare Flag --destination_kms_key.

Per ulteriori informazioni sullo strumento a riga di comando bq, vedi Utilizzo dello strumento a riga di comando bq.

Vai

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Python BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

Proteggi la destinazione di una copia di una tabella con un servizio gestito dal cliente la chiave di crittografia impostando il valore QueryJobConfig.destination_encryption_configuration in una proprietà EncryptionConfiguration e copia la tabella.

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

Determina 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. Questo mostra le tabelle e le viste nel set di dati.

2. Fai clic sul nome della tabella.

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

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

   

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

Modifica la chiave Cloud KMS per una tabella BigQuery

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

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

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

Un vantaggio di update è che è più veloce di cp e ti consente di usare decoratori di tavole

SQL

Utilizza la Dichiarazione ALTER TABLE SET OPTIONS per aggiornare il campo kms_key_name di una tabella:

1. Nella console Google Cloud, vai alla pagina BigQuery.

   Vai a BigQuery

2. Nell'editor query, inserisci la seguente istruzione:

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

3. Fai clic su Esegui.

Per ulteriori informazioni su come eseguire le query, vedi Eseguire una query interattiva.

bq

Puoi utilizzare il comando bq cp con il flag --destination_kms_key per modificare la chiave di una tabella protetta da Cloud KMS. La Il flag --destination_kms_key specifica l'ID risorsa della chiave da utilizzare con la tabella.

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

Vai

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Go BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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

Prima di provare questo esempio, segui le istruzioni per la configurazione di Java nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Java BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

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

Cambia la chiave di crittografia gestita dal cliente per una tabella modificando il valore Table.encryption_configuration in una nuova proprietà EncryptionConfiguration e aggiorna la tabella.

Prima di provare questo esempio, segui le istruzioni per la configurazione di Python nel Guida rapida di BigQuery con librerie client. Per ulteriori informazioni, consulta API Python BigQuery documentazione di riferimento.

Per eseguire l'autenticazione su BigQuery, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per le librerie client.

# 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

Imposta una chiave predefinita per il set di dati

Puoi impostare una chiave Cloud KMS predefinita a livello di set di dati che si applichi a tutti tabelle create di recente all'interno del set di dati, a meno che un Cloud KMS diverso viene specificata quando crei la tabella. La chiave predefinita non si applica a 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

• che specifica la chiave predefinita EncryptionConfiguration.kmsKeyName quando chiami il metodo datasets.insert oppure Metodi datasets.patch

• specifica la chiave predefinita nel flag --default_kms_key quando esegui il comando 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: all'interno di un set di dati a cui è applicata una chiave Cloud KMS predefinita, impossibile criptare nuove tabelle con una chiave diversa da quella gestita dal cliente chiave di crittografia. Vale a dire, se il set di dati ha una chiave Cloud KMS predefinita, non puoi utilizzare una chiave di crittografia non gestita dal cliente per criptare nuove tabelle in del set di dati.

Imposta una chiave predefinita per il progetto

Puoi impostare chiavi Cloud KMS predefinite del progetto applicabili a tutti nei risultati della query e nelle nuove tabelle create nel progetto per quella località, a meno che devi specificare una chiave Cloud KMS diversa. La chiave predefinita non è applicabile alle tabelle esistenti. La modifica della chiave predefinita non modifica le tabelle esistenti e si applica solo alle nuove tabelle create dopo la modifica.

SQL

Utilizza la Dichiarazione ALTER PROJECT SET OPTIONS per aggiornare il campo default_kms_key_name di un progetto. Puoi trovare nome risorsa della chiave nella pagina Cloud KMS.

1. Nella console Google Cloud, vai alla pagina BigQuery.

   Vai a BigQuery

2. Nell'editor query, inserisci la seguente istruzione:

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

3. Fai clic su Esegui.

Per ulteriori informazioni su come eseguire le query, vedi Eseguire una query interattiva.

bq

Puoi utilizzare il comando bq per eseguire un Dichiarazione di ALTER PROJECT SET OPTIONS per aggiornare il campo default_kms_key_name di un progetto:

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

Utilizza 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 di machine learning, inclusi i modelli TensorFlow importati.

Crea un modello criptato con una chiave Cloud KMS

Per creare un modello criptato, utilizza Dichiarazione 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 restrizioni quando con la crittografia dei modelli di machine learning:

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

  • DNN
  • Ampio e profondo
  • Codificatore automatico
  • Albero potenziato

• Chiavi CMEK per regione Global e chiavi CMEK per più regioni, ad esempio EU o US non sono supportati durante la creazione Modelli AutoML Tables.

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 per impostazione predefinita la crittografia 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 da crittografia predefinita e aggiornalo per utilizzare Cloud KMS e la protezione dei dati. Il flag --destination_kms_key specifica ID risorsa della chiave da utilizzare con il modello di destinazione.

Per copiare un modello con crittografia predefinita in un nuovo modello che ha Protezione di 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

a sovrascrivere un modello con crittografia predefinita nello stesso modello. con la protezione di 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 cambiare un modello dalla protezione di Cloud KMS alla crittografia predefinita:

bq cp -f \
DATASET_ID.MODEL_ID DATASET_ID.MODEL_ID

Per ulteriori informazioni sullo strumento a riga di comando bq, vedi Utilizzo dello strumento a riga di comando bq.

Determina se un modello è protetto da Cloud KMS

Utilizza la Comando bq show per vedere se un modello è protetto dalla chiave Cloud KMS. La 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 il Cloud KMS chiave per un modello criptato. Le informazioni CMEK si trovano nella chiave gestita dal cliente nella sezione Dettagli modello del riquadro Dettagli del modello.

Modifica la chiave Cloud KMS per un modello criptato

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

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

Usa chiavi di progetto o set di dati predefinite

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

Utilizza le funzioni di BigQuery ML con modelli criptati

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

Usa CMEK per proteggere l'API BigQuery Connection

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

Per saperne di più su come creare una connessione protetta da CMEK, vedi Creare connessioni Cloud SQL.

Rimuovi l'accesso di BigQuery alla chiave Cloud KMS

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

Nota: se rimuovi l'accesso di BigQuery a una chiave, questa modifica non viene applicata immediatamente, ma entro un'ora mentre IAM la modifica delle autorizzazioni si propaga. Se esegui una query nel momento in cui completa comunque, ma i risultati potrebbero non essere visibili.

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

• Non è più possibile accedere ai dati in queste tabelle protette da CMEK: query, cp, extract e tabledata.list avranno esito negativo.

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

• Una volta concesso nuovamente l'accesso, le prestazioni delle query per queste tabelle può essere ridotto per diversi giorni.

Controlla l'utilizzo di CMEK con il criterio dell'organizzazione

BigQuery si integra con CMEK vincoli dei criteri dell'organizzazione che ti consente di specificare i requisiti di conformità della crittografia di risorse BigQuery nella tua organizzazione.

Questa integrazione ti consente di:

• Richiedono CMEK per tutte le risorse BigQuery in un progetto.

• Limita le chiavi Cloud KMS utilizzabili per proteggere le risorse in un progetto.

Richiedono CMEK per tutte le risorse

Un criterio comune è richiedere l'uso di CMEK per proteggere tutte le risorse in un un insieme specifico di progetti. Puoi utilizzare lo Vincolo di constraints/gcp.restrictNonCmekServices per applicare questo criterio in in BigQuery.

Se configurato, questo criterio dell'organizzazione causa tutte le richieste di creazione di risorse senza un che la chiave Cloud KMS specificata non abbia esito positivo.

Una volta impostato, il criterio viene applicato solo alle nuove risorse nel progetto. Qualsiasi e risorse esistenti senza chiavi Cloud KMS impostate continuano a esistere accessibile senza problemi.

Nota: questo vincolo si applica solo alle risorse che contengono dati. Risorse che utilizzano solo la chiave Cloud KMS specificata come predefinita per i nuovi di risorse (ad esempio set di dati e configurazione di progetti) possono essere ancora create aggiornato senza una chiave Cloud KMS.

Console

1. Apri la pagina Criteri dell'organizzazione.

   Vai a Criteri dell'organizzazione

2. Nel campo Filtro, inserisci constraints/gcp.restrictNonCmekServices, quindi fai clic su Limita i servizi che possono creare risorse senza CMEK.

3. Fai clic su Modifica.

4. Seleziona Personalizza, poi Sostituisci e fai clic su Aggiungi regola.

5. Seleziona Personalizzato e poi fai clic su Rifiuta.

6. Nel campo Valore personalizzato, inserisci is:bigquery.googleapis.com.

7. Fai clic su Fine e poi su Salva.

gcloud

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

Per verificare che il criterio venga applicato correttamente, puoi provare a creare una tabella nel progetto. Il processo non riesce a meno che non specifichi un Cloud KMS chiave.

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

Limita le chiavi Cloud KMS per un progetto BigQuery

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

Potresti specificare una regola, ad esempio "Per tutti gli account BigQuery risorse in projects/my-company-data-project, le chiavi Cloud KMS utilizzate questo progetto deve provenire da projects/my-company-central-keys OPPURE progetti/chiavi specifiche per i team."

Console

1. Apri la pagina Criteri dell'organizzazione.

   Vai a Criteri dell'organizzazione

2. Nel campo Filtro, inserisci constraints/gcp.restrictCmekCryptoKeyProjects, quindi fai clic su Limita i progetti che possono fornire CryptoKey KMS per CMEK.

3. Fai clic su Modifica.

4. Seleziona Personalizza, poi Sostituisci e fai clic su Aggiungi regola.

5. Seleziona Personalizzato e poi fai clic su Consenti.

6. Nel campo Valore personalizzato, inserisci under:projects/<var>KMS_PROJECT_ID</var>.

7. Fai clic su Fine e poi su Salva.

gcloud

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

Per verificare che il criterio venga 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 dei criteri dell'organizzazione

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

Ritardo di propagazione

Dopo aver configurato o aggiornato un criterio dell'organizzazione, potrebbero essere necessari fino a 15 minuti l'applicazione della nuova norma. BigQuery memorizza i criteri nella cache per non influire negativamente sulla latenza di creazione di query e tabelle.

Autorizzazioni richieste per impostare un criterio dell'organizzazione

L'autorizzazione per impostare o aggiornare il criterio dell'organizzazione potrebbe essere difficile da acquisire a fini di test. Devi disporre del Ruolo Amministratore criteri organizzazione, che possono essere concesse solo a livello di organizzazione (anziché a livello di progetto o a livello di cartella).

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

Impatto della rotazione della chiave Cloud KMS

BigQuery non ruota automaticamente una chiave di crittografia della tabella quando la chiave Cloud KMS associata alla tabella viene ruotata. Tutti i dati in le tabelle esistenti continuano a essere protette dalla versione della chiave con cui erano è stato creato.

Tutte le tabelle appena create utilizzano la versione della chiave primaria al momento della loro per la creazione di contenuti.

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

Impatto sulla fatturazione di Cloud KMS

Quando crei o tronchi una tabella protetta da CMEK, BigQuery una chiave intermedia di crittografia che viene quindi crittografata specificata dalla chiave Cloud KMS.

Ai fini della fatturazione, ciò significa che nessuna delle due chiamate a Cloud KMS né i relativi costi associati scalano con le dimensioni della tabella. Per le tabelle protette da CMEK, È prevista una chiamata a Cloud KMS cryptoKeys.encrypt per ogni creazione o troncamento di una tabella e una chiamata a Cloud KMS cryptoKeys.decrypt per ogni tabella coinvolta in una query. Entrambi questi metodi appartengono alla categoria Operazioni chiave: crittografia elencate in Prezzi di Cloud KMS.

Lettura o scrittura su chiamate di tabella protette da CMEK esistenti Cloud KMS cryptoKeys.decrypt perché la chiave intermedia deve essere decriptato.

Limitazioni

Accesso in BigQuery alla chiave Cloud KMS

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

• La chiave è attivata
• L'account di servizio BigQuery dispone della crittografia e della decriptazione le autorizzazioni sulla chiave

Le seguenti sezioni descrivono l'impatto sugli inserimenti di flussi di dati e sugli annunci a lungo termine dati inaccessibili quando una chiave è inaccessibile.

Impatto sull'inserimento di flussi di dati

La chiave Cloud KMS deve essere disponibile e accessibile per almeno 24 ore consecutive nel periodo di 48 ore successive a una richiesta di inserimento di flussi di dati. Se la chiave non è disponibile e non è accessibile, i dati trasmessi in flusso potrebbero non essere completamente persistenti e possono andare persi. Per ulteriori informazioni sull'inserimento di flussi di dati, consulta Flusso 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 è compatibile 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 per eliminare la tabella e i dati associati. Almeno 7 giorni prima della data vengono eliminati, BigQuery invia un'email all'indirizzo associati all'account di fatturazione.

Utilizzo di origini dati esterne

Se esegui query su dati archiviati in un'origine dati esterna come Cloud Storage, in cui è stata criptata con CMEK dati, la crittografia dei dati viene gestita da Cloud Storage. Ad esempio, le tabelle BigLake supportano i dati criptati con CMEK in di archiviazione ideale in Cloud Storage.

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

Passare dalla crittografia protetta da CMEK a quella predefinita e viceversa

Non puoi passare dalla crittografia predefinita a CMEK e passare da una tabella attiva all'altra la crittografia. Per cambiare crittografia, copia tabella con crittografia di destinazione un set di dati o utilizza una query SELECT * per selezionare la tabella WRITE_TRUNCATE.

Utilizzare i decoratori di tabelle

Se proteggi una tabella con Cloud KMS e poi sostituisci i dati nel tabella utilizzando il valore WRITE_TRUNCATE per load, cp o query dell'operazione, poi decoratori di gamma non funzionano oltre il limite di modifica della crittografia. Puoi comunque usare la tabella decoratori, compresi i decorator di intervalli, per eseguire query sui dati prima o dopo il limite o esegui una query sullo snapshot in un momento specifico.

Query tabella con caratteri jolly

Impossibile eseguire query su tabelle protette da CMEK con un carattere jolly suffisso.

Assistenza per le versioni

Il supporto CMEK per BigQuery è disponibile solo per BigQuery Enterprise Plus e BigQuery on demand. Clienti BigQuery con prenotazioni a costo fisso legacy prima di luglio 5, 2023, manterranno tutto il supporto esistente per CMEK nel livello Enterprise.

Assistenza per BigQuery Studio

Asset di codice di BigQuery Studio, incluse le query salvate e i notebook, non supportano CMEK.

Domande frequenti

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

Con le chiavi di crittografia gestite dal cliente, specificare ripetutamente le autorizzazioni non è obbligatorio. Se l'account di servizio BigQuery dispone dell'autorizzazione di utilizzare la chiave Cloud KMS per criptare e decriptare, chiunque disponga dell'autorizzazione alla tabella BigQuery possono accedere ai dati, anche se non hanno accesso diretto alla chiave Cloud KMS.

Quale account di servizio viene utilizzato?

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

Ad esempio, considera tre tabelle protette da CMEK: table1, table2 e table3. Per eseguire query sui dati di {project1.table1, project2.table2} con 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 quali modi BigQuery può utilizzare la mia chiave Cloud KMS?

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

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

Quali librerie di crittografia vengono utilizzate?

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

Come posso ricevere ulteriore assistenza?

In caso di domande a cui non trovi risposta qui, vedi Supporto BigQuery.

Risolvere gli errori

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

Errore	Consiglio
Concedi il ruolo Autore crittografia/decrittografia CryptoKey Cloud KMS	L'account di servizio BigQuery associato al progetto non dispone di autorizzazioni IAM sufficienti per eseguire operazioni specificata dalla chiave Cloud KMS. Segui le istruzioni nell'errore oppure in questa documentazione per concedere Autorizzazione IAM.
Le impostazioni di crittografia delle tabelle esistenti non corrispondono a quelle di crittografia specificato nella richiesta	Questo può verificarsi in scenari in cui la tabella di destinazione è criptata che non corrispondono alle impostazioni di crittografia nella tua richiesta. Come mitigazione, usa l'istruzione di scrittura TRUNCATE per sostituire la tabella, o specificare una tabella di destinazione diversa.
Questa regione non è supportata	La regione della chiave Cloud KMS non corrisponde a quella della Set di dati BigQuery della tabella di destinazione. Come mitigazione, seleziona una chiave in una regione che corrisponda al tuo set di dati o caricala in un set di dati che corrisponde alla regione della chiave.
L'amministratore richiede che tu specifichi una chiave di crittografia per le query nel progetto PROJECT_ID.	Un criterio dell'organizzazione ha impedito la creazione di una risorsa o l'esecuzione di una query. Per ulteriori informazioni su queste norme, consulta la sezione Richiesta di CMEK per tutte le risorse in un progetto BigQuery.
L'amministratore impedisce di utilizzare le chiavi KMS del progetto KMS_PROJECT_ID per proteggere le risorse nel progetto PROJECT_ID.	Un criterio dell'organizzazione ha impedito la creazione di un'istanza risorsa o eseguire una query. Per scoprire di più su queste norme, consulta Limita le chiavi Cloud KMS per un progetto BigQuery.