Interroger des données Cloud Bigtable

Cette page explique comment utiliser BigQuery pour interroger des données stockées dans Cloud Bigtable.

Cloud Bigtable est la base de données NoSQL partiellement remplie de Google qui peut contenir jusqu'à plusieurs milliards de lignes, des milliers de colonnes et des pétaoctets de données. Ce service utilise un modèle de données semblable à celui du système Apache HBase et offre une bibliothèque cliente compatible avec HBase. Pour en savoir plus sur le modèle de données de Cloud Bigtable, consultez la section Modèle de stockage Cloud Bigtable.

Régions et zones disponibles

L'interrogation des données Cloud Bigtable n'est actuellement possible que dans les régions et zones suivantes :
Région Zone(s)
us-central1

us-central1-a

us-central1-b

us-central1-c

us-central1-f

europe-west1

europe-west1-b

europe-west1-c

europe-west1-d

Récupérer l'URI Cloud Bigtable

Si vous souhaitez créer une table externe pour une source de données Cloud Bigtable, vous devez fournir l'URI Cloud Bigtable. Pour récupérer cet URI, procédez comme suit :

  1. Ouvrez la console Cloud Bigtable.

    Ouvrir la console Cloud Bigtable

  2. Récupérez les informations suivantes concernant votre source de données Cloud Bigtable :

    • L'ID de votre projet
    • L'ID de votre instance Cloud Bigtable
    • Le nom de votre table Cloud Bigtable
  3. Composez l'URI Cloud Bigtable en utilisant le format ci-dessous, où :

    • project_id correspond au projet contenant votre instance Cloud Bigtable.
    • instance_id est l'ID de l'instance Cloud Bigtable.
    • table_name est le nom de la table que vous interrogez.

    https://googleapis.com/bigtable/projects/project_id/instances/instance_id/tables/table_name

Contrôles d'accès et champs d'application

Contrôles de l'accès aux tables externes permanentes

Vous pouvez partager l'accès à une table externe permanente qui est associée à une source de données Google Cloud Bigtable. En revanche, il est impossible de partager l'accès à une table externe temporaire.

Vous pouvez partager l'accès à une table externe permanente avec des utilisateurs (y compris des comptes de service) ou des groupes. Pour interroger la table externe, les utilisateurs ou groupes doivent (au minimum) disposer des droits suivants :

  • Accès bigquery.dataViewer à l'ensemble de données contenant la table externe
  • Accès bigquery.user au niveau du projet ou à un niveau supérieur afin d'exécuter des tâches de requête
  • Accès bigtable.reader à Cloud Bigtable de façon à disposer d'un accès en lecture seule aux métadonnées et aux tables

Champs d'application des instances Compute Engine

Lorsque vous créez une instance Compute Engine, vous pouvez spécifier une liste de champs d'application pour celle-ci. Les champs d'application contrôlent l'accès de l'instance aux produits Google Cloud Platform tels que Cloud Bigtable. Les applications exécutées sur la VM utilisent le compte de service pour appeler les API Google Cloud.

