Daten mit Cloud KMS-Schlüsseln schützen

BigQuery verschlüsselt standardmäßig inaktive Kundendaten. Diese Standardverschlüsselung wird von BigQuery vorgenommen und verwaltet. Zusätzliche Maßnahmen Ihrerseits sind nicht erforderlich. Zuerst werden Daten in einer BigQuery-Tabelle mit einem Datenverschlüsselungsschlüssel verschlüsselt. Dann werden diese Datenverschlüsselungsschlüssel mit Schlüsselverschlüsselungsschlüsseln verschlüsselt, was als Umschlagverschlüsselung bezeichnet wird. Schlüsselverschlüsselungsschlüssel verschlüsseln nicht direkt Ihre Daten, sondern die Datenverschlüsselungsschlüssel, mit denen Google Ihre Daten verschlüsselt. Weitere Informationen finden Sie unter Schlüsselverwaltung.

Wenn Sie die Verschlüsselung selbst steuern möchten, können Sie von Kunden verwaltete Verschlüsselungsschlüssel (Customer-Managed Encryption Keys, CMEK) für BigQuery verwenden. Statt es Google zu überlassen, können Sie so auch selbst über Cloud KMS die Schlüsselverschlüsselungsschlüssel, die Ihre Daten schützen, steuern und verwalten. Hier werden Details zum entsprechenden Verfahren beschrieben.

Weitere Informationen finden Sie unter Verschlüsselung inaktiver Daten.

Vorbereitung

1. Machen Sie sich mit Datasets, Tabellen und Abfragen vertraut.

2. Überlegen Sie sich, ob Sie BigQuery und Cloud KMS im selben Google Cloud-Projekt oder in unterschiedlichen Projekten ausführen möchten. Für die Beispiele gelten diese Konventionen:

   • PROJECT_ID ist die ID des Projekts, in dem BigQuery ausgeführt wird
   • PROJECT_NUMBER ist die Projektnummer des Projekts, in dem BigQuery ausgeführt wird
   • KMS_PROJECT_ID ist die ID des Projekts, in dem Cloud KMS ausgeführt wird (auch wenn es sich um dasselbe Projekt handelt, in dem BigQuery ausgeführt wird)
   Weitere Informationen zu Cloud-Projekt-IDs und -Projektnummern finden Sie unter Projekte identifizieren.

3. BigQuery ist in neuen Projekten automatisch aktiviert. Wenn Sie ein bereits bestehendes Projekt verwenden, um BigQuery auszuführen, müssen Sie die BigQuery-API aktivieren.

4. Für das Google Cloud-Projekt, in dem Cloud KMS ausgeführt wird, gilt:

   1. Cloud Key Management Service API aktivieren
   2. Erstellen Sie einen Schlüsselbund und einen Schlüssel, wie unter Schlüsselbunde und Schlüssel erstellen beschrieben. Erstellen Sie den Schlüsselbund an einem Standort, der dem Standort Ihres BigQuery-Datasets entspricht:
      • Für jedes multiregionale Dataset sollte ein multiregionaler Schlüsselbund aus einem übereinstimmenden Standort verwendet werden. Beispiel: Ein Dataset in der Region US sollte mit einem Schlüsselbund aus der Region us und ein Dataset in der Region EU mit einem Schlüsselbund aus der Region europe geschützt werden.
      • Für regionale Datasets sollten übereinstimmende regionale Schlüssel verwendet werden. Beispiel: Ein Dataset in der Region asia-northeast1 sollte mit einem Schlüsselbund aus der Region asia-northeast1 geschützt werden.
      • Die Region global wird für die Verwendung mit BigQuery nicht unterstützt.
      Weitere Informationen zu den unterstützten Standorten für BigQuery und Cloud KMS finden Sie unter Cloud-Standorte.

Verschlüsselungsvorgabe

Zum Schutz Ihrer Daten in BigQuery verwendet Cloud KMS AES-256-Schlüssel. Diese Schlüssel dienen in BigQuery als Schlüsselverschlüsselungsschlüssel, mit denen die Datenverschlüsselungsschlüssel verschlüsselt werden, die wiederum Ihre Daten verschlüsseln.

Berechtigungen zum Verschlüsseln und Entschlüsseln erteilen

