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

Par défaut, BigQuery chiffre les contenus client stockés au repos. Le service traite et gère ce chiffrement par défaut sans requérir la moindre action 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 Gérer les 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. Dans ce cas, vous ne dépendez plus de Google pour la gestion des clés de chiffrement de clés dans Cloud KMS, mais effectuez cette tâche vous-même. Cet article aborde cette technique plus en détail.

Renseignez-vous au sujet des options de chiffrement sur Google Cloud Platform.

Avant de commencer

  1. Comprenez le fonctionnement des ensembles de données, des tables et des requêtes.

  2. Choisissez d'exécuter BigQuery et Cloud KMS dans un même projet GCP ou au sein de différents projets. 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 les numéros de projet GCP, 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. Sur le projet GCP qui exécute Cloud KMS, accomplissez les étapes suivantes :

    1. Activez l'API Cloud KMS.
    2. Créez un trousseau de clés et une clé, comme décrit dans la section Créer des trousseaux de clés et des clés. Créez le trousseau de clés dans la même zone que l'ensemble de données BigQuery :
      • Les ensembles de données multirégionaux doivent utiliser des trousseaux de clés multirégionaux situés dans la même zone. 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 identiques. Par exemple, un ensemble de données situé 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 zones compatibles avec BigQuery et Cloud KMS, consultez la section Zones 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 Platform, identifiez l'ID du compte de service BigQuery et attribuez-lui un rôle permettant d'effectuer des opérations de chiffrement et de déchiffrement à l'aide de Cloud KMS.

Identifier l'ID du compte de service

UI Web

  1. Accédez à l'interface utilisateur Web de BigQuery.

    Accéder à l'UI Web de BigQuery

  2. Cliquez sur l'icône de flèche vers le bas flèche vers le bas à côté du nom de votre projet dans la navigation, puis cliquez sur Customer-Managed Encryption (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 Copy (Copier) pour copier l'ID du compte de service dans le presse-papiers, puis sur OK pour fermer la boîte de dialogue utilisateur.

Ligne de commande

Pour identifier l'ID du compte de service, exécutez la commande bq show en spécifiant le paramètre --encryption_service_account :

bq show --encryption_service_account

La commande affiche l'ID du compte de service :

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

Attribuer le rôle de chiffreur/déchiffreur

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

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

UI Web

  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 n'apparaît pas dans la liste des membres, c'est qu'il ne possède aucun rôle. 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 des rôles actuels pour le 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 attribuer le rôle au compte de service bq-[PROJECT_NUMBER]@bigquery-encryption.iam.gserviceaccount.com.

Ligne de commande

Vous pouvez attribuer le rôle à l'aide de l'outil de ligne de commande gcloud :

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 [KMS_PROJECT_ID] par l'ID de votre projet GCP exécutant Cloud KMS, remplacez [PROJECT_NUMBER] par le numéro de projet (et non l'ID de projet) de votre projet GCP exécutant BigQuery et remplacez [KMS_KEY_LOCATION], [KMS_KEY_RING], [KMS_KEY_RING], [KMS_KEY] par l'emplacement, le trousseau de clés et les noms de clé de votre clé Cloud KMS.

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 Web

  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 BigQuery, puis cliquez sur Créer une table.

  2. Sur la page Créer une table, renseignez les informations nécessaires pour créer une table vide sans schéma ou 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 pour la clé de chiffrement gérée par le client, saisissez l'ID de ressource de la clé. Cette clé se présente au format suivant :
      projects/[PROJECT_ID]/locations/[LOCATION]/keyRings/[KEYRING]/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 clé.
  3. Cliquez sur Créer une table.

Ligne de commande

Pour créer la table, utilisez l'outil de ligne de commande bq en incluant le paramètre --destination_kms_key. Le paramètre --destination_kms_key spécifie l'ID de ressource de la clé à utiliser avec la table. Cette clé se présente au format suivant :

projects/[PROJECT_ID]/locations/[LOCATION]/keyRings/[KEYRING]/cryptoKeys/[KEY]
Pour plus d'informations sur la récupération de l'ID de ressource de clé, consultez la section sur l'ID de ressource de clé [Key resource ID](/kms/docs/object-hierarchy#key_resource_id). 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/[KEYRING]/cryptoKeys/[KEY] \
mydataset.newtable

Vous pouvez également utiliser une instruction DDL :

bq query --use_legacy_sql=false "
  CREATE TABLE mydataset.newtable (name STRING, value INT64)
  OPTIONS(
    kms_key_name='projects/[PROJECT_ID]/locations/[LOCATION]/keyRings/[KEYRING]/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/[KEYRING]/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 section Outil de ligne de commande bq.

Go

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
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-central1/keyRings/test/cryptoKeys/test",
	},
}
if err := tableRef.Create(ctx, meta); err != nil {
	return err
}

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-central1', '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 Web

  1. Cliquez sur le bouton Saisir une requête dans l'UI 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é. Cette clé se présente au format suivant :

    projects/[PROJECT_ID]/locations/[LOCATION]/keyRings/[KEYRING]/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 clé.

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

Ligne de commande

Pour protéger la table de destination ou les résultats de requête (si vous utilisez une table temporaire) à l'aide de votre clé Cloud KMS, incluez le paramètre --destination_kms_key. Le paramètre --destination_kms_key spécifie l'ID de ressource de la clé à utiliser avec la table de destination ou la table obtenue. Cette clé se présente au format suivant :

