Créer et gérer des tables BigLake
Ce document explique comment mettre en œuvre des tables BigLake et part du principe que vous connaissez bien les tables de base de données et la gestion des autorisations. Pour obtenir une présentation des tables BigLake, consultez la page Présentation des tables BigLake.
Avant de commencer
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
Pour ce tutoriel, nous vous recommandons de créer un projet de test pour vous assurer que vos charges de travail de production ne sont pas affectées.
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the BigQuery Connection API.
Si vous souhaitez lire des tables BigLake à partir de moteurs Open Source tels qu'Apache Spark, vous devez activer l'API BigQuery Storage Read.
-
In the Google Cloud console, activate Cloud Shell.
Assurez-vous que votre version du SDK Google Cloud est 366.0.0 ou ultérieure :
gcloud versionSi nécessaire, mettez à jour le SDK Google Cloud.
Facultatif : Pour Terraform, utilisez Terraform version 4.25.0 ou ultérieure. Vous pouvez télécharger la dernière version sur la page de téléchargements de HashiCorp Terraform.
Autorisations IAM
Pour travailler avec des tables BigLake, vos utilisateurs ont besoin des autorisations IAM (Identity and Access Management) suivantes en fonction de leur rôle dans votre organisation. Pour en savoir plus sur les rôles utilisateur, consultez la page Modèle de sécurité. Pour en savoir plus sur l'attribution d'autorisations, consultez la page Afficher les rôles pouvant être attribués sur des ressources.
- Administrateur de lac de données :
bigquery.connections.createbigquery.connections.deletebigquery.connections.listbigquery.connections.update
- Administrateur d'entrepôt de données :
bigquery.tables.createbigquery.tables.updatebigquery.connections.delegate
- Analyste de données :
bigquery.jobs.createbigquery.tables.getbigquery.tables.getDatabigquery.readsessions.create
Considérations au sujet des zones
Si vous utilisez Cloud Storage pour stocker des fichiers de données, nous vous recommandons d'utiliser Cloud Storage comme zone régionale unique ou zone birégionale pour des performances optimales, et non pour les buckets multirégionaux.
Créer et afficher une ressource de connexion
BigLake utilise une ressource de connexion pour accéder aux lacs de données. Vous pouvez associer une ressource de connexion à une seule table ou à un groupe arbitraire de tables dans un projet.
Créer une connexion de ressource Cloud
Sélectionnez l'une des options suivantes :
Console
Accédez à la page BigQuery.
Pour créer une connexion, cliquez sur Ajouter des données, puis sur Source de données externe.
Dans la liste Type de connexion, sélectionnez BigLake et fonctions distantes (ressource Cloud).
Dans le champ ID de connexion, saisissez un nom pour votre connexion.
Cliquez sur Créer une connexion.
Dans le volet Explorateur, cliquez sur la connexion du projet que vous avez utilisé pour créer la ressource de connexion. Les informations de connexion s'affichent :
Dans la section Informations de connexion, copiez l'ID du compte de service car vous en aurez besoin dans une étape ultérieure.
bq
Dans un environnement de ligne de commande, créez une connexion :
bq mk --connection --location=REGION --project_id=PROJECT_ID \ --connection_type=CLOUD_RESOURCE CONNECTION_IDLe paramètre
--project_idremplace le projet par défaut.Remplacez les éléments suivants :
REGION: votre région de connexionPROJECT_ID: ID de votre projet CloudCONNECTION_ID: ID de votre connexion
Lorsque vous créez une ressource de connexion, BigQuery crée un compte de service système unique et l'associe à la connexion.
Récupérez et copiez l'ID du compte de service, car vous en aurez besoin dans une autre étape :
bq show --connection PROJECT_ID.REGION.CONNECTION_ID
Le résultat ressemble à ce qui suit :
name properties 1234.REGION.CONNECTION_ID {"serviceAccountId": "connection-1234-9u56h9@gcp-sa-bigquery-condel.iam.gserviceaccount.com"}
Terraform
Ajoutez la section suivante à votre fichier main.tf.
## This creates a cloud resource connection.
## Note: The cloud resource nested object has only one output only field - serviceAccountId.
resource "google_bigquery_connection" "connection" {
connection_id = "CONNECTION_ID"
project = "PROJECT_ID"
location = "REGION"
cloud_resource {}
}
Remplacez les éléments suivants :
CONNECTION_ID: ID de votre connexionPROJECT_ID: ID de votre projet CloudREGION: votre région de connexion
Si vous obtenez l'erreur de connexion suivante, mettez à jour le SDK Google Cloud :
Flags parsing error: flag --connection_type=CLOUD_RESOURCE: value should be one of...
Créer une connexion BigQuery AWS
Pour vous connecter à AWS, vous devez créer une connexion BigQuery AWS. Lorsque vous créez une ressource de connexion, BigQuery crée un ID unique et l'associe à la connexion.
Créer une connexion BigQuery Azure
BigQuery fournit deux méthodes pour accéder en toute sécurité aux données à partir d'Azure Blob Storage. Vous pouvez utiliser la fédération d'identité en accordant l'accès à votre application Azure à un compte de service Google Cloud, ou vous pouvez accorder directement l'accès à votre application Azure Active Directory (AD) dans votre locataire :
Configurer l'accès à un lac de données
Dans les étapes suivantes, vous allez accorder à la nouvelle ressource de connexion un accès en lecture seule à un lac de données afin que BigQuery puisse accéder aux fichiers pour le compte des utilisateurs.
Configurer l'accès à Cloud Storage
Sélectionnez l'une des options suivantes :
Console
Nous vous recommandons d'attribuer au compte de service de ressource de connexion le rôle IAM Lecteur des objets de l'espace de stockage (roles/storage.objectViewer), qui permet au compte de service d'accéder aux buckets Cloud Storage.
Console
Accédez à la page IAM et administration.
Cliquez sur Ajouter.
La boîte de dialogue Ajouter des comptes principaux s'ouvre.
Dans le champ Nouveaux comptes principaux, saisissez l'ID du compte de service que vous avez copié précédemment.
Dans le champ Sélectionner un rôle, sélectionnez Cloud Storage, puis Lecteur des objets Storage.
Cliquez sur Enregistrer.
gsutil
Exécutez la commande gsutil iam ch :
gsutil iam ch serviceAccount:MEMBER:objectViewer gs://example-bucket
Remplacez MEMBER par l'ID du compte de service que vous avez copié précédemment, par exemple example@gcp-sa-bigquery-condel.iam.gserviceaccount.com.
Pour plus d'informations, consultez la section Ajouter un compte principal à une stratégie au niveau du bucket.
Terraform
Ajoutez la section suivante à votre fichier main.tf.
## This grants permissions to the service account of the connection created in the last step.
resource "google_project_iam_member" "connectionPermissionGrant" {
project = "PROJECT_ID"
role = "roles/storage.objectViewer"
member = format("serviceAccount:%s", google_bigquery_connection.connection.cloud_resource[0].service_account_id)
} Après avoir migré les utilisateurs vers des tables BigLake, supprimez leurs autorisations pour accéder directement à Cloud Storage. L'accès direct aux fichiers permet aux utilisateurs d'ignorer les règles de gouvernance (telles que la sécurité au niveau des lignes et des colonnes) définies sur les tables BigLake.
Configurer l'accès à Amazon S3
Pour accéder aux données S3, vous devez ajouter une relation d'approbation au rôle AWS. Toutefois, si votre compte AWS dispose d'un fournisseur d'identité personnalisé, suivez les instructions de la section Configurer un fournisseur d'identité AWS personnalisé.
Configurer l'accès à Azure
Les étapes de configuration de l'accès à votre application Azure varient en fonction de la connexion à Azure. Si vous utilisez la fédération d'identité pour accéder aux données stockées dans Azure, procédez comme suit :
- Ajoutez l'identifiant fédéré à l'application Azure.
- Attribuez un rôle aux applications Azure de BigQuery.
Si vous avez utilisé une identité non fédérée, procédez comme suit :
- Créez un compte principal de service Azure AD.
- Attribuez un rôle aux applications Azure AD de BigQuery.
Créer une table BigLake
Si vous savez comment créer des tables dans BigQuery, le processus de création d'une table BigLake est similaire. La table peut être dans n'importe quel format de fichier compatible avec BigLake. Pour en savoir plus, consultez la section Limites.
Créer une table BigLake pour Cloud Storage
Avant de créer une table BigLake, vous devez disposer d'un ensemble de données. Pour créer une table BigLake, choisissez l'une des options suivantes :
Console
Accédez à la page BigQuery.
Dans le volet Explorateur, sélectionnez l'ensemble de données dans lequel vous souhaitez créer une table, puis cliquez sur Créer une table.
Dans Créer une table à partir de, sélectionnez Google Cloud Storage, puis la source de données de la table externe dans votre bucket Cloud Storage.
Pour Format de fichier, sélectionnez le format correspondant à votre fichier.
Dans le champ Table, saisissez un nom pour votre table (par exemple,
mytable).Sous Type de table, définissez le type de table sur Table externe. Par défaut, la case Créer une table BigLake à l'aide d'une connexion à une ressource cloud est cochée.
Pour ID de connexion, sélectionnez la connexion que vous avez créée précédemment.
Cliquez sur Créer une table.
SQL
Pour créer une table BigLake en vous connectant à une table Cloud Storage externe, utilisez l'instruction LDD CREATE EXTERNAL TABLE :
Dans la console Google Cloud, accédez à la page BigQuery.
Dans l'éditeur de requête, saisissez l'instruction suivante :
CREATE EXTERNAL TABLE `PROJECT_ID.DATASET.EXTERNAL_TABLE_NAME` WITH CONNECTION `PROJECT_ID.REGION.CONNECTION_ID` OPTIONS ( format ="TABLE_FORMAT", uris = ['FILE_PATH']);
Remplacez les éléments suivants :
DATASET: nom de l'ensemble de données BigQuery dans lequel vous souhaitez créer une table, par exemple,mydataset.EXTERNAL_FILE_NAME: nom de la table que vous souhaitez créer (par exemple,mytable).TABLE_FORMAT: format de la table que vous souhaitez créer (par exemple,PARQUET)FILE_PATH: chemin d'accès à la source de données de la table externe que vous souhaitez créer (par exemple,gs://mybucket/myfile.parquet)
Cliquez sur Exécuter.
Pour en savoir plus sur l'exécution des requêtes, consultez la page Exécuter des requêtes interactives.
bq
Dans un environnement de ligne de commande, utilisez le décorateur @connection pour spécifier la connexion à utiliser à la fin du paramètre --external_table_definition :
bq mk \
--table \
--external_table_definition=TABLE_FORMAT=FILE_PATH@projects/PROJECT_ID/locations/REGION/connections/CONNECTION_ID \
PROJECT_ID:DATASET.EXTERNAL_TABLE_NAME
Remplacez les éléments suivants :
TABLE_FORMAT: nom de la table que vous souhaitez créer (par exemple,PARQUET).FILE_PATH: chemin d'accès à la source de données de la table externe que vous souhaitez créer (par exemple,gs://mybucket/myfile.parquet)DATASET: nom de l'ensemble de données BigQuery dans lequel vous souhaitez créer une table, par exemple,mydataset.EXTERNAL_TABLE_NAME: nom de la table que vous souhaitez créer (par exemple,mytable).
Terraform
Ajoutez la section suivante à votre fichier main.tf.
Si vous utilisez la détection automatique de schéma, annulez la mise en commentaire des lignes correspondantes dans la section suivante.
## This creates a dataset for your table.
resource "google_bigquery_dataset" "dataset" {
provider = google
project = "PROJECT_ID"
dataset_id = "DATASET"
location = "REGION"
}
## If you are using schema autodetect, uncomment the following to set up
## a delay to give IAM changes time to propagate.
#resource "time_sleep" "wait_7_min" {
#depends_on = [google_project_iam_member.connectionPermissionGrant]
#create_duration = "7m"
#}
## This creates a table using the connection id.
resource "google_bigquery_table" "biglakeTable" {
## If you are using schema autodetect, uncomment the following to
## set up a dependency on the prior delay.
# depends_on = [time_sleep.wait_7_min]
dataset_id = google_bigquery_dataset.dataset.dataset_id
table_id = "EXTERNAL_TABLE_NAME"
project = "PROJECT_ID"
schema = <<EOF
[
{
"name": "country",
"type": "STRING"
},
{
"name": "product",
"type": "STRING"
},
{
"name": "price",
"type": "INT64"
}
]
EOF
external_data_configuration {
## Autodetect determines whether schema autodetect is active or inactive.
autodetect = AUTODETECT_BOOLEAN
source_format = "PARQUET"
connection_id = google_bigquery_connection.connection.name
source_uris = [
"gs://huron-userguide-demo/orders/*.parquet",
]
}
deletion_protection = false
}
Remplacez les éléments suivants :
DATASET: nom de l'ensemble de données BigQuery dans lequel vous souhaitez créer une table, par exemple,mydataset.EXTERNAL_TABLE_NAME: nom de la table que vous souhaitez créer (par exemple,mytable).AUTODETECT_BOOLEAN: indique si vous utilisez la détection automatique de schéma dans votre projet (par exemple, "true" ou "false").
BigLake est compatible avec la détection automatique de schéma. Toutefois, si vous n'avez pas fourni de schéma et que le compte de service n'a pas reçu d'accès lors des étapes précédentes, ces étapes échouent avec un message d'accès refusé si vous essayez de détecter automatiquement le schéma.
Créer une table BigLake pour Amazon S3
Pour accéder aux données stockées dans S3, vous avez besoin d'une table externe. Pour créer une table BigLake pour Amazon S3, suivez les instructions de la section Créer une table externe pour les données Amazon S3.
Créer une table BigLake pour Azure
Pour accéder aux données stockées dans le stockage Azure, vous avez besoin d'une table externe. Pour créer une table BigLake pour le stockage Azure, suivez les instructions de la section Créer une table externe pour les données Azure Storage.
Mettre à niveau des tables externes vers des tables BigLake
Vous pouvez mettre à niveau des tables externes vers des tables BigLake en associant la table externe à une connexion à une ressource cloud. Pour obtenir la liste complète des options et des arguments, consultez les rubriques de référence bq update et bq mkdef.
Vous pouvez utiliser n'importe quel format source compatible avec BigLake. Pour en savoir plus, consultez la section Limites.
Pour mettre à jour une table externe vers une table BigLake, sélectionnez l'une des options suivantes :
SQL
L'exemple suivant utilise l'instruction LDD CREATE OR REPLACE EXTERNAL TABLE pour mettre à niveau les tables externes vers des tables BigLake en associant la table externe à une connexion de ressource Cloud :
Dans la console Google Cloud, accédez à la page BigQuery.
Dans l'éditeur de requête, saisissez l'instruction suivante :
CREATE OR REPLACE EXTERNAL TABLE `EXTERNAL_TABLE_NAME` WITH CONNECTION `CONNECTION_ID` OPTIONS( format="TABLE_FORMAT", uris="[FILE_PATH]" )Remplacez les éléments suivants :
DATASET: nom de l'ensemble de données BigQuery dans lequel vous souhaitez créer une table, par exemple,mydataset.EXTERNAL_FILE_NAME: nom de la table que vous souhaitez créer (par exemple,mytable).TABLE_FORMAT: format de la table que vous souhaitez créer (par exemple,PARQUET)FILE_PATH: chemin d'accès à la source de données de la table externe que vous souhaitez créer (par exemple,gs://mybucket/myfile.parquet)
Cliquez sur Exécuter.
Pour en savoir plus sur l'exécution des requêtes, consultez la page Exécuter des requêtes interactives.
bq
Générez une nouvelle définition de table externe qui spécifie la connexion à utiliser :
bq mkdef --connection_id=PROJECT_ID.REGION.CONNECTION_ID \ --source_format=TABLE_FORMAT \ "FILE_PATH" > /tmp/DEFINITION_FILE
Remplacez
DEFINITION_FILEpar le nom du fichier de définition de table que vous souhaitez créer, par exemple,tabledefinition.json.Mettez à jour la table en utilisant la nouvelle définition de table externe :
bq update --external_table_definition=/tmp/DEFINITION_FILE PROJECT_ID:DATASET.EXTERNAL_TABLE_NAME
Configurer des stratégies de contrôle d'accès
Pour créer des stratégies de contrôle d'accès pour les tables BigLake, vous devez d'abord créer une taxonomie de tags avec stratégie dans Data Catalog. Ensuite, appliquez les tags avec stratégie aux lignes ou aux colonnes sensibles.
Pour obtenir des instructions sur la configuration de la sécurité au niveau des colonnes, consultez le guide de la sécurité au niveau des colonnes.
Le workflow permettant de définir des stratégies de contrôle d'accès au niveau des colonnes pour BigLake est identique à celui des tables gérées par BigQuery.
Pour savoir comment configurer la sécurité au niveau des lignes, consultez le guide de la sécurité au niveau des lignes.
Par exemple, supposons que vous souhaitez limiter l'accès aux lignes de la table mytable dans l'ensemble de données mydataset :
+---------+---------+-------+ | country | product | price | +---------+---------+-------+ | US | phone | 100 | | JP | tablet | 300 | | UK | laptop | 200 | +---------+---------+-------+
Vous pouvez créer un filtre au niveau de la ligne pour Kim (kim@example.com), qui limite son accès aux lignes où country est égal à US.
CREATE ROW ACCESS POLICY only_us_filter ON mydataset.mytable GRANT TO ('user:kim@example.com') FILTER USING (country = 'US');
Kim peut ensuite exécuter la requête suivante :
SELECT * FROM projectid.mydataset.mytable;
Le résultat n'affiche que les lignes où country est égal à US :
+---------+---------+-------+ | country | product | price | +---------+---------+-------+ | US | phone | 100 | +---------+---------+-------+
Interroger une table BigLake via BigQuery
Vous pouvez utiliser n'importe quel client BigQuery pour envoyer une requête. Si vous utilisez l'outil de ligne de commande bq, exécutez la commande query et spécifiez la syntaxe SQL standard Google en utilisant l'option --nouse_legacy_sql ou --use_legacy_sql=false. Exemple :
bq query --nouse_legacy_sql "SELECT * FROM PROJECT_ID.DATASET.EXTERNAL_TABLE_NAME;"
Interroger une table BigLake en utilisant des connecteurs
Vous pouvez accéder aux tables BigLake sur Cloud Storage à l'aide d'autres outils de traitement de données que BigQuery. Par exemple, vous pouvez utiliser Apache Spark, Trino ou Apache Hive. à l'aide de connecteurs BigQuery. L'API BigQuery Storage applique des règles de gouvernance au niveau des lignes et des colonnes pour toutes les tables BigLake dans Cloud Storage ou BigQuery.
Spark
L'exemple suivant utilise Dataproc, mais fonctionne également avec tous les déploiements Spark utilisant le connecteur Spark BigQuery.
Dans cet exemple, vous fournissez le connecteur Spark BigQuery en tant qu'action d'initialisation lorsque vous créez un cluster. Cette action vous permet d'utiliser un notebook Zeppelin et d'implémenter un parcours utilisateur pour les analystes de données.
Créez un cluster à nœud unique en exécutant l'action d'initialisation du connecteur Spark BigQuery :
gcloud dataproc clusters create biglake-demo-cluster \ --optional-components=ZEPPELIN \ --region=REGION \ --enable-component-gateway \ --single-node \ --initialization-actions gs://goog-dataproc-initialization-actions-us-central1/connectors/connectors.sh \ --metadata bigquery-connector-url=gs://spark-lib/bigquery/spark-bigquery-latest_2.12.jar \ --metadata spark-bigquery-connector-url=gs://spark-lib/bigquery/spark-bigquery-latest_2.12.jar
Dataflow
Pour lire les tables BigLake de Dataflow, utilisez le connecteur Dataflow en mode DIRECT_READ afin d'utiliser l'API BigQuery Storage. La lecture à partir d'une chaîne de requête est également acceptée. Consultez la page E/S BigQuery dans la documentation Apache Beam.
Journaux d'audit
Pour plus d'informations sur la journalisation dans BigQuery, consultez la page Présentation de la surveillance BigQuery. Pour en savoir plus sur la journalisation dans Google Cloud, consultez la page Cloud Logging.