Créer des tables BigLake Blob Storage

Ce document explique comment créer une table Azure BigLake Blob Storage. Une table BigLake vous permet d'utiliser la délégation d'accès pour interroger des données dans Blob Storage. La délégation d'accès dissocie l'accès à la table BigLake de l'accès au data store sous-jacent.

Pour plus d'informations sur la manière dont les données circulent entre BigQuery et Blob Storage, consultez la page Flux de données lors de l'interrogation de données.

Avant de commencer

Assurez-vous de disposer d'une connexion pour accéder aux données stockées dans Blob Storage.

Rôles requis

Pour obtenir les autorisations nécessaires pour créer une table externe, demandez à votre administrateur de vous accorder le rôle IAM Administrateur BigQuery (roles/bigquery.admin) sur votre ensemble de données. Pour en savoir plus sur l'attribution de rôles, consultez la section Gérer les accès.

Ce rôle prédéfini contient les autorisations requises pour créer une table externe. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour créer une table externe :

bigquery.tables.create
bigquery.connections.delegate

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés ou d'autres rôles prédéfinis.

Créer un ensemble de données

Avant de créer une table externe, vous devez créer un ensemble de données dans la région disponible. Sélectionnez l'une des options suivantes :

Console

Accédez à la page BigQuery.

Accéder à BigQuery
Dans le panneau Explorateur, sélectionnez le projet dans lequel vous souhaitez créer l'ensemble de données.
Développez l'option Afficher les actions, puis cliquez sur Créer un ensemble de données.
Sur la page Créer un ensemble de données, spécifiez les détails suivants :

