Vom Kunden verwaltete Cloud KMS-Schlüssel

Hinweis: Dieses Feature ist möglicherweise nicht verfügbar, wenn Sie Reservierungen verwenden, die mit bestimmten BigQuery-Editionen erstellt wurden. Weitere Informationen dazu, welche Features in den einzelnen Editionen aktiviert sind, finden Sie unter Einführung in BigQuery-Editionen.

Standardmäßig verschlüsselt BigQuery inaktive Daten. 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 Cloud Key Management Service (KMS).

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. Weitere Informationen zu CMEK einschließlich der Vorteile und Einschränkungen finden Sie unter Vom Kunden verwaltete Verschlüsselungsschlüssel.

Hinweis

• Alle Datenassets, die sich im verwalteten BigQuery-Speicher befinden, unterstützen CMEK. Wenn Sie jedoch auch Daten abfragen, die in einer externen Datenquelle wie Cloud Storage mit CMEK-verschlüsselten Daten gespeichert sind, wird die Datenverschlüsselung durch Cloud Storage verwaltet. BigLake-Tabellen unterstützen beispielsweise mit CMEK verschlüsselte Daten in Cloud Storage.

  BigQuery- und BigLake-Tabellen unterstützen keine CSEKs (Customer-Supplied Encryption Keys, vom Kunden bereitgestellte Verschlüsselungsschlüssel).

• Ü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 dies dasselbe Projekt ist, in dem BigQuery ausgeführt wird)
  Weitere Informationen zu Google Cloud-Projekt-IDs und -Projektnummern finden Sie unter Projekte identifizieren.

• 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.

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

  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.
     • Sie können die Region global nicht verwenden, wenn Sie CMEK für BigQuery in der Google Cloud Console konfigurieren. Sie können jedoch die Region global verwenden, wenn Sie CMEK für BigQuery mit dem bq-Befehlszeilentool oder GoogleSQL konfigurieren.
     Weitere Informationen zu den unterstützten Standorten für BigQuery und Cloud KMS finden Sie unter Cloud-Standorte.

Ein Entschlüsselungsaufruf wird mit Cloud KMS einmal pro Abfrage an eine CMEK-verschlüsselte Tabelle durchgeführt. Weitere Informationen finden Sie unter Cloud KMS – Preise.

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.

Prüfen Sie, ob Ihr Dienstkonto erstellt wurde, und ermitteln Sie dann mithilfe der Google Cloud Console die BigQuery-Dienstkonto-ID. Als Nächstes gewähren Sie dem Dienstkonto die entsprechende Rolle zum Verschlüsseln und Entschlüsseln mithilfe von Cloud KMS.

Erstellen eines Dienstkontos auslösen

Ihr BigQuery-Dienstkonto wird nicht automatisch erstellt, wenn Sie ein Projekt erstellen. Um das Erstellen Ihres Dienstkontos auszulösen, geben Sie einen Befehl ein, der das Konto verwendet, z. B. den Befehl bq show --encryption_service_account, oder rufen Sie die API-Methode projects.getServiceAccount auf. Beispiel:

bq show --encryption_service_account --project_id=PROJECT_ID

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. Wechseln Sie in der Google Cloud Console zur 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]

Verschlüsseler-/Entschlüsselerrolle zuweisen

Weisen Sie dem BigQuery-Systemdienstkonto, das Sie in die Zwischenablage kopiert haben, die Rolle Cloud KMS CryptoKey Encrypter/Decrypter zu. Dieses Konto hat das folgende Format:

[e-mail]

Console

1. Öffnen Sie in der Google 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 Rollen 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 die Google Cloud CLI 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 Google 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

Die Ressourcen-ID für den Cloud KMS-Schlüssel ist für die CMEK-Nutzung erforderlich, wie in den Beispielen gezeigt. Bei diesem Wert muss die Groß-/Kleinschreibung beachtet werden und er muss die folgende Form haben:

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

Hinweis: Sie können keine Schlüsselressourcen-ID angeben, die das Token /cryptoKeyVersions/ enthält. BigQuery verwendet immer die Schlüsselversion, die als primary markiert ist, um eine Tabelle beim Erstellen zu schützen.

