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 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. 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 les sections concernant la création de trousseaux et de 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 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 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 classique

  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 le volet de 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.

CLI

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

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

CLI

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 du projet GCP exécutant Cloud KMS et project_number par le numéro (et non l'ID) du projet GCP exécutant BigQuery. Remplacez également kms_key_location, kms_key_ring et kms_key par l'emplacement, le trousseau de clés et les noms de clés associés à la 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, renseignez 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

Pour créer la table, utilisez l'outil de ligne de commande bq en incluant le paramètre --destination_kms_key. L'indicateur --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 Utiliser l'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 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

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. L'indicateur --destination_kms_key spécifie l'ID de ressource de la clé à utiliser avec la table de destination ou la table obtenue.

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/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 Utiliser l'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 :

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 la console GCP.
    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 Advanced options (Options avancées).
  5. Sous Encryption (Chiffrement), sélectionnez Customer-managed key (Clé gérée par le client).
  6. Cliquez sur le menu déroulant Select a customer-managed key (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, définissez l'indicateur --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

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

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 l'indicateur --destination_kms_key. L'indicateur --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 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 page Utiliser l'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'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 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

Pour modifier la clé Cloud KMS d'une table existante protégée par une clé CMEK, vous pouvez exécuter une requête ALTER TABLE, utiliser l'API ou utiliser l'outil de ligne de commande bq. Il existe deux manières de 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 d'utiliser des 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. Pour la valeur kms_key_name, spécifiez l'ID de ressource de la clé avec laquelle vous souhaitez protéger la table.

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

CLI

Pour modifier la clé d'une table protégée par Cloud KMS, exécutez la commande bq cp en incluant l'indicateur --destination_kms_key. L'indicateur --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

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

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

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.