Pour Dataset ID (ID de l'ensemble de données), renseignez le nom unique de l'ensemble de données.
Pour Emplacement des données, choisissez une région compatible.
Facultatif : Pour supprimer automatiquement les tables, cochez la case Activer l'expiration de la table et définissez l'âge maximal par défaut de la table en jours. Les données dans Azure ne sont pas supprimées à l'expiration de la table.
Si vous souhaitez utiliser le classement par défaut, développez la section Options avancées, puis sélectionnez l'option Activer le classement par défaut.
Cliquez sur Créer un ensemble de données.

SQL

Utilisez l'instruction LDD CREATE SCHEMA : L'exemple suivant crée un ensemble de données dans la région azure-eastus2 :

Dans la console Google Cloud, accédez à la page BigQuery.

Accéder à BigQuery

Dans l'éditeur de requête, saisissez l'instruction suivante :

CREATE SCHEMA mydataset
OPTIONS (
  location = 'azure-eastus2');

Cliquez sur Exécuter.

Pour en savoir plus sur l'exécution des requêtes, consultez Exécuter une requête interactive.

bq

Dans un environnement de ligne de commande, créez un ensemble de données à l'aide de la commande bq mk :

bq --location=LOCATION mk \
    --dataset \
PROJECT_ID:DATASET_NAME

Le paramètre --project_id remplace le projet par défaut.

Remplacez les éléments suivants :

LOCATION : emplacement de votre ensemble de données

Pour en savoir plus sur les régions disponibles, consultez la page Emplacements. Une fois que vous avez créé un ensemble de données, vous ne pouvez plus modifier son emplacement. Vous pouvez spécifier une valeur par défaut pour l'emplacement à l'aide du fichier .bigqueryrc.
PROJECT_ID : ID de votre projet.
DATASET_NAME : nom de l'ensemble de données que vous souhaitez créer

Pour créer un ensemble de données dans un projet autre que votre projet par défaut, ajoutez l'ID du projet au nom de l'ensemble de données de la manière suivante : PROJECT_ID:DATASET_NAME.

Créer des tables BigLake sur des données non partitionnées

Sélectionnez l'une des options suivantes :

Console

Accédez à la page BigQuery.

Accéder à BigQuery
Dans le volet Explorateur, développez votre projet, puis sélectionnez un ensemble de données.
Dans la section Informations sur l'ensemble de données, cliquez sur Créer une table.
Dans la section Source de la page Create table (Créer une table), procédez comme suit :
1. Dans Créer une table à partir de, sélectionnez Azure Blob Storage.
2. Pour Sélectionner le chemin d'accès Azure Blob Storage, saisissez un chemin d'accès Blob Storage au format suivant : azure://AZURE_STORAGE_ACCOUNT_NAME.blob.core.windows.net/CONTAINER_NAME/FILE_PATH
  
  Remplacez les éléments suivants :
  - AZURE_STORAGE_ACCOUNT_NAME : nom du compte Blob Storage. La région du compte doit être identique à celle de l'ensemble de données.
  - CONTAINER_NAME : nom du conteneur Blob Storage.
  - FILE_PATH : chemin d'accès aux données qui pointe vers les données Blob Storage. Par exemple, pour un seul fichier CSV, FILE_PATH peut être myfile.csv.
3. Dans le champ Format de fichier, sélectionnez le format de données Azure. Les formats acceptés sont AVRO, CSV, DELTA_LAKE, ICEBERG, JSONL, ORC et PARQUET.
Dans la section Destination, procédez comme suit :
1. Dans le champ Ensemble de données, sélectionnez l'ensemble de données approprié.
2. Dans le champ Table, saisissez le nom de la table.
3. Vérifiez que le paramètre Type de table est défini sur Table externe.
4. Dans le champ ID de connexion, sélectionnez l'ID de connexion approprié dans la liste déroulante. Pour en savoir plus sur les connexions, consultez la section Se connecter à Blob Storage.
Dans la section Schéma, vous pouvez activer la détection automatique de schéma ou spécifier manuellement un schéma si vous disposez d'un fichier source. Si vous ne disposez pas d'un fichier source, vous devez spécifier manuellement un schéma.
- Pour activer la détection automatique de schéma, sélectionnez l'option Détection automatique.
- Pour spécifier manuellement un schéma, ne cochez pas l'option Détection automatique. Activez Modifier sous forme de texte et saisissez le schéma de la table sous forme de tableau JSON.
Cliquez sur Créer une table.

SQL

Pour créer une table BigLake, utilisez l'instruction CREATE EXTERNAL TABLE avec la clause WITH CONNECTION :

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 DATASET_NAME.TABLE_NAME
WITH CONNECTION `AZURE_LOCATION.CONNECTION_NAME`
  OPTIONS (
    format = 'DATA_FORMAT',
    uris = ['azure://AZURE_STORAGE_ACCOUNT_NAME.blob.core.windows.net/CONTAINER_NAME/FILE_PATH']);
```
Remplacez les éléments suivants :
- DATASET_NAME : nom de l'ensemble de données créé
- TABLE_NAME : nom à attribuer à la table
- AZURE_LOCATION : emplacement Azure dans Google Cloud (tel que azure-eastus2)
- CONNECTION_NAME : nom de la connexion créée
- DATA_FORMAT : tout format BigQuery fédéré accepté, tel que AVRO, CSV, DELTA_LAKE ou ICEBERG (preview)
- AZURE_STORAGE_ACCOUNT_NAME : nom du compte Blob Storage
- CONTAINER_NAME : nom du conteneur Blob Storage
- FILE_PATH : chemin d'accès aux données qui pointe vers les données Blob Storage
Cliquez sur Exécuter.

Pour en savoir plus sur l'exécution des requêtes, consultez Exécuter une requête interactive.

Exemple :

CREATE EXTERNAL TABLE absdataset.abstable
WITH CONNECTION `azure-eastus2.abs-read-conn`
  OPTIONS (
    format = 'CSV', uris = ['azure://account_name.blob.core.windows.net/container/path/file.csv']);

bq

Créer un fichier de définition de table

bq mkdef  \
    --source_format=DATA_FORMAT \
    --connection_id=AZURE_LOCATION.CONNECTION_NAME \
    "azure://AZURE_STORAGE_ACCOUNT_NAME.blob.core.windows.net/CONTAINER_NAME/FILE_PATH" > table_def

Remplacez les éléments suivants :

DATA_FORMAT : tout format BigQuery fédéré accepté, tel que AVRO, CSV, ICEBERG ou PARQUET
AZURE_LOCATION : emplacement Azure dans Google Cloud (tel que azure-eastus2)
CONNECTION_NAME : nom de la connexion que vous avez créée
AZURE_STORAGE_ACCOUNT_NAME : nom du compte Blob Storage
CONTAINER_NAME : nom du conteneur Blob Storage
FILE_PATH : chemin d'accès aux données qui pointe vers les données Blob Storage

Ensuite, créez la table BigLake :

bq mk --external_table_definition=table_def DATASET_NAME.TABLE_NAME

Remplacez les éléments suivants :

DATASET_NAME : nom de l'ensemble de données que vous avez créé
TABLE_NAME : nom que vous souhaitez attribuer à cette table

Par exemple, les commandes suivantes créent une table BigLake, my_dataset.my_table, qui peut interroger vos données Blob Storage stockées dans le chemin azure://account_name.blob.core.windows.net/container/path et dispose d'une connexion en lecture à l'emplacement azure-eastus2 :

bq mkdef \
    --source_format=AVRO \
    --connection_id=azure-eastus2.read-conn \
    "azure://account_name.blob.core.windows.net/container/path" > table_def

bq mk \
    --external_table_definition=table_def my_dataset.my_table

API

Appelez la méthode API tables.insert, puis créez un objet ExternalDataConfiguration dans la ressource Table que vous transmettez.

Spécifiez la propriété schema ou définissez la propriété autodetect sur true pour activer la détection automatique du schéma pour les sources de données acceptées.

Spécifiez la propriété connectionId pour identifier la connexion à utiliser pour la connexion à Blob Storage.

Créer des tables BigLake sur des données partitionnées

Vous pouvez créer une table BigLake pour les données partitionnées Hive dans Blob Storage. Une fois la table partitionnée en externe créée, vous ne pouvez pas modifier la clé de partition. Vous devez recréer la table pour modifier la clé de partition.

Pour créer une table BigLake basée sur des données partitionnées Hive, sélectionnez l'une des options suivantes :

Console

Accédez à la page BigQuery.

Accéder à BigQuery
Dans le volet Explorateur, développez votre projet et sélectionnez un ensemble de données.
Cliquez sur Afficher les actions, puis sur Créer une table. Le volet Créer une table s'ouvre.
Dans la section Source, spécifiez les détails suivants :
1. Dans Créer une table à partir de, sélectionnez l'une des options suivantes :
  - Amazon S3
  - Azure Blob Storage
2. Indiquez le chemin d'accès au dossier, en utilisant des caractères génériques. Exemple :
  - Pour Amazon S3 : s3://mybucket/*
  - Pour Blob Storage : azure://mystorageaccount.blob.core.windows.net/mycontainer/*
  Le dossier doit se trouver au même emplacement que l'ensemble de données contenant la table que vous souhaitez créer, modifier ou écraser.
3. Dans la liste Format de fichier, sélectionnez le type de fichier.
4. Cochez la case Partitionnement des données source, puis spécifiez les informations suivantes :
  1. Pour le champ Sélectionner le préfixe d'URI source, saisissez le préfixe d'URI. Par exemple, s3://mybucket/my_files.
  2. Facultatif : Pour exiger un filtre de partitionnement sur toutes les requêtes de cette table, cochez la case Demander un filtre de partitionnement. Ce type de filtre peut contribuer à réduire les coûts et à améliorer les performances. Pour en savoir plus, consultez la section Exiger des filtres de prédicat sur les clés de partitionnement dans les requêtes.
  3. Dans la section Mode d'inférence de la partition, sélectionnez l'une des options suivantes :
    - Déduire automatiquement les types : définir le mode de détection du schéma de partition sur AUTO.
    - Toutes les colonnes sont des chaînes : définir le mode de détection du schéma de partition sur STRINGS.
    - Fournir ma propre définition : définir le mode de détection du schéma de partition sur CUSTOM et saisir manuellement les informations de schéma pour les clés de partition. Pour plus d'informations, consultez la section Fournir un schéma de clé de partitionnement personnalisé.
Dans la section Destination, spécifiez les détails suivants :
1. Pour Projet, sélectionnez le projet dans lequel vous souhaitez créer la table.
2. Pour Ensemble de données, sélectionnez l'ensemble de données dans lequel vous souhaitez créer la table.
3. Pour le champ Table, saisissez le nom de la table que vous souhaitez créer.
4. Pour Type de table, vérifiez que l'option Table externe est sélectionnée.
5. Pour ID de connexion, sélectionnez la connexion que vous avez créée précédemment.
Dans la section Schéma, vous pouvez activer la détection automatique de schéma ou spécifier manuellement un schéma si vous disposez d'un fichier source. Si vous ne disposez pas d'un fichier source, vous devez spécifier manuellement un schéma.
- Pour activer la détection automatique de schéma, sélectionnez l'option Détection automatique.
- Pour spécifier manuellement un schéma, ne cochez pas l'option Détection automatique. Activez Modifier sous forme de texte et saisissez le schéma de la table sous forme de tableau JSON.
Pour ignorer les lignes dont les valeurs de colonnes supplémentaires ne correspondent pas au schéma, développez la section Options avancées et sélectionnez Valeurs inconnues.
Cliquez sur Créer une table.

SQL

Utilisez l'instruction LDD CREATE EXTERNAL TABLE :

Dans Google Cloud Console, 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 PARTITION COLUMNS
(
  PARTITION_COLUMN PARTITION_COLUMN_TYPE,
)
WITH CONNECTION `PROJECT_ID.REGION.CONNECTION_ID`
OPTIONS (
  hive_partition_uri_prefix = "HIVE_PARTITION_URI_PREFIX",
  uris=['FILE_PATH'],
  format ="TABLE_FORMAT"
);
```
Remplacez les éléments suivants :
- PROJECT_ID : nom du projet dans lequel vous souhaitez créer la table, par exemple myproject
- DATASET : nom de l'ensemble de données BigQuery dans lequel vous souhaitez créer la table, par exemple, mydataset
- EXTERNAL_TABLE_NAME : nom de la table que vous souhaitez créer (par exemple, mytable)
- PARTITION_COLUMN : nom de la colonne de partitionnement
- PARTITION_COLUMN_TYPE : type de la colonne de partitionnement
- REGION : région contenant la connexion, par exemple us
- CONNECTION_ID : nom de la connexion, par exemple myconnection
- HIVE_PARTITION_URI_PREFIX : préfixe d'URI de partitionnement Hive ; par exemple :
  - s3://mybucket/
  - azure://mystorageaccount.blob.core.windows.net/mycontainer/
- FILE_PATH : chemin d'accès à la source de données de la table externe que vous souhaitez créer ; par exemple :
  - s3://mybucket/*.parquet
  - azure://mystorageaccount.blob.core.windows.net/mycontainer/*.parquet
- TABLE_FORMAT : format de la table que vous souhaitez créer (par exemple, PARQUET)
Cliquez sur Exécuter.

Pour en savoir plus sur l'exécution des requêtes, consultez Exécuter une requête interactive.

Exemples

L'exemple suivant crée une table BigLake sur des données partitionnées dans Amazon S3. Le schéma est détecté automatiquement.

CREATE EXTERNAL TABLE `my_dataset.my_table`
WITH PARTITION COLUMNS
(
  sku STRING,
)
WITH CONNECTION `us.my-connection`
OPTIONS(
  hive_partition_uri_prefix = "s3://mybucket/products",
  uris = ['s3://mybucket/products/*']
);

L'exemple suivant crée une table BigLake sur des données partitionnées dans Blob Storage. Le schéma est spécifié.

CREATE EXTERNAL TABLE `my_dataset.my_table`
(
  ProductId INTEGER,
  ProductName, STRING,
  ProductType, STRING
)
WITH PARTITION COLUMNS
(
  sku STRING,
)
WITH CONNECTION `us.my-connection`
OPTIONS(
  hive_partition_uri_prefix = "azure://mystorageaccount.blob.core.windows.net/mycontainer/products",
  uris = ['azure://mystorageaccount.blob.core.windows.net/mycontainer/*']
);

bq

Tout d'abord, utilisez la commande bq mkdef pour créer un fichier de définition de table :

bq mkdef \
--source_format=SOURCE_FORMAT \
--connection_id=REGION.CONNECTION_ID \
--hive_partitioning_mode=PARTITIONING_MODE \
--hive_partitioning_source_uri_prefix=URI_SHARED_PREFIX \
--require_hive_partition_filter=BOOLEAN \
 URIS > DEFINITION_FILE

Remplacez les éléments suivants :

SOURCE_FORMAT : format de la source de données externe. Par exemple, CSV.
REGION : région contenant la connexion, par exemple us
CONNECTION_ID : nom de la connexion, par exemple myconnection
PARTITIONING_MODE : mode de partitionnement Hive. Utilisez l'une des valeurs suivantes :
- AUTO : détecte automatiquement les noms et les types de clés.
- STRINGS : convertit automatiquement les noms de clés en chaînes.
- CUSTOM : encode le schéma de clé dans le préfixe d'URI source.
URI_SHARED_PREFIX : préfixe de l'URI source.
BOOLEAN : spécifie si un filtre de prédicat est requis au moment de la requête. Cette option est facultative. La valeur par défaut est false.
URIS : chemin d'accès au dossier Amazon S3 ou au dossier Blob Storage, au format générique.
DEFINITION_FILE : chemin d'accès au fichier de définition de table sur votre ordinateur local.

Si la valeur de PARTITIONING_MODE est CUSTOM, incluez le schéma de clé de partitionnement dans le préfixe d'URI source, en utilisant le format suivant :

--hive_partitioning_source_uri_prefix=GCS_URI_SHARED_PREFIX/{KEY1:TYPE1}/{KEY2:TYPE2}/...

Après avoir créé le fichier de définition de table, créez la table BigLake à l'aide de la commande bq mk :

bq mk --external_table_definition=DEFINITION_FILE \
DATASET_NAME.TABLE_NAME \
SCHEMA

Remplacez les éléments suivants :

DEFINITION_FILE : chemin d'accès au fichier de définition de table.
DATASET_NAME : nom de l'ensemble de données contenant la table.
TABLE_NAME : nom de la table que vous créez.
SCHEMA : spécifie un chemin d'accès à un fichier de schéma JSON, ou spécifie le schéma au format field:data_type,field:data_type,.... Pour utiliser la détection automatique de schéma, omettez cet argument.

Exemples

L'exemple suivant utilise le mode de partitionnement Hive AUTO pour les données Amazon S3 :

bq mkdef --source_format=CSV \
  --connection_id=us.my-connection \
  --hive_partitioning_mode=AUTO \
  --hive_partitioning_source_uri_prefix=s3://mybucket/myTable \
  --metadata_cache_mode=AUTOMATIC \
  s3://mybucket/* > mytable_def

bq mk --external_table_definition=mytable_def \
  mydataset.mytable \
  Region:STRING,Quarter:STRING,Total_sales:INTEGER

L'exemple suivant utilise le mode de partitionnement Hive STRING pour les données Amazon S3 :

bq mkdef --source_format=CSV \
  --connection_id=us.my-connection \
  --hive_partitioning_mode=STRING \
  --hive_partitioning_source_uri_prefix=s3://mybucket/myTable \
  s3://mybucket/myTable/* > mytable_def

bq mk --external_table_definition=mytable_def \
  mydataset.mytable \
  Region:STRING,Quarter:STRING,Total_sales:INTEGER

L'exemple suivant utilise le mode de partitionnement Hive CUSTOM pour les données Blob Storage :

bq mkdef --source_format=CSV \
  --connection_id=us.my-connection \
  --hive_partitioning_mode=CUSTOM \
  --hive_partitioning_source_uri_prefix=azure://mystorageaccount.blob.core.windows.net/mycontainer/{dt:DATE}/{val:STRING} \
  azure://mystorageaccount.blob.core.windows.net/mycontainer/* > mytable_def

bq mk --external_table_definition=mytable_def \
  mydataset.mytable \
  Region:STRING,Quarter:STRING,Total_sales:INTEGER

API

Pour définir le partitionnement Hive à l'aide de l'API BigQuery, incluez l'objet hivePartitioningOptions dans l'objet ExternalDataConfiguration lorsque vous créez le fichier de définition de table. Pour créer une table BigLake, vous devez également spécifier une valeur pour le champ connectionId.

Si vous définissez le champ hivePartitioningOptions.mode sur CUSTOM, vous devez encoder le schéma de clé de partitionnement dans le champ hivePartitioningOptions.sourceUriPrefix comme suit : s3://BUCKET/PATH_TO_TABLE/{KEY1:TYPE1}/{KEY2:TYPE2}/...

Pour forcer l'application d'un filtre de prédicat au moment de la requête, définissez le champ hivePartitioningOptions.requirePartitionFilter sur true.

Tables Delta Lake

Pour demander de l'aide ou envoyer des commentaires concernant cette fonctionnalité, envoyez un e-mail à l'adresse bq-federated-formats@google.com.

Delta Lake est un format de table Open Source compatible avec les tables de données à l'échelle du pétaoctet. Les tables Delta Lake peuvent être interrogées à la fois en tant que tables temporaires et permanentes, et sont acceptées en tant que table BigLake.

Synchronisation des schémas

Delta Lake conserve un schéma canonique dans ses métadonnées. Vous ne pouvez pas mettre à jour un schéma à l'aide d'un fichier de métadonnées JSON. Pour mettre à jour le schéma, procédez comme suit :

Exécutez la commande bq update avec l'option --autodetect_schema :
```
bq update --autodetect_schema
PROJECT_ID:DATASET.TABLE
```
Remplacez les éléments suivants :
- PROJECT_ID : ID du projet contenant la table que vous souhaitez mettre à jour
- DATASET : ensemble de données contenant la table que vous souhaitez mettre à jour
- TABLE : table dont vous souhaitez prendre un instantané

Conversion des types de données

BigQuery convertit les types de données Delta Lake en types de données BigQuery, comme décrit ci-dessous :

Type Delta Lake	Type BigQuery
`boolean`	`BOOL`
`byte`	`INT64`
`int`	`INT64`
`long`	`INT64`
`float`	`FLOAT64`
`double`	`FLOAT64`
`Decimal(P/S)`	`NUMERIC` ou `BIG_NUMERIC` selon la précision
`date`	`DATE`
`time`	`TIME`
`timestamp (not partition column)`	`TIMESTAMP`
`timestamp (partition column)`	`DATETIME`
`string`	`STRING`
`binary`	`BYTES`
`array<Type>`	`ARRAY<Type>`
`struct`	`STRUCT`
`map<KeyType, ValueType>`	`ARRAY<Struct<key KeyType, value ValueType>>`

Limites

Les limites suivantes s'appliquent aux tables Delta Lake :

Les limites des tables externes s'appliquent aux tables Delta Lake.
Les tables Delta Lake ne sont compatibles qu'avec BigQuery Omni et sont soumises aux limites suivantes.
Vous ne pouvez pas mettre à jour une table avec un nouveau fichier de métadonnées JSON. Vous devez utiliser une opération de mise à jour de table de schéma à détection automatique. Pour en savoir plus, consultez la section Synchronisation des schémas.
Les fonctionnalités de sécurité de BigLake protègent les tables Delta Lake uniquement lorsque leur accès est effectué par l'intermédiaire des services BigQuery.

Créer une table Delta Lake

L'exemple suivant crée une table externe à l'aide de l'instruction CREATE EXTERNAL TABLE au format Delta Lake :

CREATE [OR REPLACE] EXTERNAL TABLE table_name
WITH CONNECTION connection_name
OPTIONS (
         format = 'DELTA_LAKE',
         uris = ["parent_directory"]
       );

Remplacez les éléments suivants :

table_name : nom de la table.
connection_name : nom de la connexion. La connexion doit identifier une source Amazon S3 ou Blob Storage.
parent_directory : URI du répertoire parent.

Transfert de cloud à cloud avec Delta Lake

L'exemple suivant utilise l'instruction LOAD DATA pour charger des données dans la table appropriée :

LOAD DATA [INTO | OVERWRITE] table_name
FROM FILES (
        format = 'DELTA_LAKE',
        uris = ["parent_directory"]
)
WITH CONNECTION connection_name;

Pour plus d'exemples de transferts de données inter-cloud, consultez la section Charger des données avec des opérations multicloud.

Interroger des tables BigLake

Pour en savoir plus, consultez la page Interroger des données Blob Storage.

Afficher les métadonnées des ressources avec `INFORMATION_SCHEMA`

Vous pouvez afficher les métadonnées de ressources avec des vues INFORMATION_SCHEMA. Lorsque vous interrogez les vues JOBS_BY_*, JOBS_TIMELINE_BY_* et RESERVATION*, vous devez spécifier l'emplacement de traitement de la requête colocalisé avec la région de la table. Pour en savoir plus sur les emplacements BigQuery Omni, consultez la section Emplacements. Pour toutes les autres tables système, spécifier l'emplacement de la tâche de requête est facultatif.

Consultez la section Limites pour en savoir plus sur les tables système compatibles avec BigQuery Omni.

Pour interroger les tables système JOBS_* et RESERVATION*, sélectionnez l'une des méthodes suivantes pour spécifier l'emplacement de traitement :

Console

Accédez à la page BigQuery.

Accéder à BigQuery
Si l'onglet Éditeur n'est pas visible, cliquez sur Saisir une nouvelle requête.
Cliquez sur Plus> Paramètres de requête. La boîte de dialogue Query Settings (Paramètres de la requête) s'ouvre.
Dans la boîte de dialogue Paramètres de requête, pour Paramètres supplémentaires > Emplacement des données, sélectionnez BigQuery région située dans la région BigQuery Omni. Par exemple, si votre région BigQuery Omni est aws-us-east-1, spécifiez us-east4.
Sélectionnez les champs restants, puis cliquez sur Enregistrer.

bq

Utilisez l'option --location pour définir l'emplacement de traitement de la tâche sur la région BigQuery qui est hébergée en colocation avec la région BigQuery Omni. Par exemple, si votre région BigQuery Omni est aws-us-east-1, spécifiez us-east4.

Exemple

bq query --use_legacy_sql=false --location=us-east4 \
"SELECT * FROM region-azure-eastus2.INFORMATION_SCHEMA.JOBS limit 10;"

API

Si vous exécutez des tâches de manière automatisée, définissez l'argument d'emplacement sur la région BigQuery qui est colocalisée avec la région BigQuery Omni. Par exemple, si votre région BigQuery Omni est aws-us-east-1, spécifiez us-east4.

VPC Service Controls

Vous pouvez utiliser les périmètres VPC Service Controls en tant que couche de défense supplémentaire, afin de limiter l'accès à un service cloud externe depuis BigQuery Omni. Par exemple, les périmètres VPC Service Controls peuvent limiter les exportations depuis vos tables BigQuery Omni vers un bucket Amazon S3 ou un conteneur Blob Storage spécifique.

Pour en savoir plus sur VPC Service Controls, consultez la page Présentation de VPC Service Controls.

Autorisation requise

Assurez-vous de disposer des autorisations requises pour configurer des périmètres de service. Pour afficher la liste des rôles IAM requis pour configurer VPC Service Controls, consultez la page Contrôle des accès avec IAM dans la documentation de VPC Service Controls.

Configurer VPC Service Controls à l'aide de la console Google Cloud

Dans le menu de navigation de la console Google Cloud, cliquez sur Sécurité, puis sur VPC Service Controls.

Accéder à VPC Service Controls
Pour configurer VPC Service Controls pour BigQuery Omni, suivez les étapes du guide Créer un périmètre de service, puis lorsque vous êtes dans le volet Règles de sortie, procédez comme suit :
1. Dans le volet Règles de sortie, cliquez sur Ajouter une règle.
2. Dans la section Attributs "FROM" du client API, sélectionnez une option dans la liste Identité.
3. Sélectionnez Attributs "TO" des ressources externes.
4. Pour ajouter une ressource externe, cliquez sur Ajouter des ressources externes.
5. Dans la boîte de dialogue Ajouter une ressource externe, saisissez un nom de ressource valide dans le champ Nom de la ressource externe. Exemple :
  - Pour Amazon Simple Storage Service (Amazon S3) : s3://BUCKET_NAME
    
    Remplacez BUCKET_NAME par le nom de votre bucket Amazon S3.
  - Pour Azure Blob Storage : azure://myaccount.blob.core.windows.net/CONTAINER_NAME
    
    Remplacez CONTAINER NAME par le nom de votre conteneur Blob Storage.
  Pour obtenir la liste des attributs de règle de sortie, consultez la documentation de référence sur les règles de sortie.
6. Sélectionnez les méthodes que vous souhaitez autoriser sur vos ressources externes :
  1. Si vous souhaitez autoriser toutes les méthodes, sélectionnez Toutes les méthodes dans la liste Méthodes.
  2. Si vous souhaitez autoriser des méthodes spécifiques, sélectionnez Méthode sélectionnée, cliquez sur Sélectionner des méthodes, puis sélectionnez les méthodes à autoriser sur vos ressources externes.
7. Cliquez sur Créer un périmètre.

Configurer VPC Service Controls à l'aide de gcloud CLI

Pour configurer VPC Service Controls à l'aide de gcloud CLI, procédez comme suit :

Définissez la règle d'accès par défaut.
Créez le fichier d'entrée de la règle de sortie.
Ajoutez la règle de sortie.

Définir la règle d'accès par défaut

Une règle d'accès est un conteneur à l'échelle de l'organisation pour les niveaux d'accès et les périmètres de service. Pour en savoir plus sur la définition d'une règle d'accès par défaut ou l'obtention d'un nom de règle d'accès, consultez la page Gérer une règle d'accès.

Créer le fichier d'entrée de règle de sortie

Un bloc de règles de sortie définit l'accès autorisé depuis un périmètre aux ressources situées en dehors de ce périmètre. Pour les ressources externes, la propriété externalResources définit les chemins d'accès aux ressources externes auxquelles l'accès est autorisé à partir de votre périmètre VPC Service Controls.

Les règles de sortie peuvent être configurées à l'aide d'un fichier JSON ou d'un fichier YAML. L'exemple suivant utilise le format .yaml :

- egressTo:
    operations:
    - serviceName: bigquery.googleapis.com
      methodSelectors:
      - method: "*"
      *OR*
      - permission: "externalResource.read"
    externalResources:
      - EXTERNAL_RESOURCE_PATH
  egressFrom:
    identityType: IDENTITY_TYPE
    *OR*
    identities:
    - serviceAccount:SERVICE_ACCOUNT

egressTo : répertorie les opérations de service autorisées sur les ressources Google Cloud situées dans des projets spécifiés qui sont extérieurs au périmètre.
operations : répertorie les services et actions/méthodes auxquels un client qui satisfait les conditions du bloc from est autorisé à accéder.
serviceName : définissez bigquery.googleapis.com pour BigQuery Omni.
methodSelectors : répertorie les méthodes auxquelles un client qui satisfait les conditions from peut accéder. Pour connaître les méthodes et autorisations pouvant faire l'objet de restrictions pour les services, consultez la section Méthodes de service compatibles avec les restrictions.
method : méthode de service valide, ou \"*\" pour autoriser toutes les méthodes serviceName.
permission : autorisation de service valide, telle que \"*\", externalResource.read ou externalResource.write. L'accès aux ressources situées en dehors du périmètre est autorisé pour les opérations nécessitant cette autorisation.
externalResources : répertorie les ressources externes auxquelles les clients situés au sein d'un périmètre peuvent accéder. Remplacez EXTERNAL_RESOURCE_PATH par un bucket Amazon S3 valide, tel que s3://bucket_name, ou par un chemin d'accès à un conteneur Blob Storage, tel que azure://myaccount.blob.core.windows.net/container_name.
egressFrom : répertorie les opérations de service autorisées sur les ressources Google Cloud dans des projets spécifiés dans le périmètre.
identityType ou identities : définit les types d'identité pouvant accéder aux ressources spécifiées en dehors du périmètre. Remplacez IDENTITY_TYPE par l'une des valeurs valides suivantes :
- ANY_IDENTITY : permet d'autoriser toutes les identités.
- ANY_USER_ACCOUNT : permet d'autoriser tous les utilisateurs.
- ANY_SERVICE_ACCOUNT : permet d'autoriser tous les comptes de service.
identities : répertorie les comptes de service pouvant accéder aux ressources spécifiées qui sont situées en dehors du périmètre.
serviceAccount (facultatif) : remplacez SERVICE_ACCOUNT par le compte de service qui peut accéder aux ressources spécifiées en dehors du périmètre.

Examples

L'exemple suivant est une règle qui autorise les opérations de sortie depuis l'intérieur du périmètre vers l'emplacement Amazon S3 s3://mybucket dans AWS.

- egressTo:
    operations:
    - serviceName: bigquery.googleapis.com
      methodSelectors:
      - method: "*"
    externalResources:
      - s3://mybucket
      - s3://mybucket2
  egressFrom:
    identityType: ANY_IDENTITY

L'exemple suivant autorise les opérations de sortie vers un conteneur Blob Storage :

- egressTo:
    operations:
    - serviceName: bigquery.googleapis.com
      methodSelectors:
      - method: "*"
    externalResources:
      - azure://myaccount.blob.core.windows.net/mycontainer
  egressFrom:
    identityType: ANY_IDENTITY

Pour en savoir plus sur les règles de sortie, consultez la documentation de référence sur les règles de sortie.

Ajouter la règle de sortie

Pour ajouter la règle de sortie lorsque vous créez un périmètre de service, exécutez la commande gcloud access-context-manager perimeters create. Par exemple, la commande suivante crée un périmètre nommé omniPerimeter, qui inclut le projet portant le numéro de projet 12345, limite l'API BigQuery et ajoute une règle de sortie définie dans le fichier egress.yaml :

gcloud access-context-manager perimeters create omniPerimeter \
    --title="Omni Perimeter" \
    --resources=projects/12345 \
    --restricted-services=bigquery.googleapis.com \
    --egress-policies=egress.yaml

Pour ajouter la règle de sortie à un périmètre de service existant, exécutez la commande gcloud access-context-manager perimeters update. Par exemple, la commande suivante ajoute une règle de sortie définie dans le fichier egress.yaml à un périmètre de service existant nommé omniPerimeter :

gcloud access-context-manager perimeters update omniPerimeter
    --set-egress-policies=egress.yaml

Vérifier votre périmètre

Pour vérifier le périmètre, exécutez la commande gcloud access-context-manager perimeters describe :

gcloud access-context-manager perimeters describe PERIMETER_NAME

Remplacez PERIMETER_NAME par le nom du périmètre.

Par exemple, la commande suivante décrit le périmètre omniPerimeter :

gcloud access-context-manager perimeters describe omniPerimeter

Pour en savoir plus, consultez la page Gérer les périmètres de service.

Limites

Pour obtenir la liste complète des limites applicables aux tables BigLake basées sur Amazon S3 et Blob Storage, consultez la section Limites.

Étapes suivantes

Découvrez BigQuery Omni.
Découvrez les tables BigLake.
Apprenez à exporter les résultats de requêtes vers Blob Storage.

Créer des tables BigLake Blob Storage

Avant de commencer

Rôles requis

Autorisations requises

Créer un ensemble de données

Console

SQL

bq

Créer des tables BigLake sur des données non partitionnées

Console

SQL

bq

API

Créer des tables BigLake sur des données partitionnées

Console

SQL

bq

API

Tables Delta Lake

Synchronisation des schémas

Conversion des types de données

Limites

Créer une table Delta Lake

Transfert de cloud à cloud avec Delta Lake

Interroger des tables BigLake

Afficher les métadonnées des ressources avec INFORMATION_SCHEMA

Console

bq

API

VPC Service Controls

Autorisation requise

Configurer VPC Service Controls à l'aide de la console Google Cloud

Configurer VPC Service Controls à l'aide de gcloud CLI

Définir la règle d'accès par défaut

Créer le fichier d'entrée de règle de sortie

Examples

Ajouter la règle de sortie

Vérifier votre périmètre

Limites

Étapes suivantes

Afficher les métadonnées des ressources avec `INFORMATION_SCHEMA`