Schlüsselressourcen-ID abrufen

1. Öffnen Sie in der Google 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 Mehr .

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

Durch Cloud KMS geschützte Tabelle erstellen

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

Console

1. Öffnen Sie in der Google Cloud Console die Seite "BigQuery".

   Zur Seite "BigQuery"

2. Maximieren Sie im Bereich Explorer Ihr Projekt und wählen Sie ein Dataset aus.

3. Maximieren Sie die Option Aktionen und klicken Sie auf Öffnen.

4. Klicken Sie im Detailfeld auf Tabelle erstellen.

5. 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.

6. Klicken Sie auf Tabelle erstellen.

SQL

Verwenden Sie die Anweisung CREATE TABLE mit der Option kms_key_name:

1. Öffnen Sie in der Google Cloud Console die Seite BigQuery.

   BigQuery aufrufen

2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

   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. Klicken Sie auf Ausführen.

Informationen zum Ausführen von Abfragen finden Sie unter Interaktive Abfrage ausführen.

bq

Sie können das 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/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
DATASET_ID.TABLE_ID

So erstellen Sie eine Tabelle aus einer Abfrage:

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"

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

Terraform

Verwenden Sie die Ressource google_bigquery_table:

Im folgenden Beispiel wird eine Tabelle mit dem Namen mytable erstellt. Außerdem werden die Ressourcen google_kms_crypto_key und google_kms_key_ring verwendet, um einen Cloud Key Management Service-Schlüssel für die Tabelle anzugeben.

Um dieses Beispiel auszuführen, müssen Sie die Cloud Resource Manager API und die Cloud Key Management Service API aktivieren.

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

Führen Sie die Schritte in den folgenden Abschnitten aus, um Ihre Terraform-Konfiguration auf ein Google Cloud-Projekt anzuwenden.

Cloud Shell vorbereiten

1. Rufen Sie Cloud Shell auf.

2. Legen Sie das Google Cloud-Standardprojekt fest, auf das Sie Ihre Terraform-Konfigurationen anwenden möchten.

   Sie müssen diesen Befehl nur einmal pro Projekt und in jedem beliebigen Verzeichnis ausführen.

   export GOOGLE_CLOUD_PROJECT=PROJECT_ID

   Umgebungsvariablen werden überschrieben, wenn Sie in der Terraform-Konfigurationsdatei explizite Werte festlegen.

Verzeichnis vorbereiten

Jede Terraform-Konfigurationsdatei muss ein eigenes Verzeichnis haben (auch als Stammmodul bezeichnet).

1. Erstellen Sie in Cloud Shell ein Verzeichnis und eine neue Datei in diesem Verzeichnis. Der Dateiname muss die Erweiterung .tf haben, z. B. main.tf. In dieser Anleitung wird die Datei als main.tf bezeichnet.

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

2. Wenn Sie einer Anleitung folgen, können Sie den Beispielcode in jedem Abschnitt oder Schritt kopieren.

   Kopieren Sie den Beispielcode in das neu erstellte main.tf.

   Kopieren Sie optional den Code aus GitHub. Dies wird empfohlen, wenn das Terraform-Snippet Teil einer End-to-End-Lösung ist.

3. Prüfen und ändern Sie die Beispielparameter, die auf Ihre Umgebung angewendet werden sollen.
4. Speichern Sie die Änderungen.
5. Initialisieren Sie Terraform. Dies ist nur einmal für jedes Verzeichnis erforderlich.

   terraform init

   Fügen Sie optional die Option -upgrade ein, um die neueste Google-Anbieterversion zu verwenden:

   terraform init -upgrade

Änderungen anwenden

1. Prüfen Sie die Konfiguration und prüfen Sie, ob die Ressourcen, die Terraform erstellen oder aktualisieren wird, Ihren Erwartungen entsprechen:

   terraform plan

   Korrigieren Sie die Konfiguration nach Bedarf.

