Protéger des données avec des clés Cloud KMS

Par défaut, BigQuery chiffre le contenu client stocké au repos, puis traite et gère ce chiffrement sans aucune action supplémentaire de votre part. Les données d'une table BigQuery sont tout d'abord chiffrées à l'aide de clés de chiffrement de données. Ces clés sont ensuite chiffrées par des clés de chiffrement de clés, dans le cadre du processus appelé chiffrement encapsulé. Les clés de chiffrement de clés ne chiffrent pas directement les données, mais plutôt les clés de chiffrement de données utilisées par Google pour les chiffrer. Pour en savoir plus, consultez la section Gestion des clés.

Si vous souhaitez contrôler vous-même le chiffrement, vous pouvez utiliser des clés gérées par le client (CMEK, Customer-Managed Encryption Keys) pour BigQuery. Au lieu de laisser Google gérer les clés de chiffrement de clés qui protègent vos données, c'est vous qui vous chargez de cette tâche dans Cloud KMS. Cet article décrit en détail cette technique.

Découvrez les options de chiffrement disponibles dans Google Cloud.

Avant de commencer

  1. Assurez-vous de bien comprendre le fonctionnement des ensembles de données, des tables et des requêtes.

  2. Déterminez si vous allez exécuter BigQuery et Cloud KMS dans le même projet Google Cloud ou dans des projets différents. Dans cette documentation, voici les conventions qui sont utilisées :

    • project_id est l'ID du projet qui exécute BigQuery.
    • project_number est le numéro du projet qui exécute BigQuery.
    • kms_project_id est l'ID du projet qui exécute Cloud KMS (même s'il s'agit du même projet que celui qui exécute BigQuery).
    Pour en savoir plus sur les ID et numéros de projet Google Cloud, consultez la section Identifier des projets.

  3. BigQuery est automatiquement activé dans les nouveaux projets. Si vous exécutez BigQuery à partir d'un projet préexistant, activez l'API BigQuery.

  4. Pour le projet Google Cloud qui exécute Cloud KMS, procédez comme suit :

    1. Activez l'API Cloud KMS.
    2. Créez un trousseau de clés ainsi qu'une clé en suivant la procédure décrite à la section Créer des trousseaux de clés et des clés. Créez le trousseau de clés dans le même emplacement que celui de votre ensemble de données BigQuery :
      • Les ensembles de données multirégionaux doivent utiliser un trousseau de clés multirégional issu du même emplacement. Par exemple, un ensemble de données situé dans la région US doit être protégé par un trousseau de clés de la région us. De même, un ensemble de données se trouvant dans la région EU doit être protégé par un trousseau de clés de la région europe.
      • Les ensembles de données régionaux doivent utiliser des clés régionales correspondantes. Par exemple, un ensemble de données dans la région asia-northeast1 doit être protégé par un trousseau de clés de la région asia-northeast1.
      • La région global n'est pas compatible avec BigQuery.
      Pour en savoir plus sur les emplacements compatibles avec BigQuery et Cloud KMS, consultez la section Emplacements cloud.

Spécification du chiffrement

Les clés Cloud KMS qui servent à protéger les données dans BigQuery sont des clés de type AES-256. Elles servent de clés de chiffrement de clés dans BigQuery, dans la mesure où elles chiffrent les clés de chiffrement de données qui chiffrent les données.

Accorder une autorisation de chiffrement et de déchiffrement

Dans la console Google Cloud, identifiez l'ID du compte de service BigQuery afin d'accorder à ce compte le rôle nécessaire au chiffrement et au déchiffrement à l'aide de Cloud KMS.

Identifier l'ID du compte de service

UI classique

  1. Accédez à l'UI Web de BigQuery.

    Accéder à l'UI Web de BigQuery

  2. Cliquez sur la flèche vers le bas flèche vers le bas située à côté du nom du projet dans le volet de navigation, puis sur Chiffrement géré par le client.

  3. Une boîte de dialogue utilisateur s'ouvre et affiche le compte de service nécessitant une autorisation de chiffrement et de déchiffrement :

    ID du compte de service

  4. Cliquez sur Copier pour copier l'ID du compte de service dans votre presse-papiers, puis sur OK pour fermer la boîte de dialogue.