projects/[PROJECT_ID]/locations/[LOCATION]/keyRings/[KEYRING]/cryptoKeys/[KEY]
Pour plus d'informations sur la récupération de l'ID de ressource de clé, consultez la section sur l'ID de ressource de clé [Key resource ID](/kms/docs/object-hierarchy#key_resource_id). Vous pouvez également spécifier la destination des résultats de requête à l'aide du paramètre --destination_table. Si --destination_table n'est pas spécifié, les résultats de requête apparaissent 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/[KEYRING]/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 section Outil de ligne de commande bq.

Go

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(destDatasetID).Table(destTableID)
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",
}
return runAndRead(ctx, client, q)
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.Println(row)
}

Python

Pour protéger une table de destination de requêtes à 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 exécutez la requête.

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

job_config = bigquery.QueryJobConfig()

# Set the destination table. Here, dataset_id is a string, such as:
# dataset_id = 'your_dataset_id'
table_ref = client.dataset(dataset_id).table('your_table_id')
job_config.destination = table_ref

# 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-central1', 'test', 'test')
encryption_config = bigquery.EncryptionConfiguration(
    kms_key_name=kms_key_name)
job_config.destination_encryption_configuration = encryption_config

# Start the query, passing in the extra configuration.
query_job = client.query(
    'SELECT 17 AS my_col;',
    # Location must match that of the dataset(s) referenced in the query
    # and of the destination table.
    location='US',
    job_config=job_config)  # API request - starts the query
query_job.result()

# The destination table is written using the encryption configuration.
table = client.get_table(table_ref)
assert table.encryption_configuration.kms_key_name == kms_key_name

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 :

Go

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
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())
}

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-central1', '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 en matière de disponibilité et d'accessibilité des clés.

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

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

Ligne de commande

Pour copier une table utilisant le chiffrement par défaut dans une nouvelle table (ou dans la table d'origine) protégée par Cloud KMS, exécutez la commande bq cp en incluant le paramètre --destination_kms_key. Le paramètre --destination_kms_key spécifie l'ID de ressource de la clé à utiliser avec la table de destination. Cette clé se présente au format suivant :

projects/[PROJECT_ID]/locations/[LOCATION]/keyRings/[KEYRING]/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 clé.

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/[KEYRING]/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/[KEYRING]/cryptoKeys/[KEY] \
sourceDataset.sourceTableId sourceDataset.sourceTableId

Si vous souhaitez remplacer la protection 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 le paramètre --destination_kms_key.

Pour en savoir plus sur l'outil de ligne de commande bq, consultez la section Outil de ligne de commande bq.

Go

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
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
}

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
# client = bigquery.Client()

source_dataset = bigquery.DatasetReference(
    'bigquery-public-data', 'samples')
source_table_ref = source_dataset.table('shakespeare')

# dataset_id = 'my_dataset'
dest_dataset_ref = client.dataset(dataset_id)
dest_table_ref = dest_dataset_ref.table('destination_table')

# 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-central1', 'test', 'test')
encryption_config = bigquery.EncryptionConfiguration(
    kms_key_name=kms_key_name)
job_config = bigquery.CopyJobConfig()
job_config.destination_encryption_configuration = encryption_config

job = client.copy_table(
    source_table_ref,
    dest_table_ref,
    # Location must match that of the source and destination tables.
    location='US',
    job_config=job_config)  # API request
job.result()  # Waits for job to complete.

assert job.state == 'DONE'
dest_table = client.get_table(dest_table_ref)
assert dest_table.encryption_configuration.kms_key_name == kms_key_name

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

  1. Dans l'UI 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 relatives à 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

Vous pouvez modifier la clé Cloud KMS d'une table existante protégée par une clé CMEK à l'aide de l'API ou de l'outil de ligne de commande bq. Deux commandes permettent d'effectuer cette opération : update et 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 permet d'utiliser des décorateurs de table.

Ligne de commande

Pour modifier la clé d'une table protégée par Cloud KMS, exécutez la commande bq cp en incluant le paramètre --destination_kms_key. Le paramètre --destination_kms_key spécifie l'ID de ressource de la clé à utiliser avec la table. Cette clé se présente au format suivant :

projects/[PROJECT_ID]/locations/[LOCATION]/keyRings/[KEYRING]/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 clé.

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

Go

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
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
}

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-central1/'
    '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

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 CMEK ne sont plus accessibles. Les commandes query, cp, extract et tabledata.list échouent.

  • 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 demande 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 section 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 de 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 à T, 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é ?

Les données d'une table sont déchiffrées par le compte de service BigQuery associé au projet GCP contenant cette table. 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 et table3) protégées par des clés CMEK. Pour interroger les données de {project1.table1, project2.table2} en utilisant la table de destination {project3.table3} :

  • le compte de service project1 est utilisé pour project1.table1 ;
  • le compte de service project2 est utilisé pour project2.table2 ;
  • le compte de service project3 est utilisé pour project3.table3.

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

BigQuery utilise la clé Cloud KMS pour déchiffrer les données en réponse à une requête de l'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.

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 articles de l'assistance BigQuery et de l'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-en une dans un ensemble de données appartenant à la même région que la table.

Problèmes connus

  • Les bibliothèques clientes BigQuery ne sont pas encore compatibles avec les commandes de configuration des clés de chiffrement gérées par le client.
Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

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