2. Wenden Sie die Terraform-Konfiguration an. Führen Sie dazu den folgenden Befehl aus und geben Sie yes an der Eingabeaufforderung ein:

   terraform apply

   Warten Sie, bis Terraform die Meldung „Apply complete“ anzeigt.

3. Öffnen Sie Ihr Google Cloud-Projekt, um die Ergebnisse aufzurufen. Rufen Sie in der Google Cloud Console Ihre Ressourcen in der Benutzeroberfläche auf, um sicherzustellen, dass Terraform sie erstellt oder aktualisiert hat.

Hinweis: Bei Terraform-Beispielen wird in der Regel davon ausgegangen, dass die erforderlichen APIs in Ihrem Google Cloud-Projekt aktiviert sind.

Einfach loslegen (Go)

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Go in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Go API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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

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

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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.

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

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. BigQuery speichert den Namen des Schlüssels, mit dem der Tabelleninhalt verschlüsselt wurde, und verwendet diesen Schlüssel bei der Abfrage einer durch Cloud KMS geschützten Tabelle.

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

Abfrageergebnisse mit einem Cloud KMS-Schlüssel schützen

Standardmäßig werden Abfrageergebnisse in einer temporären Tabelle gespeichert, die mit einem von Google verwalteten Schlüssel verschlüsselt ist. Falls Sie Ihre Abfrageergebnisse stattdessen mit einem Cloud KMS-Schlüssel verschlüsseln möchten, wählen Sie eine der folgenden Optionen:

Console

1. Öffnen Sie in der Google Cloud Console die Seite "BigQuery".

   Zur Seite "BigQuery"

2. Klicken Sie auf Neue Abfrage erstellen.

3. Geben Sie im Abfragetextbereich eine gültige GoogleSQL-Abfrage 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=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"

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

Einfach loslegen (Go)

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 zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Java API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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.

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

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. Öffnen Sie in der Google Cloud Console die Seite "BigQuery".

   Zur Seite "BigQuery"

2. Maximieren Sie im Bereich Explorer Ihr Projekt und wählen Sie ein Dataset aus.

3. Klicken Sie im Detailfeld 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/KMS_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/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
test2.table4 \
gs://cloud-samples-data/bigquery/us-states/us-states.json

Einfach loslegen (Go)

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

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.

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

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/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
SOURCE_DATASET_ID.SOURCE_TABLE_ID DESTINATION_DATASET_ID.DESTINATION_TABLE_ID

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

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

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.

Einfach loslegen (Go)

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

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 zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Python API.

Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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.

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 Google Cloud Console auf den blauen Pfeil links neben dem Dataset, um die Ansicht zu maximieren, oder doppelklicken Sie auf den Dataset-Namen. 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 CMEK-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 oder 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.

SQL

Mit der Anweisung ALTER TABLE SET OPTIONS können Sie das Feld kms_key_name für eine Tabelle aktualisieren:

1. Öffnen Sie in der Google Cloud Console die Seite BigQuery.

   BigQuery aufrufen

2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

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

3. Klicken Sie auf Ausführen.

Informationen zum Ausführen von Abfragen finden Sie unter Interaktive Abfrage 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/KMS_PROJECT_ID/locations/LOCATION/keyRings/KEY_RING/cryptoKeys/KEY \
-t DATASET_ID.TABLE_ID

Einfach loslegen (Go)

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

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

Ä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.

# 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

  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
  

Hinweis: In einem Dataset, auf das ein Cloud KMS-Standardschlüssel angewendet wurde, können neue 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.

Projekt-Standardschlüssel festlegen

Sie können einen projektweiten Cloud KMS-Standardschlüssel festlegen, der für alle Abfrageergebnisse und neu erstellten Tabellen im Projekt gilt, sofern Sie keinen anderen Cloud KMS-Schlüssel angeben. 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.

SQL

Mit der Anweisung ALTER PROJECT SET OPTIONS können Sie das Feld default_kms_key_name für ein Projekt aktualisieren. Sie finden den Ressourcennamen für den Schlüssel auf der Cloud KMS-Seite.

1. Öffnen Sie in der Google Cloud Console die Seite BigQuery.

   BigQuery aufrufen

2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

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