CLI

Vous pouvez identifier l'ID du compte de service en exécutant la commande bq show avec l'option --encryption_service_account spécifié :

bq show --encryption_service_account

La commande affiche l'ID du compte de service comme suit :

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

Affecter le rôle Chiffreur/Déchiffreur

Affectez le rôle Cloud KMS CryptoKey Encrypter/Decrypter au compte de service BigQuery que vous avez copié dans votre presse-papiers. Ce compte apparaît au format suivant :

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

Console

  1. Ouvrez la page Sécurité de la console GCP.

    Ouvrir la page "Clés de chiffrement du menu Sécurité"

  2. Sélectionnez le projet et cliquez sur Continuer.

  3. Identifiez la clé de chiffrement à laquelle vous souhaitez ajouter le rôle.

    • Si le compte de service bq-project_number@bigquery-encryption.iam.gserviceaccount.com ne figure pas déjà sur la liste des membres, cela signifie qu'aucun rôle ne lui a encore été attribué. Cliquez sur Ajouter un membre et saisissez l'adresse e-mail du compte de service bq-project_number@bigquery-encryption.iam.gserviceaccount.com.
    • Si le compte de service figure déjà sur la liste des membres, il possède des rôles. Cliquez sur la liste déroulante du rôle actuellement affecté au compte de service bq-project_number@bigquery-encryption.iam.gserviceaccount.com.
  4. Cliquez sur la liste déroulante Rôle, sélectionnez Cloud KMS, puis cliquez sur le rôle Chiffreur/Déchiffreur de clés cryptographiques Cloud KMS.

  5. Cliquez sur Ajouter ou Enregistrer pour appliquer le rôle au compte de service bq-project_number@bigquery-encryption.iam.gserviceaccount.com.

CLI

Pour attribuer le rôle, vous pouvez utiliser l'outil de ligne de commande gcloud comme suit :

gcloud kms keys add-iam-policy-binding \
--project=kms_project_id \
--member serviceAccount:bq-project_number@bigquery-encryption.iam.gserviceaccount.com \
--role roles/cloudkms.cryptoKeyEncrypterDecrypter \
--location=kms_key_location \
--keyring=kms_key_ring \
kms_key

Remplacez la variable kms_project_id par l'ID de votre projet Google Cloud qui exécute Cloud KMS et la variable project_number par le numéro (et non pas l'ID) de ce même projet. Ensuite, remplacez les variables kms_key_location, kms_key_ring et kms_key par l'emplacement, le trousseau de clés et le nom de votre clé Cloud KMS.

ID de ressource de la clé

Pour pouvoir utiliser des clés CMEK, vous devez disposer de l'ID de ressource de la clé Cloud KMS, comme décrit dans les exemples de cette page. Cette clé se présente au format suivant :

projects/project_id/locations/location/keyRings/key_ring/cryptoKeys/key

Pour en savoir plus sur la récupération de l'ID de ressource de la clé, consultez la section ID de ressource de la clé.

Créer une table protégée par Cloud KMS

Créer une table vide protégée par Cloud KMS

Pour créer une table protégée par Cloud KMS, procédez comme suit :

UI classique

  1. Cliquez sur l'icône de flèche vers le bas flèche vers le bas à côté du nom de votre ensemble de données dans l'interface utilisateur Web de BigQuery, puis cliquez sur Créer une table.

  2. Sur la page Créer une table, spécifiez les informations nécessaires pour créer une table vide avec une définition de schéma. Avant de cliquer sur Créer une table, définissez le type de chiffrement et spécifiez la clé Cloud KMS à utiliser avec la table :

    1. Cliquez sur la liste déroulante des types de chiffrement et sélectionnez Chiffrement géré par le client.
    2. Dans le champ Clé de chiffrement gérée par le client, saisissez l'ID de ressource de la clé.
  3. Cliquez sur Créer une table.

CLI

Vous pouvez également créer la table à l'aide de l'outil de ligne de commande bq et de l'option --destination_kms_key. L'option --destination_kms_key spécifie l'ID de ressource de la clé à utiliser avec la table.