Gewähren Sie dem BigQuery-Dienstkonto die Berechtigung zum Verschlüsseln und Entschlüsseln mit diesem Schlüssel, um Ihre BigQuery-Daten mit einem CMEK-Schlüssel zu schützen. Die Rolle Cloud KMS CryptoKey-Verschlüsseler/Entschlüsseler gewährt diese Berechtigung.

Ermitteln Sie über die Google Cloud Console die BigQuery-Dienstkonto-ID. Anschließend gewähren Sie dem Dienstkonto die entsprechende Rolle zum Verschlüsseln und Entschlüsseln mithilfe von Cloud KMS.

Dienstkonto-ID ermitteln

Die BigQuery-Dienstkonto-ID hat die folgende Form:

[e-mail]

Die folgenden Methoden zeigen, wie Sie die BigQuery-Dienstkonto-ID für Ihr Projekt ermitteln.

Console

1. Öffnen Sie in der Cloud Console die Seite Dashboard.

   Zur Seite "Dashboard"

2. Klicken Sie oben auf der Seite auf die Drop-down-Liste Auswählen aus. Wählen Sie im angezeigten Fenster Auswählen aus Ihr Projekt aus.

3. Die Projekt-ID und die Projektnummer werden auf der Dashboardkarte Projektinformationen des Projekts angezeigt:

   

4. Ersetzen Sie im folgenden String PROJECT_NUMBER durch Ihre Projektnummer. Der neue String identifiziert Ihre BigQuery-Dienstkonto-ID.

   [e-mail]
   

bq

Verwenden Sie den Befehl bq show mit dem Flag --encryption_service_account, um die Dienstkonto-ID zu ermitteln:

bq show --encryption_service_account

Der Befehl zeigt die Dienstkonto-ID an:

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

Rolle "Verschlüsseler/Entschlüsseler" zuweisen

Weisen Sie dem BigQuery-Systemdienstkonto, das Sie in die Zwischenablage kopiert haben, die Rolle "Cloud KMS Verschlüsseler/Entschlüsseler" zu. Dieses Konto hat das folgende Format:

[e-mail]

Console

1. Öffnen Sie in der Cloud Console die Seite Kryptografische Schlüssel.

   Zur Seite "Kryptografische Schlüssel"

2. Klicken Sie auf den Namen des Schlüsselbunds, der den Schlüssel enthält.

3. Klicken Sie auf das Kästchen für den Verschlüsselungsschlüssel, dem Sie die Rolle hinzufügen möchten. Der Tab Berechtigungen wird geöffnet.

4. Klicken Sie auf Mitglied hinzufügen.

5. Geben Sie die E-Mail-Adresse des Dienstkontos [e-mail] ein.

   • Wenn sich das Dienstkonto bereits in der Mitgliederliste befindet, enthält es Rollen. Klicken Sie auf die Drop-down-Liste der aktuellen Rolle des Dienstkontos [e-mail].

6. Klicken Sie auf die Drop-down-Liste für Rolle auswählen, dann auf Cloud KMS und anschließend auf die Rolle Cloud KMS CryptoKey-Verschlüsseler/Entschlüsseler.

7. Klicken Sie zum Anwenden dieser Rolle auf das Dienstkonto [e-mail] auf Speichern.

gcloud

Sie können das gcloud-Befehlszeilentool verwenden, um die Rolle zuzuweisen:

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

Dabei gilt:

• KMS_PROJECT_ID ist die ID Ihres Google Cloud-Projekts, in dem Cloud KMS ausgeführt wird.
• PROJECT_NUMBER ist die Projektnummer (nicht die Projekt-ID) des Cloud-Projekts, in dem BigQuery ausgeführt wird.
• KMS_KEY_LOCATION ist der Standortname Ihres Cloud KMS-Schlüssels.
• KMS_KEY_RING ist der Schlüsselbundname Ihres Cloud KMS-Schlüssels.
• KMS_KEY ist der Schlüsselname Ihres Cloud KMS-Schlüssels.

Schlüsselressourcen-ID

Wenn vom Kunden verwaltete Verschlüsselungsschlüssel verwendet werden, ist die Ressourcen-ID für den Cloud KMS-Schlüssel erforderlich, wie in den Beispielen veranschaulicht. Bei diesem Schlüssel ist die Groß-/Kleinschreibung zu beachten. Er hat das folgende Format:

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