3. Klicken Sie auf Ausführen.

Informationen zum Ausführen von Abfragen finden Sie unter Interaktive Abfrage ausführen.

bq

Mit dem bq-Befehl können Sie eine ALTER PROJECT SET OPTIONS-Anweisung ausführen, um das default_kms_key_name-Feld für ein Projekt zu aktualisieren:

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

CMEK zum Schutz von BigQuery ML-Modellen verwenden

BigQuery ML unterstützt CMEK. Zusätzlich zur Standardverschlüsselung von BigQuery können Sie eigene Cloud Key Management Service-Schlüssel für die Verschlüsselung von ML-Modellen verwenden, einschließlich importierter TensorFlow-Modelle.

Verschlüsseltes Modell mit einem Cloud KMS-Schlüssel erstellen

Verwenden Sie zum Erstellen eines verschlüsselten Modells die Anweisung CREATE MODEL und geben Sie in den Trainingsoptionen KMS_KEY_NAME an:

    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

Dieselbe Syntax gilt auch für importierte TensorFlow-Modelle:

    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

Beschränkungen

Für vom Kunden verwaltete Verschlüsselungsschlüssel gelten beim Verschlüsseln von Modellen für maschinelles Lernen folgende Einschränkungen:

• CMEK-Schlüssel der Region Global werden für die folgenden Modelltypen nicht unterstützt:

  • DNN
  • Wide and Deep
  • Autoencoder
  • Boosted Tree

• CMEK-Schlüssel der Region Global und multiregionale CMEK-Schlüssel wie EU oder US werden beim Erstellen von AutoML Tables-Modellen nicht unterstützt.

Modell mit Standardverschlüsselung zu Cloud KMS-Schutz umwandeln

Sie können den Befehl bq cp mit dem Flag --destination_kms_key verwenden, um ein durch Standardverschlüsselung geschütztes Modell in ein neues Modell zu kopieren, das durch Cloud KMS geschützt ist. Alternativ können Sie den Befehl bq cp mit dem Flag -f verwenden, um ein durch die Standardverschlüsselung geschütztes Modell zu überschreiben und das Modell auf den Cloud KMS-Schutz zu aktualisieren. Das Flag --destination_kms_key gibt die Ressourcen-ID des Schlüssels an, der mit dem Zieltmodell verwendet werden soll.

So kopieren Sie ein Modell mit Standardverschlüsselung in ein neues Modell mit Cloud KMS-Schutz:

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

So überschreiben Sie ein Modell, das mit dem Standardverschlüsselung verschlüsselt ist, auf dasselbe Modell mit Cloud KMS-Schutz:

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

So ändern Sie ein Modell vom Cloud KMS-Schutz in die Standardverschlüsselung:

bq cp -f \
DATASET_ID.MODEL_ID DATASET_ID.MODEL_ID

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

Ermitteln, ob ein Modell durch Cloud KMS geschützt ist

Mit dem Befehl bq show können Sie prüfen, ob ein Modell durch einen Cloud KMS-Schlüssel geschützt ist. Der Verschlüsselungsschlüssel befindet sich im Feld kmsKeyName.

bq show -m my_dataset.my_model

Sie können den Google Cloud KMS-Schlüssel für ein verschlüsseltes Modell auch in der Google Cloud Console ermitteln. CMEK-Informationen befinden sich im Feld Vom Kunden verwalteter Schlüssel im Abschnitt Modelldetails des Bereichs Details des Modells.

Cloud KMS-Schlüssel für ein verschlüsseltes Modell ändern

Verwenden Sie den Befehl bq update mit dem Flag --destination_kms_key, um den Schlüssel für ein durch Cloud KMS geschütztes Modell zu ändern.

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

Standardprojekt- oder Dataset-Schlüssel verwenden

Wenn Sie einen standardmäßigen Cloud KMS-Schlüssel auf Projekt- oder Dataset-Ebene festgelegt haben, verwendet BigQuery ML diesen Schlüssel automatisch beim Erstellen von Modellen. Verwenden Sie die Anweisung CREATE MODEL, um einen anderen Schlüssel zum Verschlüsseln des Modells anzugeben, wenn Sie nicht den Standardschlüssel verwenden möchten.

