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.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

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

Activate Cloud Shell
Assurez-vous que votre version du SDK Google Cloud est 366.0.0 ou ultérieure :
```
gcloud version
```
Si 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.create
- bigquery.connections.delete
- bigquery.connections.list
- bigquery.connections.update
Administrateur d'entrepôt de données :
- bigquery.tables.create
- bigquery.tables.update
- bigquery.connections.delegate
Analyste de données :
- bigquery.jobs.create
- bigquery.tables.get
- bigquery.tables.getData
- bigquery.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.

Accéder à 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_ID
```
Le paramètre --project_id remplace le projet par défaut.

Remplacez les éléments suivants :
- REGION : votre région de connexion
- PROJECT_ID : ID de votre projet Cloud
- CONNECTION_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 connexion
PROJECT_ID : ID de votre projet Cloud
REGION : 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.

Accéder à 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é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.

Accéder à 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.

Accéder à 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.

Accéder à 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_FILE par 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.