Pour créer une table vide à l'aide d'un schéma, exécutez la commande suivante :

bq mk --schema name:string,value:integer -t \
--destination_kms_key projects/project_id/locations/location/keyRings/key_ring/cryptoKeys/key \
mydataset.newtable

Vous pouvez également utiliser une instruction LDD :

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

Pour créer une table à partir d'une requête, exécutez la commande suivante :

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"

Pour en savoir plus sur l'outil de ligne de commande bq, consultez la page consacrée à l'utilisation de l'outil de ligne de commande bq.

Go

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

	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
}

Python

Pour protéger une nouvelle table à l'aide d'une clé de chiffrement gérée par le client, définissez la propriété Table.encryption_configuration sur un objet EncryptionConfiguration avant de créer la table.

# 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

Interroger une table protégée par une clé Cloud KMS

L'interrogation d'une table protégée par Cloud KMS ne requiert aucune démarche spécifique. BigQuery stocke le nom de la clé permettant de chiffrer le contenu de la table et l'utilise lorsqu'une table protégée par Cloud KMS est interrogée.

Tant que BigQuery a accès à la clé Cloud KMS qui sert à chiffrer le contenu de la table, vous pouvez utiliser les outils existants, la console BigQuery et l'interface de ligne de commande bq de la même manière qu'avec les tables chiffrées par défaut.

Protéger les résultats de requête à l'aide d'une clé Cloud KMS

UI classique

  1. Cliquez sur le bouton Saisir une requête dans l'interface utilisateur Web de BigQuery.

  2. Saisissez une requête SQL BigQuery valide dans la zone de texte Nouvelle requête.

  3. Cliquez sur Type de chiffrement et sélectionnez Chiffrement géré par le client.

  4. Dans le champ Clé de chiffrement gérée par le client, saisissez l'ID de ressource de la clé.

  5. Cliquez sur Exécuter la requête.

CLI

Spécifiez l'option --destination_kms_key pour protéger la table de destination ou les résultats de la requête (si vous utilisez une table temporaire) avec votre clé Cloud KMS. L'option --destination_kms_key spécifie l'ID de ressource de la clé à utiliser avec la table de destination ou la table résultante.

Vous pouvez également spécifier l'option --destination_table pour indiquer la destination des résultats de la requête. Si l'option --destination_table n'est pas spécifiée, les résultats de la requête seront écrits dans une table temporaire.

Pour interroger une table, exécutez la commande suivante :

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"

Pour en savoir plus sur l'outil de ligne de commande bq, consultez la page consacrée à l'utilisation de l'outil de ligne de commande bq.

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

	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
}

Python

from google.cloud import bigquery

# TODO(developer): 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")

Charger une table protégée par Cloud KMS

Pour charger un fichier de données dans une table protégée par Cloud KMS, procédez comme suit :

Console

Pour protéger une table de destination de tâches de chargement à l'aide d'une clé de chiffrement gérée par le client, spécifiez la clé au moment de charger la table.

  1. Ouvrez l'UI Web de BigQuery dans Cloud Console.
    Accéder à l'UI Web de BigQuery
  2. Dans la section Ressources du panneau de navigation, développez votre projet et sélectionnez un ensemble de données.
  3. À droite de la fenêtre, dans le panneau de détails, cliquez sur Créer une table.
  4. Saisissez les options que vous souhaitez utiliser pour le chargement de la table, mais avant de cliquer sur Créer une table, sélectionnez Options avancées.
  5. Sous Chiffrement, sélectionnez Clé gérée par le client.
  6. Cliquez sur le menu déroulant Sélectionner une clé gérée par le client et choisissez la clé à utiliser. Si vous ne voyez aucune clé, saisissez un ID de ressource de clé.

    Options avancées

  7. Cliquez sur Créer une table.

CLI

Pour protéger une table de destination de tâches de chargement à l'aide d'une clé de chiffrement gérée par le client, spécifiez l'option --destination_kms_key.

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
Exemple :
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

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

Python

Pour protéger une table de destination de tâches de chargement à l'aide d'une clé de chiffrement gérée par le client, définissez la propriété LoadJobConfig.destination_encryption_configuration sur un objet EncryptionConfiguration et chargez la table.