BigQuery ML-Funktionen mit verschlüsselten Modellen verwenden

Sie können alle BigQuery ML-Funktionen mit einem verschlüsselten Modell verwenden, ohne einen Verschlüsselungsschlüssel angeben zu müssen.

CMEK zum Schutz der BigQuery Connection API verwenden

Bei Cloud SQL-Verbindungen können Sie Ihre BigQuery Connection API-Anmeldedaten mit CMEK schützen.

Weitere Informationen zum Erstellen einer CMEK-geschützten Verbindung finden Sie unter Cloud SQL-Verbindungen erstellen.

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 (Identity and Access Management) 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 erfolgt jedoch innerhalb einer Stunde, während die IAM-Berechtigungsänderung übernommen wird. Wenn Sie zu diesem Zeitpunkt eine Abfrage ausführen, wird diese dennoch abgeschlossen. 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.

CMEK-Nutzung mit Organisationsrichtlinie steuern

BigQuery lässt sich in CMEK-Organisationsrichtlinieneinschränkungen einbinden, um Anforderungen für die Verschlüsselungscompliance für BigQuery-Ressourcen in Ihrer Organisation anzugeben.

Durch diese Einbindung haben Sie folgende Möglichkeiten:

• CMEKs für alle BigQuery-Ressourcen in einem Projekt erzwingen.

• Einschränken, welche Cloud KMS-Schlüssel zum Schutz von Ressourcen in einem Projekt verwendet werden können.

CMEKs für alle Ressourcen erzwingen

Eine gängige Richtlinie besteht darin, die Verwendung von CMEKs zu erzwingen, um alle Ressourcen in einer bestimmten Gruppe von Projekten zu schützen. Mit der constraints/gcp.restrictNonCmekServices-Einschränkung können Sie diese Richtlinie in BigQuery erzwingen.

Ist diese Richtlinie festgelegt, schlagen alle Anfragen zur Ressourcenerstellung ohne angegebenen Cloud KMS-Schlüssel fehl.

Nachdem Sie diese Richtlinie festgelegt haben, gilt sie nur für neue Ressourcen im Projekt. Alle vorhandenen Ressourcen, für die keine Cloud KMS-Schlüssel festgelegt sind, bleiben bestehen und sind problemlos zugänglich.

Hinweis: Diese Einschränkung gilt nur für Ressourcen, die Daten enthalten. Ressourcen, die nur den angegebenen Cloud KMS-Schlüssel als Standard für neue Ressourcen verwenden (z. B. Datasets und Projektkonfigurationen), können ohne Cloud KMS-Schlüssel erstellt oder aktualisiert werden.

Console

1. Öffnen Sie die Seite Organisationsrichtlinien.

   Zu den Organisationsrichtlinien

2. Geben Sie im Feld Filter constraints/gcp.restrictNonCmekServices ein und klicken Sie dann auf Einschränken, welche Dienste Ressourcen ohne CMEK erstellen können.

3. Klicken Sie auf  Bearbeiten.

4. Wählen Sie Anpassen, Ersetzen und dann Regel hinzufügen aus.

5. Wählen Sie Benutzerdefiniert und klicken Sie dann auf Ablehnen.

6. Geben Sie im Feld Benutzerdefinierter Wert den Wert is:bigquery.googleapis.com ein.

7. Klicken Sie auf Fertig und anschließend auf Speichern.

gcloud

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

Wenn Sie prüfen möchten, ob die Richtlinie erfolgreich angewendet wurde, können Sie versuchen, eine Tabelle im Projekt zu erstellen. Der Vorgang schlägt fehl, sofern Sie keinen Cloud KMS-Schlüssel angeben.

Diese Richtlinie gilt auch für Abfrageergebnistabellen im Projekt. Sie können einen Projektstandardschlüssel angeben, sodass Nutzer nicht jedes Mal manuell einen Schlüssel angeben müssen, wenn sie eine Abfrage im Projekt ausführen.

