Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Créer une table externe Bigtable

Cette page explique comment créer une table externe permanente BigQuery qui peut être utilisée pour interroger des données stockées dans Bigtable. L'interrogation des données Bigtable est disponible dans tous les emplacements Bigtable.

Avant de commencer

Avant de créer une table externe, rassemblez certaines informations et assurez-vous de disposer des autorisations nécessaires pour créer la table.

Rôles requis

Pour créer une table externe à utiliser pour interroger vos données Bigtable, vous devez être un compte principal dans le rôle d'administrateur Bigtable (roles/bigtable.admin) pour l'instance contenant la table source.

Vous devez également disposer de l'autorisation Identity and Access Management (IAM) BigQuery bigquery.tables.create.

Tous les rôles Identity and Access Management prédéfinis suivants incluent cette autorisation :

Éditeur de données BigQuery (roles/bigquery.dataEditor)
Propriétaire de données BigQuery (roles/bigquery.dataOwner)
Administrateur BigQuery (roles/bigquery.admin)

Si vous ne disposez pas de compte principal pour l'un de ces rôles, demandez à votre administrateur de vous accorder l'accès ou de créer la table externe à votre place.

Pour en savoir plus sur les rôles et les autorisations Identity and Access Management dans BigQuery, consultez la page Rôles et autorisations prédéfinis. Pour afficher les informations concernant les autorisations Bigtable, consultez la page Contrôle des accès avec Identity and Access Management. Pour afficher les rôles requis pour interroger la table externe, consultez la page Interroger des données Bigtable data.

Créer ou identifier un ensemble de données

Avant de créer une table externe, vous devez créer un ensemble de données pour contenir la table externe. Vous pouvez également utiliser un ensemble de données existant.

Planifier votre utilisation du calcul

Déterminez le type de calcul que vous souhaitez utiliser lorsque vous interrogez vos données. Vous pouvez spécifier que vous souhaitez utiliser Data Boost ou que vous souhaitez acheminer le trafic vers un cluster dédié dans les paramètres de votre profil d'application.

Data Boost

Pour éviter d'affecter le trafic de diffusion de votre application, vous pouvez utiliser le calcul sans serveur Data Boost lorsque vous utilisez une table externe BigQuery pour lire vos données Bigtable. Pour utiliser Data Boost, vous devez utiliser un profil d'application Data Boost et inclure l'ID du profil d'application lorsque vous composez votre URI Bigtable. Pour en savoir plus, consultez la page Présentation de Bigtable Data Boost.

Nœuds provisionnés

Si vous n'utilisez pas Data Boost, les nœuds de cluster sont utilisés pour le calcul.

Si vous n'utilisez pas Data Boost et que vous prévoyez d'interroger fréquemment les mêmes données que celles utilisées par votre application de production, nous vous recommandons de désigner un cluster de votre instance Bigtable qui ne sera utilisé que pour l'analyse BigQuery. Cela isole le trafic du ou des clusters que vous utilisez pour les lectures et les écritures de votre application. Pour en savoir plus sur la réplication et la création d'instances comportant plusieurs clusters, consultez la page À propos de la réplication.

Identifier ou créer un profil d'application

Avant de créer une table externe, choisissez le profil d'application Bigtable que BigQuery doit utiliser pour lire les données. Nous vous recommandons d'utiliser un profil d'application que vous n'utilisez que pour BigQuery. Le profil d'application peut être un profil d'application standard ou un profil d'application Data Boost, selon le type de calcul que vous souhaitez utiliser pour interroger vos données.

Si vous disposez dans votre instance Bigtable d'un cluster dédié à l'accès à BigQuery, configurez le profil d'application pour qu'il utilise le routage à cluster unique vers ce cluster.

Pour utiliser le calcul sans serveur Data Boost, créez un profil d'application Data Boost. Pour utiliser des nœuds de cluster pour le calcul, créez un profil d'application standard. Pour en savoir plus sur le fonctionnement des profils d'application Bigtable, consultez la page À propos des profils d'application. Pour savoir comment créer un profil d'application, consultez la section Créer et configurer des profils d'application.

Récupérer l'URI Bigtable

Pour créer une table externe destinée à une source de données Bigtable, vous devez fournir l'URI Bigtable. Pour récupérer l'URI Bigtable, procédez comme suit :

Ouvrez la page Bigtable dans la console.

Accéder à Bigtable
Récupérez les informations suivantes concernant votre source de données Bigtable :
- ID de votre projet.
- ID de votre instance Bigtable.
- ID du profil d'application Bigtable que vous prévoyez d'utiliser. Il peut s'agir d'un profil d'application standard ou d'un profil d'application Data Boost, selon le type de calcul que vous souhaitez utiliser. Si vous ne spécifiez pas d'ID de profil d'application, le profil d'application par défaut est utilisé.
- Nom de votre table Bigtable.
Composez l'URI Bigtable en utilisant le format ci-dessous, où :
- PROJECT_ID est le projet contenant votre instance Bigtable.
- INSTANCE_ID est l'ID de l'instance Bigtable.
- APP_PROFILE (facultatif) est l'identifiant du profil d'application que vous souhaitez utiliser.
- TABLE_NAME est le nom de la table que vous interrogez.
https://googleapis.com/bigtable/projects/PROJECT_ID/instances/INSTANCE_ID[/appProfiles/APP_PROFILE]/tables/TABLE_NAME

Créer des tables externes permanentes

Lorsque vous créez une table externe permanente dans BigQuery qui est associée à une source de données Bigtable, vous disposez de deux options pour spécifier le format de la table externe :