Schlüsselressourcen-ID abrufen

1. Öffnen Sie in der Cloud Console die Seite Kryptografische Schlüssel.

   Zur Seite "Kryptografische Schlüssel"

2. Klicken Sie auf den Namen des Schlüsselbunds, der den Schlüssel enthält.

3. Klicken Sie für den Schlüssel, dessen Ressourcen-ID Sie abrufen, auf das Dreipunktmenü.

4. Klicken Sie auf Ressourcen-ID kopieren. Die Ressourcen-ID für den Schlüssel wird in die Zwischenablage kopiert.

Durch Cloud KMS geschützte Tabelle erstellen

Durch Cloud KMS geschützte leere Tabelle erstellen

So erstellen Sie eine Tabelle, die durch Cloud KMS geschützt ist:

Console

1. Rufen Sie in der Cloud Console die BigQuery-Web-UI auf.
   Zur BigQuery-Web-UI

2. Maximieren Sie im Navigationsbereich im Abschnitt Ressourcen Ihr Projekt und wählen Sie ein Dataset aus.

3. Klicken Sie auf Tabelle erstellen.

4. Geben Sie auf der Seite Tabelle erstellen die erforderlichen Informationen ein, um eine leere Tabelle mit einer Schemadefinition zu erstellen. Bevor Sie auf Tabelle erstellen klicken, müssen Sie den Verschlüsselungstyp festlegen und den Cloud KMS-Schlüssel zur Verwendung mit der Tabelle angeben:

   1. Klicken Sie auf Erweiterte Optionen.
   2. Klicken Sie auf Vom Kunden verwalteter Schlüssel.
   3. Wählen Sie den Schlüssel aus. Wenn der Schlüssel, den Sie verwenden möchten, nicht aufgeführt ist, geben Sie die Ressourcen-ID für den Schlüssel ein.

5. Klicken Sie auf Tabelle erstellen.

bq

Sie können das bq-Befehlszeilentool mit dem Flag --destination_kms_key verwenden, um die Tabelle zu erstellen. Das Flag --destination_kms_key gibt die Ressourcen-ID des Schlüssels an, der mit der Tabelle verwendet werden soll.

So erstellen Sie eine leere Tabelle mit einem Schema:

bq mk --schema name:string,value:integer -t \
--destination_kms_key projects/PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
mydataset.newtable

Alternativ können Sie eine DDL-Anweisung verwenden:

bq query --use_legacy_sql=false "
  CREATE TABLE mydataset.newtable (name STRING, value INT64)
  OPTIONS(
    kms_key_name='projects/PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY'
  )
"

So erstellen Sie eine Tabelle aus einer Abfrage:

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

Weitere Informationen zum bq-Befehlszeilentool finden Sie unter bq-Befehlszeilentool verwenden.

Go

Auf GitHub ansehen

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

Auf GitHub ansehen

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

Schützen Sie eine neue Tabelle mit einem vom Kunden verwalteten Verschlüsselungsschlüssel. Legen Sie dazu das Attribut Table.encryption_configuration auf ein EncryptionConfiguration-Objekt fest, bevor Sie die Tabelle erstellen.

Auf GitHub ansehen Feedback

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

table_ref = client.dataset(dataset_id).table("my_table")
table = bigquery.Table(table_ref)

# Set the encryption key to use for the table.
# TODO: Replace this key with a key you have created in Cloud KMS.
kms_key_name = "projects/{}/locations/{}/keyRings/{}/cryptoKeys/{}".format(
    "cloud-samples-tests", "us", "test", "test"
)
table.encryption_configuration = bigquery.EncryptionConfiguration(
    kms_key_name=kms_key_name
)

table = client.create_table(table)  # API request

assert table.encryption_configuration.kms_key_name == kms_key_name

Durch Cloud KMS-Schlüssel geschützte Tabelle abfragen

Für die Abfrage einer durch Cloud KMS geschützten Tabelle sind keine besonderen Vorkehrungen erforderlich. Der Name des zum Verschlüsseln des Tabelleninhalts verwendeten Schlüssels wird in BigQuery gespeichert. Dieser Schlüssel wird anschließend bei der Abfrage einer durch Cloud KMS geschützten Tabelle verwendet.