Si vous configurez une instance Compute Engine pour qu'elle s'exécute en tant que compte de service et que ce compte de service accède à une table externe associée à une source de données Cloud Bigtable, vous devez ajouter à l'instance le champ d'application Cloud Bigtable permettant un accès en lecture seule aux données (https://www.googleapis.com/auth/bigtable.data.readonly). Pour en savoir plus, consultez la page Créer une instance Compute Engine pour Cloud Bigtable.

Pour en savoir plus sur l'attribution de champs d'application à une instance Compute Engine, consultez la section Modifier le compte de service et les champs d'application d'accès d'une instance. Pour en savoir plus sur les comptes de service Compute Engine, consultez la page Comptes de service.

Tables externes permanentes et temporaires

Vous pouvez interroger une source de données externe dans BigQuery à l'aide d'une table permanente ou d'une table temporaire. Lorsque vous utilisez une table permanente, vous créez dans un ensemble de données BigQuery une table qui est associée à votre source de données externe. 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 externe sous-jacente. Vous avez par ailleurs la possibilité d'interroger la table à tout moment.

Lorsque vous interrogez une source de données externe à l'aide d'une table temporaire, vous exécutez une commande qui inclut une requête et crée une table non permanente associée à la source de données externe. En cas d'utilisation d'une table temporaire, vous ne créez pas de table dans l'un de vos ensembles de données BigQuery. La table n'étant pas stockée de manière permanente dans un ensemble de données, elle ne peut pas être partagée avec d'autres utilisateurs. L'interrogation d'une source de données externe à l'aide d'une table temporaire est utile pour des requêtes ad hoc ponctuelles qui sont exécutées sur des données externes, ou pour les processus d'extraction, de transformation et de chargement (ETL, Extract-Transform-Load).

Interroger des données Cloud Bigtable à l'aide de tables externes permanentes

Pour interroger une source de données Cloud Bigtable à l'aide d'une table permanente, vous devez créer, dans un ensemble de données BigQuery, une table qui est associée à la source de données. Les données 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 Cloud Bigtable sous-jacente.

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

  • Si vous utilisez l'API ou l'interface de ligne de commande (CLI), vous devez créer un fichier de définition de table qui spécifie le schéma et les métadonnées de la source de données externe.
  • Si vous utilisez la console GCP ou l'interface utilisateur Web classique BigQuery, vous devez saisir manuellement la famille et les qualificatifs de colonnes Cloud Bigtable.

Pour interroger des données Cloud Bigtable à l'aide d'une table externe permanente, vous devez exécuter les opérations suivantes :

  • Créer un fichier de définition de table (pour la CLI ou l'API)
  • Créer une table associée à la source de données externe dans BigQuery
  • Interroger les données à l'aide de la table permanente

Créer et interroger une table externe permanente

Pour créer et interroger une table permanente, suivez les procédures ci-dessous.

Console

Actuellement, il n'est pas possible d'interroger les données de Cloud Bigtable à l'aide de la console GCP.

UI classique

  1. Accédez à l'interface utilisateur Web de BigQuery.
    Accéder à l'UI Web de BigQuery

  2. Dans le panneau de navigation, passez la souris sur un ensemble de données, cliquez sur l'icône de flèche vers le bas image de la flèche vers le bas et cliquez sur Créer une table.

  3. Dans la section Données sources de la page Créer une table :

    • Dans le champ Emplacement, sélectionnez Google Cloud Bigtable et dans le champ de la source, indiquez l'URI Cloud Bigtable au format suivant : https://googleapis.com/bigtable/projects/project_id/instances/instance_id/tables/table_name. Où project_id est le projet contenant votre instance Cloud BigTable, instance_id est l'ID de l'instance Cloud BigTable et table_name est le nom de la table que vous interrogez.
    • Pour le paramètre Format de fichier, vérifiez que Cloud Bigtable est sélectionné.
  4. Dans la section Table de destination de la page Créer une table :

    • Pour le paramètre Nom de la table, choisissez l'ensemble de données correspondant, puis saisissez dans le champ le nom de la table permanente que vous créez dans BigQuery.
    • Vérifiez que le paramètre Type de table est défini sur Table externe.
  5. Dans la zone Qualificatifs et famille de colonne, cliquez sur Ajouter une famille pour spécifier les qualificatifs et les familles de colonnes. Vous pouvez également cliquer sur Modifier sous forme de texte, puis créer un tableau JSON contenant les qualificatifs et familles de colonnes. Cette liste restreint les familles de colonnes pouvant être référencées dans les requêtes et spécifie leurs types de valeurs. Exemple :

      [
        {
          "familyId": "family_int",
          "type": "INTEGER",
          "encoding": "BINARY",
          "onlyReadLatest": "true",
          "columns": [
            {
              "qualifierString": "foo",
              "onlyReadLatest": "true"
            }
          ]
        }
      ]
    
    Vous pouvez utiliser la liste de qualificatifs de colonne pour effectuer des conversions de types. Si vous laissez la liste vide, toutes les familles de colonnes sont incluses dans le schéma de la table et leurs valeurs sont lues sous forme d'octets (BYTES). Pour en savoir plus, reportez-vous aux options Cloud Bigtable dans la documentation de l'API externalDataConfiguration.

  6. Sélectionnez les éléments appropriés dans la section Options, puis cliquez sur Créer une table.

Une fois que la table permanente a été créée, vous pouvez exécuter une requête sur celle-ci comme s'il s'agissait d'une table BigQuery native, en respectant les limites applicables aux sources de données externes. Pour interroger la table dans l'interface utilisateur Web, cliquez sur Saisir une requête, indiquez votre requête dans la zone Nouvelle requête, puis cliquez sur Exécuter la requête.

Une fois que la requête a été exécutée, vous pouvez exporter les résultats au format CSV ou JSON, puis les enregistrer sous forme de table ou dans Google Sheets. Consultez Télécharger, enregistrer et exporter des données pour en savoir plus.

CLI

La commande bq mk permet de créer une table dans l'outil de ligne de commande BigQuery. Lorsque vous utilisez la CLI 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.

  1. Utilisez la commande bq mk pour créer une table permanente.

    bq mk \
    --external_table_definition=definition_file \
    dataset.table
    

    Où :

    • definition_file est le chemin d'accès du fichier de définition de table sur votre ordinateur local.
    • dataset est le nom de l'ensemble de données contenant la table.
    • table est le nom de la table que vous créez.

    Vous pouvez ensuite exécuter une requête sur la table comme s'il s'agissait d'une table BigQuery native, en respectant les limites applicables aux sources de données externes.

API

  • Pour la propriété sourceUris dans la ressource de table, vous ne pouvez spécifier qu'un seul URI Cloud Bigtable. Il doit s'agir d'une URL HTTPS complète et valide.

  • Spécifiez les propriétés du format de données en définissant la propriété sourceFormat. Pour Cloud Bigtable, indiquez "BIGTABLE".

Interroger des données Cloud Bigtable à l'aide de tables externes temporaires

Pour interroger une source de données externe sans créer de table permanente, vous devez exécuter une commande permettant de combiner les éléments suivants :

  • Un fichier de définition de table et une requête
  • Une définition de schéma intégrée et une requête
  • Un fichier de définition de schéma JSON et une requête

Le fichier de définition de table ou le schéma fourni est utilisé pour créer la table externe temporaire, sur laquelle la requête s'exécute. Il est possible d'interroger une source de données externe à l'aide d'une table temporaire dans l'API et la CLI BigQuery.

En cas d'utilisation d'une table externe temporaire, vous ne créez pas de table dans l'un de vos ensembles de données BigQuery. La table n'étant pas stockée de manière permanente dans un ensemble de données, elle ne peut pas être partagée avec d'autres utilisateurs. L'interrogation d'une source de données externe à l'aide d'une table temporaire est utile pour les requêtes ad hoc ponctuelles qui sont exécutées sur des données externes ou pour les processus d'extraction, de transformation et de chargement (ETL, Extract-Transform-Load).

Créer et interroger une table externe temporaire

Pour interroger des données Cloud Bigtable à l'aide d'une table externe temporaire, vous devez exécuter les opérations suivantes :

Il est actuellement possible de créer et d'interroger une table externe temporaire dans l'API et dans la CLI.

CLI

Pour interroger une table temporaire à l'aide d'un fichier de définition de table, saisissez la commande bq query avec l'indicateur --external_table_definition.

(Facultatif) Spécifiez l'indicateur --location et définissez la valeur correspondant à votre emplacement.

bq --location=location query \
--use_legacy_sql=false \
--external_table_definition=table::definition_file \
'query'

Où :

  • location est le nom de votre emplacement. L'indicateur --location est facultatif.
  • table est le nom de la table temporaire que vous créez.
  • definition_file est le chemin d'accès du fichier de définition de table sur votre ordinateur local.
  • query est la requête que vous soumettez à la table temporaire.

Par exemple, la commande ci-dessous permet de créer et d'interroger la table temporaire follows à l'aide du fichier de définition de table follows_def.

bq query \
--use_legacy_sql=false \
--external_table_definition=follows::/tmp/follows_def \
'SELECT
  COUNT(rowkey)
 FROM
   follows'

API

  • Créez une requête. Consultez la page Interroger des données pour en savoir plus sur la création d'une tâche de requête.

  • (Facultatif) Spécifiez votre emplacement dans la propriété location de la section jobReference de la ressource de tâche.

  • Spécifiez les propriétés de la source de données externe en définissant la propriété ExternalDataConfiguration pour la ressource de table.

Considérations sur les performances

Les performances des requêtes exécutées sur des sources de données externes Cloud Bigtable dépendent des trois facteurs suivants :

  • Nombre de lignes
  • Quantité de données lues
  • Ampleur de la parallélisation

BigQuery tente de lire le moins de données possible en se limitant aux familles de colonnes référencées dans la requête. L'ampleur de la parallélisation dépend du nombre de nœuds présents dans le cluster Cloud Bigtable et du nombre de divisions que comporte la table.

Notez que Cloud Bigtable fusionne automatiquement les divisions en fonction de la charge. Si la table n'est pas lue fréquemment, le nombre de divisions diminue au fil du temps et les performances des requêtes se dégradent progressivement. Pour savoir comment diviser une table en fonction d'une clé de ligne, consultez la page Gérer des tables.

En interrogeant Cloud Bigtable à partir de BigQuery, vous consommez des cycles de processeur Cloud Bigtable. Cela peut influer sur la latence et le débit des autres requêtes simultanées telles que la diffusion du trafic utilisateur en direct. Par exemple, une utilisation intensive du processeur sur Cloud Bigtable influe sur les requêtes en longue traîne et augmente la latence au 99e centile.

Vous devez surveiller l'utilisation du processeur Cloud Bigtable pour vérifier que vous vous trouvez dans les limites recommandées, telles qu'indiquées dans le tableau de bord de surveillance Cloud Bigtable de la console GCP. L'augmentation du nombre de nœuds de votre instance vous permet de mieux gérer le trafic BigQuery et celui lié aux autres requêtes simultanées.

Schéma généré

Par défaut, BigQuery expose les valeurs d'une famille de colonnes sous la forme d'un tableau de colonnes contenant lui-même un tableau de valeurs écrites à différents horodatages. Ce schéma conserve la disposition naturelle des données dans Cloud Bigtable. Toutefois, l'exécution des requêtes SQL peut s'avérer problématique. Vous pouvez convertir des colonnes en sous-champs dans la famille de colonnes parente et ne lire que la dernière valeur de chaque cellule. Les deux tableaux sont représentés dans le schéma par défaut sous la forme de valeurs scalaires.

Exemple

Vous enregistrez des profils utilisateur pour un réseau social fictif. Un modèle de données applicable à ce cas de figure peut se présenter sous la forme d'une famille de colonnes profile incluant des colonnes pour le sexe (gender), l'âge (age) et l'adresse e-mail (email).

rowkey | profile:gender| profile:age| profile:email
-------| --------------| -----------| -------------
alice  | female        | 30         | alice@gmail.com

À partir du schéma par défaut, vous pouvez créer une requête SQL standard permettant de comptabiliser les utilisateurs de sexe masculin de plus de 30 ans.

SELECT
  COUNT(1)
FROM
  `dataset.table`
OMIT
  RECORD IF NOT SOME(profile.column.name = "gender"
    AND profile.column.cell.value = "male")
  OR NOT SOME(profile.column.name = "age"
    AND INTEGER(profile.column.cell.value) > 30)

Il est plus facile d'interroger les données si les colonnes gender et age sont présentées sous la forme de sous-champs. Pour les présenter de cette façon, répertoriez gender et age sous la forme de colonnes nommées dans la famille de colonnes profile lors de la définition de la table. Vous pouvez également demander à BigQuery de présenter les dernières valeurs de cette famille de colonnes. En règle générale, seule la dernière valeur présente un intérêt. Il peut également s'agir de la seule valeur disponible.

Une fois que les colonnes sont présentées sous la forme de sous-champs, la requête SQL standard permettant de comptabiliser les utilisateurs de sexe masculin de plus de 30 ans se présente comme suit :

SELECT
  COUNT(1)
FROM
  `dataset.table`
WHERE
  profile.gender.cell.value="male"
  AND profile.age.cell.value > 30

Notez que les colonnes gender et age sont référencées directement sous forme de champs. La configuration JSON correspondant à ce cas de figure est la suivante :

  "bigtableOptions": {
    "readRowkeyAsString": "true",
    "columnFamilies": [
      {
          "familyId": "profile",
          "onlyReadLatest": "true",
          "columns": [
              {
                  "qualifierString": "gender",
                  "type": "STRING"
              },
              {
                  "qualifierString": "age",
                  "type": "INTEGER"
              }
          ]
      }
    ]
  }

Encodage de valeurs

Cloud Bigtable stocke les données sous forme d'octets bruts, indépendamment de l'encodage. Toutefois, les valeurs de type octet sont d'une utilité limitée pour l'analyse des requêtes SQL. Cloud Bigtable fournit deux types élémentaires de décodage scalaire : texte et binaire HBase.

Dans le format texte, on part du principe que toutes les valeurs sont stockées sous la forme de chaînes de texte alphanumériques. Par exemple, l'entier 768 correspond à la chaîne "768". Dans l'encodage binaire, on considère que la classe de méthodes HBase Bytes.toBytes a été utilisée pour encoder les données et qu'elle applique une méthode de décodage appropriée.

Filtres de requête

Les requêtes associées à un filtre d'égalité de ligne ne permettent de lire qu'une ligne spécifique. L'exemple suivant utilise la syntaxe SQL standard :

SELECT
  COUNT(follows.column.name)
FROM
  `dataset.table`
WHERE
  rowkey = "alice";

Les filtres de plage tels que rowkey > '1' et rowkey < '8' sont également acceptés, mais uniquement lorsque la clé de ligne est lue sous forme de chaîne avec l'option readRowkeyAsString.

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…

Besoin d'aide ? Consultez notre page d'assistance.