# 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

Insérer des données en flux continu dans une table protégée par Cloud KMS

Vous pouvez insérer des données en flux continu dans votre table BigQuery protégée par une clé CMEK sans spécifier de paramètres supplémentaires. Notez que ces données sont chiffrées dans le tampon et à l'emplacement final grâce à votre clé Cloud KMS. Avant de diffuser des données dans une table protégée par une clé CMEK, vérifiez les exigences de disponibilité et d'accessibilité des clés.

Pour en savoir plus sur la diffusion de données, consultez la page Insérer des données en flux continu dans BigQuery.

Remplacer le chiffrement par défaut d'une table par la protection Cloud KMS

CLI

Vous pouvez exécuter la commande bq cp en spécifiant l'option --destination_kms_key pour copier une table protégée avec le chiffrement par défaut dans une nouvelle table ou dans la table d'origine, protégée par Cloud KMS. L'option --destination_kms_key spécifie l'ID de ressource de la clé à utiliser avec la table de destination.

Pour copier une table utilisant le chiffrement par défaut dans une nouvelle table protégée par Cloud KMS, exécutez la commande suivante :

bq cp \
--destination_kms_key projects/project_id/locations/location/keyRings/key_ring/cryptoKeys/key \
sourceDataset.sourceTableId destinationDataset.destinationTableId

Si vous souhaitez copier une table protégée par le chiffrement par défaut dans la même table, mais en utilisant la protection Cloud KMS, exécutez la commande suivante :

bq cp -f \
--destination_kms_key projects/project_id/locations/location/keyRings/key_ring/cryptoKeys/key \
sourceDataset.sourceTableId sourceDataset.sourceTableId

Si vous souhaitez remplacer la protection de Cloud KMS d'une table par le chiffrement par défaut, copiez le fichier à son propre emplacement en exécutant la commande bq cp sans spécifier l'option --destination_kms_key.

Pour en savoir plus sur l'outil de ligne de commande bq, consultez la page consacrée à l'utilisation de l'outil de ligne de commande bq.

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

	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
}

Python

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Python décrite dans le guide de démarrage rapide de BigQuery sur l'utilisation des bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery en langage Python.

Pour protéger la destination d'une opération de copie de table à l'aide d'une clé de chiffrement gérée par le client, définissez la propriété QueryJobConfig.destination_encryption_configuration sur un objet EncryptionConfiguration et copiez la table.

from google.cloud import bigquery

# TODO(developer): 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")

Vérifier si une table est protégée par Cloud KMS

  1. Dans l'interface utilisateur Web de BigQuery, cliquez sur la flèche bleue située à gauche de l'ensemble de données pour le développer ou double-cliquez sur le nom de l'ensemble de données. Les tables et les vues de l'ensemble de données s'affichent.

  2. Cliquez sur le nom de la table.

  3. Cliquez sur Détails. La page Détails de la table affiche la description et les informations de la table.

  4. Si la table est protégée par Cloud KMS, le champ Clé de chiffrement gérée par le client affiche l'ID de ressource de la clé.

    Table protégée

Modifier la clé Cloud KMS d'une table BigQuery

Pour modifier la clé Cloud KMS d'une table existante protégée par une clé de chiffrement gérée par le client, vous pouvez exécuter une requête ALTER TABLE, utiliser l'API ou l'outil de ligne de commande bq. Il existe deux commandes pour modifier la clé Cloud KMS à l'aide de l'API et de l'outil de ligne de commande : update ou cp. La commande update sert à modifier la clé Cloud KMS d'une table protégée par KMS. À l'inverse, la commande cp vous permet de modifier la clé Cloud KMS d'une table protégée par une clé CMEK, de remplacer le chiffrement par défaut par la protection CMEK, ou de remplacer la protection CMEK par le chiffrement par défaut. La commande update présente l'avantage d'être plus rapide que la commande cp et de permettre l'utilisation de décorateurs de table.