Alle vorhandenen Tools, die BigQuery-Konsole und das bq-Befehlszeilentool werden genauso wie mit standardmäßig verschlüsselte Tabellen ausgeführt, sofern BigQuery Zugriff auf den Cloud KMS-Schlüssel hat, mit dem der Tabelleninhalt verschlüsselt wird.

Abfrageergebnisse mit Cloud KMS-Schlüssel schützen

Console

1. Rufen Sie in der Cloud Console die BigQuery-Web-UI auf.
   Zur BigQuery-Web-UI

2. Klicken Sie auf Neue Abfrage erstellen.

3. Geben Sie eine gültige BigQuery SQL-Abfrage in den Abfragetextbereich ein.

4. Klicken Sie auf Mehr, dann auf Abfrageeinstellungen und dann auf Erweiterte Optionen.

5. Wählen Sie Vom Kunden verwaltete Verschlüsselung aus.

6. Wählen Sie den Schlüssel aus. Wenn der Schlüssel, den Sie verwenden möchten, nicht aufgeführt ist, geben Sie die Ressourcen-ID für den Schlüssel ein.

7. Klicken Sie auf Speichern.

8. Klicken Sie auf Ausführen.

bq

Geben Sie das Flag --destination_kms_key an, um die Zieltabelle oder bei Verwendung einer temporären Tabelle die Abfrageergebnisse mit Ihrem Cloud KMS-Schlüssel zu schützen. Das Flag --destination_kms_key gibt die Ressourcen-ID des Schlüssels an, der mit der Ziel- oder Ergebnistabelle verwendet werden soll.

Sie können optional mit dem Flag --destination_table die Zieltabelle für die Abfrageergebnisse angeben. Ohne Angabe von --destination_table werden die Abfrageergebnisse in eine temporäre Tabelle geschrieben.

So fragen Sie eine Tabelle ab:

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

Weitere Informationen zum bq-Befehlszeilentool finden Sie unter bq-Befehlszeilentool verwenden.

Go

Auf GitHub ansehen

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

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Java in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Java API.

Auf GitHub ansehen Feedback

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

samples/client_query_destination_table_cmek.py

Auf GitHub ansehen Feedback

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

Durch Cloud KMS geschützte Tabelle laden

So laden Sie eine Datendatei in eine Tabelle, die durch Cloud KMS geschützt ist:

Console

Schützen Sie eine Zieltabelle für Ladejobs mit einem vom Kunden verwalteten Verschlüsselungsschlüssel. Geben Sie dazu den Schlüssel beim Laden der Tabelle an.

1. Rufen Sie in der Cloud Console die BigQuery-Web-UI auf.
   Zur BigQuery-Web-UI
2. Maximieren Sie im Navigationsbereich im Abschnitt Ressourcen Ihr Projekt und wählen Sie ein Dataset aus.
3. Klicken Sie auf der rechten Seite des Fensters im Detailbereich auf Tabelle erstellen.
4. Geben Sie die gewünschten Optionen an, die zum Laden der Tabelle zu verwenden sind. Klicken Sie aber vor dem Klicken auf Tabelle erstellen noch auf Erweiterte Optionen.
5. Wählen Sie unter Verschlüsselung die Option Vom Kunden verwalteter Schlüssel aus.

6. Klicken Sie auf die Drop-down-Liste Wählen Sie einen vom Kunden verwalteten Schlüssel aus und wählen Sie den zu verwendenden Schlüssel aus. Wenn Sie keine verfügbaren Schlüssel sehen, geben Sie eine Schlüsselressourcen-ID ein.

   

7. Klicken Sie auf Tabelle erstellen.

bq

Schützen Sie eine Zieltabelle für Ladejobs mit einem vom Kunden verwalteten Verschlüsselungsschlüssel. Legen Sie dazu das Flag --destination_kms_key fest.

bq --location=LOCATION load \
--autodetect \
--source_format=FORMAT \
--destination_kms_key projects/PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
DATASET.TABLE \
path_to_source

Beispiel:

bq load \
--autodetect \
--source_format=NEWLINE_DELIMITED_JSON \
--destination_kms_key projects/PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
test2.table4 \
gs://cloud-samples-data/bigquery/us-states/us-states.json

Go