Cloud KMS-Schlüssel für ein BigQuery-Projekt einschränken

Mit der constraints/gcp.restrictCmekCryptoKeyProjects-Einschränkung können Sie die Cloud KMS-Schlüssel einschränken, mit denen eine Ressource in einem BigQuery-Projekt geschützt werden kann.

Sie können eine Regel angeben, z. B. "Für alle BigQuery-Ressourcen in projects/my-company-data-project müssen die in diesem Projekt verwendeten Cloud KMS-Schlüssel von projects/my-company-central-keys ODER projects/team-spezific-keys stammen".

Console

1. Öffnen Sie die Seite Organisationsrichtlinien.

   Zu den Organisationsrichtlinien

2. Geben Sie im Feld Filter constraints/gcp.restrictCmekCryptoKeyProjects ein und klicken Sie dann auf Beschränken, welche Projekte KMS-CryptoKeys für CMEK bereitstellen können.

3. Klicken Sie auf  Bearbeiten.

4. Wählen Sie Anpassen, Ersetzen und dann Regel hinzufügen aus.

5. Wählen Sie Benutzerdefiniert und klicken Sie dann auf Zulassen.

6. Geben Sie im Feld Benutzerdefinierter Wert den Wert under:projects/<var>KMS_PROJECT_ID</var> ein.

7. Klicken Sie auf Fertig und anschließend auf Speichern.

gcloud

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

Sie können versuchen, eine Tabelle mit einem Cloud KMS-Schlüssel aus einem anderen Projekt zu erstellen, um zu prüfen, ob die Richtlinie erfolgreich angewendet wurde. Der Vorgang wird fehlschlagen.

Einschränkungen von Organisationsrichtlinien

Für das Festlegen einer Organisationsrichtlinie gelten Einschränkungen.

Weitergabeverzögerung

Nachdem Sie eine Organisationsrichtlinie festgelegt oder aktualisiert haben, kann es bis zu 15 Minuten dauern, bis die neue Richtlinie wirksam wird. BigQuery speichert Richtlinien im Cache, um die Latenz bei der Abfrage- und Tabellenerstellung nicht negativ zu beeinflussen.

Erforderliche Berechtigungen zum Festlegen einer Organisationsrichtlinie

Die Berechtigung zum Festlegen oder Aktualisieren der Organisationsrichtlinie kann zu Testzwecken schwierig besorgbar sein. Sie benötigen die Rolle "Administrator für Organisationsrichtlinien“, die nur auf Organisationsebene (und nicht auf Projekt- oder Ordnerebene) gewährt werden kann.

Die Rolle muss zwar auf Organisationsebene zugewiesen werden, es ist jedoch weiterhin möglich, eine Richtlinie anzugeben, die nur für ein bestimmtes Projekt oder einen bestimmten Ordner gilt.

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. Alle Daten in den vorhandenen Tabellen sind weiterhin durch die Schlüsselversion geschützt, mit der sie erstellt wurden.

Alle neu erstellten Tabellen verwenden die Primärschlüsselversion zur Zeit der Erstellung.

Wenn Sie eine Tabelle auf die neueste Schlüsselversion aktualisieren möchten, ändern Sie die Tabelle in einen anderen Cloud KMS-Schlüssel und wechseln dann zum ursprünglichen zurück.

Auswirkungen auf die Cloud KMS-Abrechnung

Wenn Sie eine CMEK-geschützte Tabelle erstellen oder kürzen, generiert BigQuery einen Zwischenschlüsselverschlüsselungsschlüssel, der dann mit dem angegebenen Cloud KMS-Schlüssel verschlüsselt wird.

Zu Abrechnungszwecken bedeutet dies, dass weder Ihre Cloud KMS-Aufrufe noch die zugehörigen Kosten mit der Tabellengröße skaliert werden. Bei CMEK-geschützten Tabellen können Sie einen Aufruf von Cloud KMS cryptoKeys.encrypt für jede Tabellenerstellung oder -kürzung und einen Aufruf von Cloud KMS cryptoKeys.decrypt für jede an einer Abfrage beteiligte Tabelle erwarten. Beide Methoden gehören zur Kategorie Schlüsselvorgänge: Kryptografisch, die unter Cloud KMS-Preise aufgeführt sind.