UI classique

  1. Accédez à l'UI Web de BigQuery.

    Accéder à l'UI Web de BigQuery

  2. Cliquez sur Saisir une requête.

  3. Saisissez votre instruction LDD dans la zone de texte Nouvelle requête. Dans le champ kms_key_name, spécifiez l'ID de ressource de la clé à utiliser pour protéger la table.

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

CLI

Vous pouvez exécuter la commande bq cp en spécifiant l'option --destination_kms_key pour modifier la clé d'une table protégée par Cloud KMS. L'option --destination_kms_key spécifie l'ID de ressource de la clé à utiliser avec la table.

bq update \
--destination_kms_key projects/project_id/locations/location/keyRings/key_ring/cryptoKeys/key \
-t dataset_id.table_id

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

Pour modifier la clé de chiffrement gérée par le client d'une table, spécifiez un autre objet EncryptionConfiguration pour la propriété Table.encryption_configuration et mettez à jour la table.

# 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

Définir une clé par défaut pour l'ensemble de données

Vous pouvez définir une clé Cloud KMS par défaut au niveau de l'ensemble de données. Celle-ci s'applique à toutes les tables nouvellement créées au sein de l'ensemble de données, à moins que vous ne spécifiiez une autre clé au moment de la création de la table. La clé par défaut ne s'applique pas aux tables existantes. La modification de la clé par défaut n'altère pas les tables existantes et s'applique uniquement aux tables créées après cette modification.

Vous pouvez définir, modifier ou supprimer la clé par défaut de l'ensemble de données de plusieurs manières :

Supprimer l'accès de BigQuery à la clé Cloud KMS

Vous pouvez supprimer l'accès de BigQuery à la clé Cloud KMS à tout moment en révoquant l'autorisation IAM associée à cette clé.

La révocation de l'accès de BigQuery à une clé Cloud KMS peut affecter considérablement l'expérience utilisateur et entraîner des pertes de données :

  • Les données des tables protégées par des clés de chiffrement gérées par le client ne sont plus accessibles. Les commandes query, cp, extract et tabledata.list échoueront toutes.

  • Aucune nouvelle donnée ne peut être ajoutée aux tables protégées par des clés CMEK.

  • Même si vous rétablissez l'accès, les performances des requêtes sur ces tables peuvent être réduites pendant plusieurs jours.

Impact de la rotation des clés Cloud KMS

BigQuery n'aligne pas automatiquement la rotation d'une clé de chiffrement de table avec la rotation de la clé Cloud KMS associée à la table. Les tables existantes continuent à utiliser la version de clé avec laquelle elles ont été créées. Les nouvelles tables utilisent la version de clé actuelle.

Limites

Accès de BigQuery à la clé Cloud KMS

Une clé Cloud KMS est considérée comme disponible et accessible par BigQuery si elle répond aux exigences suivantes :

  • La clé est activée.
  • Le compte de service BigQuery détient des autorisations de chiffrement et de déchiffrement sur la clé.

Les sections suivantes décrivent l'impact qu'une clé inaccessible peut avoir sur les insertions en flux continu et sur les données inaccessibles à long terme.

Impact sur les insertions en flux continu

La clé Cloud KMS doit être disponible et accessible pendant au moins 24 heures consécutives au cours des 48 heures qui suivent une requête d'insertion en flux continu. Dans le cas contraire, les données diffusées peuvent ne pas être entièrement conservées et risquent d'être perdues. Pour en savoir plus sur les insertions en flux continu, consultez la page Insérer des données en flux continu dans BigQuery.

Impact sur les données inaccessibles à long terme

Comme BigQuery assure un stockage géré, les données inaccessibles à long terme ne sont pas compatibles avec l'architecture de BigQuery. Si la clé Cloud KMS d'une table BigQuery spécifique n'est pas disponible ni accessible pendant 60 jours consécutifs, BigQuery peut choisir de supprimer la table et les données associées. Dans ce cas, BigQuery envoie un e-mail à l'adresse liée au compte de facturation au moins 7 jours avant la suppression.

Utiliser des décorateurs de table

Lorsque les données d'une table protégée par Cloud KMS sont remplacées via la disposition d'écriture WRITE_TRUNCATE pour les opérations load, cp ou query, vous ne pouvez plus interroger la table par le biais des décorateurs de table, selon l'heure du décorateur d'instantané.