Auf GitHub ansehen

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

Auf GitHub ansehen

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

Schützen Sie eine Zieltabelle für Ladejobs mit einem vom Kunden verwalteten Verschlüsselungsschlüssel. Legen Sie dazu das Attribut LoadJobConfig.destination_encryption_configuration auf ein EncryptionConfiguration-Objekt fest und laden Sie die Tabelle.

Auf GitHub ansehen Feedback

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

dataset_ref = client.dataset(dataset_id)
job_config = bigquery.LoadJobConfig()
job_config.autodetect = True
job_config.source_format = bigquery.SourceFormat.NEWLINE_DELIMITED_JSON

# Set the encryption key to use for the destination.
# TODO: Replace this key with a key you have created in KMS.
kms_key_name = "projects/{}/locations/{}/keyRings/{}/cryptoKeys/{}".format(
    "cloud-samples-tests", "us", "test", "test"
)
encryption_config = bigquery.EncryptionConfiguration(kms_key_name=kms_key_name)
job_config.destination_encryption_configuration = encryption_config
uri = "gs://cloud-samples-data/bigquery/us-states/us-states.json"

load_job = client.load_table_from_uri(
    uri,
    dataset_ref.table("us_states"),
    location="US",  # Location must match that of the destination dataset.
    job_config=job_config,
)  # API request

assert load_job.job_type == "load"

load_job.result()  # Waits for table load to complete.

assert load_job.state == "DONE"
table = client.get_table(dataset_ref.table("us_states"))
assert table.encryption_configuration.kms_key_name == kms_key_name

In eine von Cloud KMS geschützte Tabelle streamen

Sie können Daten in Ihre von CMEK geschützte BigQuery-Tabelle streamen, ohne zusätzliche Parameter anzugeben. Diese Daten werden mit Ihrem Cloud KMS-Schlüssel sowohl im Zwischenspeicher als auch am endgültigen Speicherort verschlüsselt. Überprüfen Sie vor dem Streamen in eine CMEK-Tabelle die Anforderungen an die Verfügbarkeit und Zugänglichkeit von Schlüsseln.

Weitere Informationen zum Streamen finden Sie unter Daten in BigQuery streamen.

Tabelle mit Standardverschlüsselung in Tabelle mit Cloud KMS-Schutz umwandeln

bq

Sie können den Befehl bq cp mit dem Flag --destination_kms_key verwenden, um eine durch Standardverschlüsselung geschützte Tabelle in eine neue Tabelle oder in die durch Cloud KMS geschützte Originaltabelle zu kopieren. Das Flag --destination_kms_key gibt die Ressourcen-ID des Schlüssels an, der mit der Zieltabelle verwendet werden soll.

So kopieren Sie eine Tabelle mit Standardverschlüsselung in eine neue Tabelle mit Cloud KMS-Schutz:

bq cp \
--destination_kms_key projects/PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
sourceDataset.sourceTableId destinationDataset.destinationTableId

Wenn Sie eine Tabelle mit Standardverschlüsselung in dieselbe Tabelle mit Cloud KMS-Schutz kopieren möchten:

bq cp -f \
--destination_kms_key projects/PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
sourceDataset.sourceTableId sourceDataset.sourceTableId

Wenn Sie eine Tabelle mit Cloud KMS-Schutz auf Standardverschlüsselung ändern möchten, kopieren Sie die Datei in sich selbst, indem Sie bq cp ohne das Flag --destination_kms_key ausführen.

Weitere Informationen zum bq-Befehlszeilentool finden Sie unter bq-Befehlszeilentool verwenden.

Go

Auf GitHub ansehen

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

Auf GitHub ansehen

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

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Python in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Python API.

Schützen Sie das Ziel einer Tabellenkopie mit einem vom Kunden verwalteten Verschlüsselungsschlüssel. Legen Sie dazu das Attribut QueryJobConfig.destination_encryption_configuration auf ein EncryptionConfiguration-Objekt fest und kopieren Sie die Tabelle.

Auf GitHub ansehen Feedback

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

Ermitteln, ob eine Tabelle durch Cloud KMS geschützt ist

1. Klicken Sie in der BigQuery-Web-UI auf den blauen Pfeil links neben dem Dataset, um es zu maximieren, oder klicken Sie doppelt auf den Namen des Datasets. Hierdurch werden die Tabellen und Ansichten im Dataset angezeigt.