Liest oder schreibt in eine vorhandene CMEK-geschützte Tabelle Cloud KMS cryptoKeys.decrypt, da der Zwischenschlüssel entschlüsselt werden muss.

Beschränkungen

BigQuery-Zugriff auf den Cloud KMS-Schlüssel

Ein Cloud KMS-Schlüssel gilt in BigQuery 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 das Streaming von Insert-Anweisungen und langfristig nicht zugänglichen 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.

Externe Datenquellen verwenden

Wenn Sie in einer externen Datenquelle (z. B. Cloud Storage mit CMEK-verschlüsselten Daten) verschlüsselte Daten abfragen, wird die Datenverschlüsselung von Cloud Storage verwaltet. BigLake-Tabellen unterstützen beispielsweise mit CMEK verschlüsselte Daten in Cloud Storage.

BigQuery- und BigLake-Tabellen unterstützen keine CSEKs (Customer-Supplied Encryption Keys, vom Kunden bereitgestellte Verschlüsselungsschlüssel).

Zwischen CMEK-geschützten und Standardverschlüsselung wechseln

Sie können eine Tabelle nicht zwischen Standardverschlüsselungen und CMEK-Verschlüsselung wechseln. Um die Verschlüsselung zu wechseln, kopieren Sie die Tabelle mit den Informationen zur Zielverschlüsselung oder verwenden Sie eine SELECT *-Abfrage, um die Tabelle selbst mit WRITE_TRUNCATE-Anordnung auszuwählen.

Tabellen-Decorators verwenden

Wenn Sie eine Tabelle mit Cloud KMS schützen und die Daten in der Tabelle durch den Wert WRITE_TRUNCATE für einen load-, cp- oder query-Vorgang ersetzen, dann gilt: Bereichs-Decorators funktionieren nicht über die Grenze für die Verschlüsselungsänderung. Sie können weiterhin Tabellen-Decorators (einschließlich Bereichs-Decorators) verwenden, um die Daten vor oder nach der Grenze abzufragen oder den Snapshot zu einem bestimmten Zeitpunkt abzufragen.

Platzhaltertabellenabfragen

CMEK-geschützte Tabellen können nicht mit einem Platzhaltersuffix abgefragt werden.

Editionsunterstützung

Die CMEK-Unterstützung für BigQuery ist nur für BigQuery Enterprise Plus und BigQuery On-Demand verfügbar. BigQuery-Kunden, die Legacy-Pauschalpreise vor dem 5. Juli 2023 verwenden, behalten den gesamten Support für CMEK in der Enterprise-Stufe bei.

BigQuery Studio-Support

BigQuery Studio-Code-Assets, einschließlich gespeicherte Abfragen und notebooks, unterstützen CMEK nicht.

Häufig gestellte Fragen

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

Bei vom Kunden verwalteten Verschlüsselungsschlüsseln (CMEK – Customer-Managed Encryption Keys) 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 Google 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 oderjobs.insert eine

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.

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 in der Fehlermeldung oder in dieser Dokumentation beschrieben ist, um die entsprechende Cloud 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.
Der Administrator legt fest, dass Sie für Abfragen im Projekt PROJECT_ID. einen Verschlüsselungsschlüssel angeben.	Eine Organisationsrichtlinie hat das Erstellen einer Ressource oder das Ausführen einer Abfrage verhindert. Weitere Informationen zu dieser Richtlinie finden Sie unter CMEKs für alle Ressourcen in einem BigQuery-Projekt anfordern.
Ihr Administrator verhindert die Verwendung von KMS-Schlüsseln aus dem Projekt KMS_PROJECT_ID zum Schutz von Ressourcen in Projekt PROJECT_ID.	Eine Organisationsrichtlinie hat das Erstellen einer Ressource oder das Ausführen einer Abfrage verhindert. Weitere Informationen zu dieser Richtlinie finden Sie unter Cloud KMS-Schlüssel für ein BigQuery-Projekt einschränken.