En supposant qu'une table ait été remplacée à l'instant T et que la valeur snapshot_time du décorateur d'instantané soit antérieure à , le tableau suivant indique s'il est possible d'interroger snapshot_time ou non :

Type de chiffrement avant T Type de chiffrement après T snapshot_time
Chiffrement Cloud KMS Chiffrement Cloud KMS Interrogation non disponible
Chiffrement par défaut Chiffrement Cloud KMS Interrogation disponible
Chiffrement Cloud KMS Chiffrement par défaut Interrogation non disponible

Notez qu'une logique comparable s'applique à <time2> lorsqu'un décorateur de plage est utilisé.

Questions fréquentes

Qui doit détenir des autorisations sur la clé Cloud KMS ?

Si vous utilisez des clés de chiffrement gérées par le client, vous n'avez pas besoin de spécifier des autorisations à plusieurs reprises. Tant que le compte de service BigQuery est autorisé à utiliser la clé Cloud KMS pour effectuer des opérations de chiffrement et de déchiffrement, tous les membres ayant accès à la table BigQuery peuvent consulter les données (même s'ils ne disposent pas d'un accès direct à la clé Cloud KMS).

Quel compte de service est utilisé ?

Le compte de service BigQuery associé au projet Google Cloud de la table est utilisé pour déchiffrer les données qu'elle contient. Les comptes de service BigQuery sont uniques pour chaque projet. En outre, lorsque des données sont rédigées dans une table anonyme protégée par Cloud KMS, c'est le compte de service associé au projet où s'effectue la tâche qui est utilisé.

Prenons l'exemple de trois tables (table1, table2, table3) protégées par des clés de chiffrement gérées par le client. Pour interroger les données de {project1.table1, project2.table2} en utilisant la table de destination {project3.table3}, procédez comme suit :

  • Utiliser le compte de service project1 pour project1.table1
  • Utiliser le compte de service project2 pour project2.table2
  • Utiliser le compte de service project3 pour project3.table3

Comment BigQuery utilise-t-il ma clé Cloud KMS ?

BigQuery utilise la clé Cloud KMS pour déchiffrer des données en réponse à une requête utilisateur, par exemple, tabledata.list ou jobs.insert.

La clé permet également à BigQuery d'effectuer des tâches de maintenance des données et d'optimisation du stockage, telles que la conversion de données dans un format optimisé en lecture.

Quelles sont les bibliothèques de cryptographie utilisées ?

BigQuery s'appuie sur Cloud KMS pour gérer les fonctionnalités CMEK. Cloud KMS utilise Tink pour effectuer le chiffrement.

Comment obtenir de l'aide ?

Si vous ne trouvez pas de réponse à vos questions dans cette documentation, contactez cmek-feedback@google.com ou consultez les pages Assistance BigQuery et Assistance Cloud KMS.

Résoudre les erreurs

La section suivante décrit les erreurs courantes et présente les solutions recommandées.

Erreur Recommandation
Veuillez attribuer le rôle de chiffreur/déchiffreur de clés cryptographiques Cloud KMS Le compte de service BigQuery associé à votre projet ne dispose pas des autorisations Cloud IAM nécessaires pour utiliser la clé Cloud KMS spécifiée. Suivez les instructions fournies par l'erreur ou figurant dans cette documentation pour attribuer l'autorisation Cloud IAM appropriée.
Les paramètres de chiffrement de table existants ne correspondent pas aux paramètres spécifiés dans la requête Ce problème peut survenir lorsque la table de destination possède des paramètres de chiffrement différents de ceux de votre requête. Pour le résoudre, remplacez la table à l'aide de la disposition d'écriture TRUNCATE ou spécifiez une table de destination différente.
Vous ne pouvez pas sélectionner cette région La région de la clé Cloud KMS ne correspond pas à la région de l'ensemble de données BigQuery contenant la table de destination. Pour corriger cette erreur, sélectionnez une clé dans la région de votre ensemble de données ou chargez les données dans un ensemble de données appartenant à la même région que la clé.
Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Besoin d'aide ? Consultez notre page d'assistance.