2. Klicken Sie auf den Namen der Tabelle.

3. Klicken Sie auf Details. Auf der Seite Tabellendetails werden die Beschreibung und die Informationen der Tabelle angezeigt.

4. Wenn die Tabelle durch Cloud KMS geschützt ist, wird im Feld Vom Kunden verwalteter Verschlüsselungsschlüssel die Schlüsselressourcen-ID angezeigt.

   

Cloud KMS-Schlüssel für eine BigQuery-Tabelle ändern

Sie können eine ALTER TABLE-Abfrage ausführen, die API oder das bq-Befehlszeilentool verwenden, um den Cloud KMS-Schlüssel einer vorhandenen durch einen CMEK geschützten Tabelle zu ändern. Es gibt zwei Möglichkeiten, den Cloud KMS-Schlüssel mithilfe der API und des bq-Befehlszeilentools zu ändern: update oder cp. Wenn Sie update verwenden, können Sie den für eine KMS-geschützte Tabelle genutzten Cloud KMS-Schlüssel ändern. Mit cp haben Sie die Möglichkeit, den für eine CMEK-geschützte Tabelle genutzten Cloud KMS-Schlüssel zu ändern. Sie können auch eine Tabelle von der Standardverschlüsselung in den CMEK-Schutz sowie eine Tabelle vom CMEK-Schutz in die Standardverschlüsselung umwandeln. Ein Vorteil von update ist, dass es schneller als cp verarbeitet wird und die Verwendung von Tabellen-Decorators ermöglicht.

Console

1. Rufen Sie in der Cloud Console die BigQuery-Web-UI auf.
   Zur BigQuery-Web-UI

2. Klicken Sie auf Neue Abfrage erstellen.

3. Geben Sie die DDL-Anweisung im Textbereich Neue Abfrage ein. Geben Sie für den Wert kms_key_name die Ressourcen-ID des Schlüssels an, den Sie zum Verschlüsseln der Tabelle verwenden möchten.

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

4. Klicken Sie auf Ausführen.

bq

Sie können den Schlüssel für eine Cloud KMS-geschützte Tabelle mit dem Befehl bq cp und dem Flag --destination_kms_key ändern. Das Flag --destination_kms_key gibt die Ressourcen-ID des Schlüssels an, der mit der Tabelle verwendet werden soll.

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

Go

Auf GitHub ansehen

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
}

Python

Ändern Sie den vom Kunden verwalteten Verschlüsselungsschlüssel für eine Tabelle. Legen Sie dazu das Attribut Table.encryption_configuration auf ein neues EncryptionConfiguration-Objekt fest und aktualisieren Sie die Tabelle.

Auf GitHub ansehen Feedback

# 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

Standardschlüssel für Dataset festlegen

Sie können einen Dataset-weiten Cloud KMS-Standardschlüssel festlegen, der für alle neu erstellten Tabellen im Dataset gilt, sofern beim Erstellen der Tabelle kein anderer Cloud KMS-Schlüssel angegeben wird. Der Standardschlüssel gilt nicht für vorhandene Tabellen. Das Ändern des Standardschlüssels wirkt sich nicht auf vorhandene Tabellen aus und betrifft nur neue Tabellen, die nach der Änderung erstellt werden.

Sie können den Standardschlüssel für ein Dataset mit den folgenden Methoden anwenden, ändern oder entfernen:

• Standardschlüssel beim Aufrufen der Methode datasets.insert oder datasets.patch im Feld EncryptionConfiguration.kmsKeyName angeben

• Standardschlüssel beim Ausführen des Befehls bq mk --dataset im Flag --default_kms_key angeben

Hinweis: In einem Dataset, auf den ein Cloud KMS-Standardschlüssel angewendet wurde, können Tabellen nur mit einem vom Kunden verwalteten Schlüssel verschlüsselt werden. Sie können also in einem Dataset mit einem Cloud KMS-Standardschlüssel keinen Schlüssel, der nicht vom Kunden verwaltet wird, für die Verschlüsselung neuer Tabellen im Dataset verwenden.

Zugriff von BigQuery auf den Cloud KMS-Schlüssel sperren