Si vous utilisez l'API ou l'outil de ligne de commande bq, vous créez un fichier de définition de table qui spécifie le schéma et les métadonnées de la table externe.
Si vous utilisez SQL, vous utilisez l'option uri de l'instruction CREATE EXTERNAL TABLE pour spécifier la table Bigtable à partir de laquelle extraire les données, et l'option bigtable_options pour spécifier le schéma de la table.

Les données de la table externe ne sont pas stockées dans la table BigQuery. La table étant permanente, vous pouvez utiliser des contrôles d'accès au niveau de l'ensemble de données pour la partager avec d'autres utilisateurs ayant également accès à la source de données Bigtable sous-jacente.

Pour créer une table permanente, choisissez l'une des méthodes suivantes.

SQL

Vous pouvez créer une table externe permanente en exécutant l'instruction LDD CREATE EXTERNAL TABLE. Vous devez spécifier explicitement le schéma de la table dans les options de l'instruction.

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

Accéder à BigQuery
Dans l'éditeur de requête, saisissez l'instruction suivante :
```
CREATE EXTERNAL TABLE DATASET.NEW_TABLE
OPTIONS (
  format = 'CLOUD_BIGTABLE',
  uris = ['URI'],
  bigtable_options = BIGTABLE_OPTIONS );
```
Remplacez les éléments suivants :
- DATASET : ensemble de données dans lequel créer la table externe Bigtable.
- NEW_TABLE : nom de la table externe Bigtable.
- URI : URI de la table Bigtable que vous souhaitez utiliser comme source de données. Cet URI doit respecter le format décrit dans la section Récupérer l'URI Bigtable.
- BIGTABLE_OPTIONS : schéma de la table Bigtable au format JSON. Pour obtenir la liste des options de définition de table Bigtable, reportez-vous à la section BigtableOptions dans la documentation de référence de l'API REST.
Cliquez sur Exécuter.

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

Une instruction permettant de créer une table Bigtable externe peut ressembler à ceci :

CREATE EXTERNAL TABLE mydataset.BigtableTable
OPTIONS (
  format = 'CLOUD_BIGTABLE',
  uris = ['https://googleapis.com/bigtable/projects/myproject/instances/myBigtableInstance/appProfiles/myAppProfile/tables/table1'],
  bigtable_options =
    """
    {
      columnFamilies: [
        {
          "familyId": "familyId1",
          "type": "INTEGER",
          "encoding": "BINARY"
        }
      ],
      readRowkeyAsString: true
    }
    """
);

bq

Vous créez une table dans l'outil de ligne de commande bq à l'aide de la commande bq mk. Lorsque vous utilisez l'outil de ligne de commande bq pour créer une table associée à une source de données externe, vous devez identifier le schéma de la table à l'aide d'un fichier de définition de table.

Utilisez la commande bq mk pour créer une table permanente.
```
bq mk \
--external_table_definition=DEFINITION_FILE \
DATASET.TABLE
```
Remplacez les éléments suivants :
- DEFINITION_FILE : chemin d'accès au fichier de définition de table sur votre ordinateur local.
- DATASET : nom de l'ensemble de données contenant la table.
- TABLE : nom de la table que vous créez.

API

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

Pour la propriété sourceUris dans la ressource Table, spécifiez un seul URI Bigtable. Il doit s'agir d'une URL HTTPS valide.

Pour la propriété sourceFormat, spécifiez "BIGTABLE".

Java

Avant d'essayer cet exemple, suivez les instructions de configuration pour Java du guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API BigQuery pour Java.

Pour vous authentifier auprès de BigQuery, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez la page Configurer l'authentification pour les bibliothèques clientes.

import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.BigtableColumn;
import com.google.cloud.bigquery.BigtableColumnFamily;
import com.google.cloud.bigquery.BigtableOptions;
import com.google.cloud.bigquery.ExternalTableDefinition;
import com.google.cloud.bigquery.QueryJobConfiguration;
import com.google.cloud.bigquery.TableId;
import com.google.cloud.bigquery.TableInfo;
import com.google.cloud.bigquery.TableResult;
import com.google.common.collect.ImmutableList;
import org.apache.commons.codec.binary.Base64;

// Sample to queries an external bigtable data source using a permanent table
public class QueryExternalBigtablePerm {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "MY_PROJECT_ID";
    String bigtableInstanceId = "MY_INSTANCE_ID";
    String bigtableTableName = "MY_BIGTABLE_NAME";
    String bigqueryDatasetName = "MY_DATASET_NAME";
    String bigqueryTableName = "MY_TABLE_NAME";
    String sourceUri =
        String.format(
            "https://googleapis.com/bigtable/projects/%s/instances/%s/tables/%s",
            projectId, bigtableInstanceId, bigtableTableName);
    String query = String.format("SELECT * FROM %s ", bigqueryTableName);
    queryExternalBigtablePerm(bigqueryDatasetName, bigqueryTableName, sourceUri, query);
  }

  public static void queryExternalBigtablePerm(
      String datasetName, String tableName, String sourceUri, String query) {
    try {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      BigQuery bigquery = BigQueryOptions.getDefaultInstance().getService();

      BigtableColumnFamily.Builder statsSummary = BigtableColumnFamily.newBuilder();

      // Configuring Columns
      BigtableColumn connectedCell =
          BigtableColumn.newBuilder()
              .setQualifierEncoded(Base64.encodeBase64String("connected_cell".getBytes()))
              .setFieldName("connected_cell")
              .setType("STRING")
              .setEncoding("TEXT")
              .