Sie können den Zugriff von BigQuery auf den Cloud KMS-Schlüssel jederzeit sperren. Dazu widerrufen Sie die IAM-Berechtigung für diesen Schlüssel.

Hinweis: Wenn Sie den Zugriff von BigQuery auf einen Schlüssel sperren, wird diese Änderung nicht sofort ausgeführt. Sie sollte jedoch innerhalb einer Stunde erfolgen, während die IAM-Berechtigungsänderung übernommen wird. Wenn Sie zu diesem Zeitpunkt eine Abfrage ausführen, wird diese dennoch ausgeführt. Die Ergebnisse werden jedoch möglicherweise nicht angezeigt.

Wenn BigQuery keinen Zugriff mehr auf den Cloud KMS-Schlüssel erhält, kann die Benutzerfreundlichkeit erheblich leiden und Datenverluste können auftreten:

• Auf Daten in diesen durch einen CMEK geschützten Tabellen kann nicht mehr zugegriffen werden. Die Befehle query, cp, extract und tabledata.list schlagen fehl.

• Diesen CMEK-geschützten Tabellen können keine neuen Daten hinzugefügt werden.

• Nachdem der Zugriff wieder gewährt wird, können für diese Tabellen ausgeführte Abfragen mehrere Tage lang beeinträchtigt werden.

Auswirkung der Cloud KMS-Schlüsselrotation

In BigQuery wird ein Tabellenverschlüsselungsschlüssel nicht automatisch rotiert, wenn der mit der Tabelle verknüpfte Cloud KMS-Schlüssel rotiert wird. Vorhandene Tabellen verwenden weiterhin die Schlüsselversion, mit der sie erstellt wurden. Neue Tabellen verwenden die aktuelle Schlüsselversion.

Beschränkungen

BigQuery-Zugriff auf den Cloud KMS-Schlüssel

Ein Cloud KMS-Schlüssel gilt unter folgenden Voraussetzungen als verfügbar und zugänglich:

• Wenn der Schlüssel aktiviert ist
• Wenn das BigQuery-Dienstkonto Berechtigungen zum Verschlüsseln und Entschlüsseln des Schlüssels hat.

In den folgenden Abschnitten werden Auswirkungen auf Streaming-Insert-Anweisungen und langfristig nicht zugängliche Daten beschrieben, wenn ein Schlüssel nicht zugänglich ist.

Auswirkungen auf Streaming-Insert-Anweisungen

Der Cloud KMS-Schlüssel muss innerhalb von 48 Stunden nach einer Streaming-Insert-Anweisung für mindestens 24 aufeinanderfolgende Stunden verfügbar und zugänglich sein. Ist das nicht der Fall, werden die gestreamten Daten unter Umständen nicht vollständig beibehalten und können verloren gehen. Weitere Informationen zu Streaming-Insert-Anweisungen finden Sie unter Daten in BigQuery streamen.

Auswirkungen auf langfristig nicht zugängliche Daten

Da BigQuery verwalteten Speicher bereitstellt, sind langfristig nicht zugängliche Daten mit der BigQuery-Architektur nicht kompatibel. Wenn der Cloud KMS-Schlüssel einer bestimmten BigQuery-Tabelle nicht zur Verfügung steht und 60 Tage lang nicht zugänglich ist, löscht BigQuery die Tabelle und die zugehörigen Daten unter Umständen. BigQuery sendet mindestens sieben Tage vor dem Löschen der Daten eine E-Mail an die mit dem Rechnungskonto verknüpfte E-Mail-Adresse.

Tabellen-Decorators verwenden

Wenn Daten in einer durch Cloud KMS geschützten Tabelle durch die Schreibanordnung WRITE_TRUNCATE für einen load-, cp- oder query-Vorgang ersetzt werden, können je nach Snapshot-Decorator-Zeit über Tabellen-Decorators keine Abfragen an die Tabelle mehr gesendet werden.

Die folgende Tabelle zeigt, ob Sie unter der Annahme, dass eine Tabelle zum Zeitpunkt T ersetzt wurde und der Snapshot-Decorator snapshot_time einen früheren Zeitpunkt als T enthält, Abfragen zur snapshot_time senden können:

Verschlüsselungstyp vor T	Verschlüsselungstyp nach T	snapshot_time
Mit Cloud KMS verschlüsselt	Mit Cloud KMS verschlüsselt	Abfrage nicht möglich
Standardverschlüsselung	Mit Cloud KMS verschlüsselt	Abfrage möglich
Mit Cloud KMS verschlüsselt	Standardverschlüsselung	Abfrage nicht möglich

Eine ähnliche Logik gilt für <time2>, wenn ein Bereichs-Decorator verwendet wird.

Häufig gestellte Fragen

Wer benötigt eine Berechtigung für den Cloud KMS-Schlüssel?

Bei vom Kunden verwalteten Verschlüsselungsschlüsseln müssen Berechtigungen nicht wiederholt festgelegt werden. Solange das BigQuery-Dienstkonto berechtigt ist, den Cloud KMS-Schlüssel zum Verschlüsseln und Entschlüsseln zu verwenden, können alle Personen mit Berechtigung für die BigQuery-Tabelle auf die Daten zugreifen. Das gilt auch, wenn sie keinen direkten Zugriff auf den Cloud KMS-Schlüssel haben.

Welches Dienstkonto wird verwendet?

Das BigQuery-Dienstkonto, das dem Cloud-Projekt der Tabelle zugeordnet ist, wird zum Entschlüsseln der Daten dieser Tabelle verwendet. Die BigQuery-Dienstkonten sind für jedes Projekt eindeutig. Bei einem Job, der Daten in eine Cloud KMS-geschützte, anonyme Tabelle schreibt, wird das Dienstkonto des Projekts verwendet.

Sehen Sie sich als Beispiel drei CMEK-geschützte Tabellen an: table1, table2 und table3. So fragen Sie Daten von {project1.table1, project2.table2} mit der Zieltabelle {project3.table3} ab:

• project1-Dienstkonto für project1.table1 verwenden
• project2-Dienstkonto für project2.table2 verwenden
• project3-Dienstkonto für project3.table3 verwenden

Wie kann BigQuery meinen Cloud KMS-Schlüssel verwenden?

BigQuery verwendet den Cloud KMS-Schlüssel zum Entschlüsseln von Daten als Antwort auf eine Nutzerabfrage, z. B. tabledata.list oder jobs.insert.

BigQuery kann den Schlüssel auch für die Datenpflege und die Speicheroptimierung verwenden, z. B. um Daten in ein für Lesevorgänge optimiertes Format umzuwandeln.

Welche Kryptografiebibliotheken werden verwendet?

BigQuery setzt für CMEK-Funktionen auf Cloud KMS. Cloud KMS verwendet zur Verschlüsselung Tink.

Wo finde ich weitere Hilfe?

Wenn Sie Fragen haben, die hier nicht beantwortet werden, wenden Sie sich an den BigQuery-Support oder den Cloud KMS-Support.

Fehlerbehebung

Im Folgenden werden häufige Fehler und empfohlene Maßnahmen beschrieben.

Fehler	Empfehlung
Gewähren Sie Cloud KMS CryptoKey die Verschlüsseler-/Entschlüsselerrolle.	Das mit Ihrem Projekt verknüpfte BigQuery-Dienstkonto hat keine ausreichenden IAM-Berechtigungen für den angegebenen Cloud KMS-Schlüssel. Folgen Sie der Anleitung, die im Fehler oder in dieser Dokumentation beschrieben wird, um die entsprechende IAM-Berechtigung zu erteilen.
Vorhandene Tabellenverschlüsselungseinstellungen stimmen nicht mit den in der Anforderung angegebenen Verschlüsselungseinstellungen überein.	Dies kann auftreten, wenn die Verschlüsselungseinstellungen für die Zieltabelle von den Verschlüsselungseinstellungen in Ihrer Abfrage abweichen. Ersetzen Sie zur Behebung des Problems die Tabelle mit der Schreibanordnung TRUNCATE oder geben Sie eine andere Zieltabelle an.
Diese Region wird nicht unterstützt.	Die Region des Cloud KMS-Schlüssels stimmt nicht mit der Region des BigQuery-Datasets der Zieltabelle überein. Sie beheben das Problem, indem Sie einen Schlüssel aus einer Region wählen, der mit Ihrem Dataset übereinstimmt, oder in ein Dataset laden, das mit der Schlüsselregion übereinstimmt.