Créer et utiliser des vues

Ce document décrit comment créer et utiliser des vues dans BigQuery. Après avoir créé une vue, vous pouvez :

  • contrôler l'accès à vos vues ;
  • obtenir des informations sur vos vues ;
  • répertorier les vues dans un ensemble de données ;
  • obtenir des métadonnées de vue à l'aide de métatables.

Pour plus d'informations sur la gestion des vues, y compris la mise à jour des propriétés d'affichage, la copie d'une vue et la suppression d'une vue, consultez Gérer les vues.

Créer une vue

Vous pouvez créer une vue dans BigQuery :

  • manuellement, à l'aide de l'interface utilisateur Web de BigQuery ou de la commande bq mk de l'outil de ligne de commande ;
  • de façon automatisée, en appelant la méthode API tables.insert ;
  • en soumettant une instruction DDL (Data Definition Language) CREATE VIEW.

Lorsque vous créez une vue dans BigQuery, son nom doit être unique pour chaque ensemble de données. Le nom de la vue peut :

  • contenir jusqu'à 1 024 caractères ;
  • contenir des lettres (majuscules ou minuscules), des chiffres et des traits de soulignement.

Autorisations requises

Les vues sont traitées comme des ressources de table dans BigQuery. Par conséquent, la création d'une vue nécessite les mêmes autorisations que la création d'une table. Pour créer une vue, vous devez disposer d'un accès WRITER au niveau de l'ensemble de données, ou bien d'un rôle IAM au niveau du projet qui inclut les autorisations bigquery.tables.create. Les rôles IAM suivants, prédéfinis au niveau du projet, incluent ces autorisations bigquery.tables.create :

En outre, étant donné que le rôle bigquery.user dispose des autorisations bigquery.datasets.create, un utilisateur dont le rôle est bigquery.user peut créer des vues dans tous les ensembles de données créés par des utilisateurs. Lorsqu'un utilisateur détenant le rôle bigquery.user crée un ensemble de données, il bénéficie d'un accès OWNER à celui-ci. L'accès OWNER à un ensemble de données confère à l'utilisateur un contrôle total sur celui-ci, et sur toutes les tables et les vues qu'il contient.

Pour en savoir plus sur les autorisations et les rôles IAM dans BigQuery, consultez la page Contrôle des accès. Pour en savoir plus sur les rôles au niveau de l'ensemble de données, consultez la section Rôles primitifs pour les ensembles de données.

Créer une vue

Pour créer une vue, procédez comme suit :

UI Web

  1. Après avoir exécuté une requête, cliquez sur le bouton Enregistrer la vue dans la fenêtre des résultats de la requête pour enregistrer la requête en tant que vue.

    Enregistrer l'affichage

  2. Dans la boîte de dialogue Enregistrer la vue :

    • Pour le champ Projet, sélectionnez le projet dans lequel la vue sera stockée.
    • Pour le champ Ensemble de données, choisissez l'ensemble de données qui contiendra la vue. L'ensemble de données contenant la vue et celui contenant les tables référencées par celle-ci doivent se trouver dans le même emplacement.
    • Pour l'ID de la table, saisissez le nom de la vue.

      Boîte de dialogue "Enregistrer la vue"

    • Cliquez sur OK.

CLI

Utilisez la commande mk avec l'indicateur --view, Pour les requêtes SQL standard, ajoutez l'indicateur --use_legacy_sql et définissez-le sur false. Les paramètres facultatifs incluent --expiration, --description et --label.

Si votre requête fait référence à des ressources externes de fonction définie par l'utilisateur stockées dans Google Cloud Storage ou dans des fichiers locaux, spécifiez ces ressources à l'aide de l'indicateur --view_udf_resource. L'indicateur --view_udf_resource n'est pas présenté ici. Pour en savoir plus sur l'utilisation des fonctions définies par l'utilisateur, consultez la page Fonctions définies par l'utilisateur en SQL standard.

Si vous créez une vue dans un projet autre que votre projet par défaut, spécifiez l'ID du projet en utilisant l'indicateur --project_id.

bq mk --use_legacy_sql=false --view_udf_resource=[PATH_TO_FILE] --expiration [INTEGER] --description "[DESCRIPTION]" --label [KEY:VALUE, KEY:VALUE] --view '[QUERY]' --project_id [PROJECT_ID] [DATASET].[VIEW]

Où :

  • [PATH_TO_FILE] est le chemin de l'URI ou du système de fichiers local permettant d'accéder à un fichier de code, qui doit être chargé et évalué immédiatement en tant que ressource de fonction définie par l'utilisateur utilisée par la vue. Répétez l'indicateur pour spécifier plusieurs fichiers.
  • [INTEGER] est la durée de vie par défaut (en secondes) de la vue. La valeur minimale est de 3 600 secondes (une heure). Le délai d'expiration correspond à l'heure actuelle plus la valeur entière. Si vous définissez le délai d'expiration lorsque vous créez une vue, le paramètre d'expiration de la table par défaut de l'ensemble de données est ignoré.
  • [DESCRIPTION] est la description du libellé.
  • [KEY:VALUE] est la paire clé/valeur qui représente un libellé. Vous pouvez entrer plusieurs libellés en utilisant une liste séparée par des virgules.
  • [QUERY] est une requête valide. Pour les vues SQL standard, la requête doit inclure l'ID de projet dans les références de table et de vue sous la forme `[PROJECT_ID].[DATASET].[TABLE]`.
  • [PROJECT_ID] est l'ID de votre projet (si vous n'avez pas configuré de projet par défaut).
  • [DATASET] est un ensemble de données dans votre projet.
  • [VIEW] est le nom de la vue que vous souhaitez créer.

Exemples :

Entrez la commande suivante pour créer une vue partitionnée nommée myview dans mydataset au sein de votre projet par défaut. L'heure d'expiration est définie sur 3 600 secondes (une heure), la description est définie sur This is my view et le libellé est défini sur organization:development. La requête utilisée pour créer la vue interroge les données de l'ensemble de données public Données sur les noms aux États-Unis.

bq mk --use_legacy_sql=false --expiration 3600 --description "This is my view" --label organization:development --view 'SELECT name,number FROM `bigquery-public-data.usa_names.usa_1910_current` WHERE gender = "M" ORDER BY number DESC' mydataset.myview

Entrez la commande suivante pour créer une vue nommée myview dans mydataset au sein de myotherproject. L'heure d'expiration est définie sur 3 600 secondes (une heure), la description est définie sur This is my view et le libellé est défini sur organization:development. La requête utilisée pour créer la vue interroge les données de l'ensemble de données public Données sur les noms aux États-Unis.

bq mk --use_legacy_sql=false --expiration 3600 --description "This is my view" --label organization:development --view 'SELECT name,number FROM `bigquery-public-data.usa_names.usa_1910_current` WHERE gender = "M" ORDER BY number DESC' --project_id myotherproject mydataset.myview

Une fois la vue créée, vous pouvez mettre à jour son délai d'expiration, sa description et ses libellés.

API

Appelez la méthode tables.insert avec une ressource de table contenant une propriété view.

Go

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Go dans le guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API BigQuery Go.

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
meta := &bigquery.TableMetadata{
	// This example shows how to create a view of the shakespeare sample dataset, which
	// provides word frequency information.  This view restricts the results to only contain
	// results for works that contain the "king" in the title, e.g. King Lear, King Henry V, etc.
	ViewQuery: "SELECT word, word_count, corpus, corpus_date FROM `bigquery-public-data.samples.shakespeare` WHERE corpus LIKE '%king%'",
}
if err := client.Dataset(datasetID).Table(tableID).Create(ctx, meta); err != nil {
	return err
}

Python

Avant de tester cet exemple, suivez la procédure de configuration de Python dans le 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 Python.

# from google.cloud import bigquery
# client = bigquery.Client()
# project = 'my-project'
# source_dataset_id = 'my_source_dataset'
# source_table_id = 'us_states'
# shared_dataset_ref = client.dataset('my_shared_dataset')

# This example shows how to create a shared view of a source table of
# US States. The source table contains all 50 states, while the view will
# contain only states with names starting with 'W'.
view_ref = shared_dataset_ref.table('my_shared_view')
view = bigquery.Table(view_ref)
sql_template = (
    'SELECT name, post_abbr FROM `{}.{}.{}` WHERE name LIKE "W%"')
view.view_query = sql_template.format(
    project, source_dataset_id, source_table_id)
view = client.create_table(view)  # API request

print('Successfully created view at {}'.format(view.full_table_id))

Contrôler l'accès aux vues

Vous ne pouvez pas attribuer de contrôles d'accès directement aux vues. Vous pouvez contrôler l'accès aux vues en configurant des contrôles d'accès au niveau de l'ensemble de données ou du projet.

Les contrôles d'accès au niveau d'un ensemble de données spécifient les opérations que les utilisateurs, les groupes et les comptes de service sont autorisés à effectuer sur les vues de cet ensemble de données. Si vous n'affectez que des autorisations au niveau de l'ensemble de données, vous devez également attribuer un rôle primitif ou prédéfini au niveau du projet qui permet d'accéder au projet, par exemple, bigquery.user.

Au lieu d'accorder l'accès à des ensembles de données individuels, vous pouvez affecter des rôles IAM prédéfinis au niveau du projet qui accordent des autorisations à toutes les données des vues de tous les ensembles de données d'un projet.

Vous pouvez également créer des rôles personnalisés IAM. Si vous créez un rôle personnalisé, les autorisations que vous accordez dépendent des opérations de vue que vous souhaitez que l'utilisateur, le groupe ou le compte de service puisse effectuer.

Pour plus d'informations sur les rôles et les autorisations, consultez les pages suivantes :

Interroger les vues

Vous interrogez une vue de la même manière qu'une table. Les autorisations requises pour interroger une vue sont également les mêmes que pour une table. Pour en savoir plus sur la création et l'envoi de requêtes, consultez la page Présentation du processus d'interrogation des données BigQuery.

Utilisation des vues

Obtenir des informations sur les vues

Vous pouvez obtenir des informations sur les vues à l'aide de l'UI Web de BigQuery, de la commande CLI bq show ou en appelant la méthode API tables.get.

Autorisations requises

Pour obtenir des informations sur des vues, vous devez disposer du rôle READER au niveau de l'ensemble de données, ou d'un rôle IAM prédéfini au niveau du projet qui comprend les autorisations bigquery.tables.get Si vous disposez des autorisations bigquery.tables.get au niveau du projet, vous pouvez obtenir des informations sur toutes les vues du projet. Tous les rôles IAM prédéfinis au niveau du projet incluent les autorisations bigquery.tables.get, à l'exception des rôles bigquery.jobUser et bigquery.user.

En outre, comme le rôle bigquery.user dispose des autorisations bigquery.datasets.create, un utilisateur affecté au rôle bigquery.user peut obtenir des informations sur les vues des ensembles de données qu'il crée. Lorsqu'un utilisateur détenant le rôle bigquery.user crée un ensemble de données, il bénéficie d'un accès OWNER à celui-ci. Un accès OWNER à un ensemble de données confère à l'utilisateur un contrôle total sur cet ensemble et sur toutes les vues qu'il contient.

Pour en savoir plus sur les autorisations et les rôles IAM dans BigQuery, consultez la page Contrôle des accès. Pour en savoir plus sur les rôles au niveau de l'ensemble de données, consultez la section Rôles primitifs pour les ensembles de données.

Obtenir des informations sur la vue

Le processus permettant d'obtenir des informations sur les vues est le même que pour les tables.

Pour obtenir des informations sur les vues :

UI Web

  1. Développez votre ensemble de données.

  2. Cliquez sur le nom de la vue.

  3. Cliquez sur Détails. La page Détails de la vue affiche la description de la vue, les informations de vue et la requête SQL qui définit la vue.

    Afficher les détails

CLI

Exécutez la commande bq show. Vous pouvez contrôler la sortie à l'aide de l'indicateur --format. Si vous souhaitez obtenir des informations sur une vue d'un projet autre que celui par défaut, ajoutez l'ID du projet à l'ensemble de données, au format suivant : [PROJECT_ID]:[DATASET].

bq show --format=prettyjson [PROJECT_ID]:[DATASET].[VIEW]

Où :

  • [PROJECT_ID] correspond à l'ID de votre projet.
  • [DATASET] est le nom de l'ensemble de données.
  • [VIEW] est le nom de la vue.

Exemples :

Saisissez la commande suivante pour afficher des informations sur myview dans l'ensemble de données mydataset de votre projet par défaut.

bq show --format=prettyjson mydataset.myview

Saisissez la commande suivante pour afficher des informations sur myview dans l'ensemble de données mydataset de myotherproject.

bq show --format=prettyjson myotherproject:mydataset.myview

API

Appelez la méthode tables.get et indiquez tous les paramètres pertinents.

Go

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Go dans le guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API BigQuery Go.

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
view := client.Dataset(datasetID).Table(viewID)
meta, err := view.Metadata(ctx)
if err != nil {
	return err
}
fmt.Printf("View %s, query: %s\n", view.FullyQualifiedName(), meta.ViewQuery)

Python

Avant de tester cet exemple, suivez la procédure de configuration de Python dans le 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 Python.

# from google.cloud import bigquery
# client = bigquery.Client()
# shared_dataset_id = 'my_shared_dataset'

view_ref = client.dataset(shared_dataset_id).table('my_shared_view')
view = client.get_table(view_ref)  # API Request

# Display view properties
print('View at {}'.format(view.full_table_id))
print('View Query:\n{}'.format(view.view_query))

Répertorier des vues dans un ensemble de données

Vous pouvez répertorier des vues dans des ensembles de données avec l'UI Web de BigQuery, à l'aide de la commande CLI bq ls ou en appelant la méthode API tables.list.

Autorisations requises

Pour répertorier les vues d'un ensemble de données, vous devez disposer du rôle READER au niveau de l'ensemble de données, ou bien d'un rôle IAM au niveau du projet qui inclut les autorisations bigquery.tables.list. Si vous avez des autorisations bigquery.tables.list au niveau du projet, vous pouvez répertorier les vues dans tous les ensembles de données du projet. Tous les rôles IAM BigQuery prédéfinis incluent les autorisations bigquery.tables.list, à l'exception du rôle bigquery.jobUser.

Pour en savoir plus sur les autorisations et les rôles IAM dans BigQuery, consultez la page Contrôle des accès. Pour en savoir plus sur les rôles au niveau de l'ensemble de données, consultez la section Rôles primitifs pour les ensembles de données.

Répertorier des vues

Le processus permettant de répertorier des vues est le même que pour les tables.

Pour répertorier les vues dans un ensemble de données :

UI Web

  1. Dans le volet de navigation de l'UI Web, cliquez sur la flèche bleue située à gauche de votre ensemble de données pour le développer ou double-cliquez sur le nom de l'ensemble de données. Les tables et vues de cet ensemble de données s'affichent.

  2. Faites défiler la liste pour voir les tables de l'ensemble de données. Les tables et les vues sont identifiées par des icônes différentes.

    Afficher les tables

Ligne de commande

Exécutez la commande bq ls. Vous pouvez contrôler la sortie à l'aide de l'indicateur --format. Si vous répertoriez des vues dans un projet autre que votre projet par défaut, ajoutez l'ID du projet à l'ensemble de données, au format suivant : [PROJECT_ID]:[DATASET].

bq ls --format=pretty [PROJECT_ID]:[DATASET]

Où :

  • [PROJECT_ID] correspond à l'ID de votre projet.
  • [DATASET] est le nom de l'ensemble de données.

Lorsque vous exécutez la commande, le champ Type affiche TABLE ou VIEW. Par exemple :

+-------------------------+-------+----------------------+-------------------+
|         tableId         | Type  |        Labels        | Time Partitioning |
+-------------------------+-------+----------------------+-------------------+
| mytable                 | TABLE | department:shipping  |                   |
| myview                  | VIEW  |                      |                   |
+-------------------------+-------+----------------------+-------------------+

Exemples :

Saisissez la commande suivante pour répertorier les vues dans l'ensemble de données mydataset dans votre projet par défaut.

bq ls --format=pretty mydataset

Saisissez la commande suivante pour répertorier les vues dans l'ensemble de données mydataset dans myotherproject.

bq ls --format=pretty myotherproject:mydataset

API

Pour répertorier les vues avec l'API, appelez la méthode tables.list.

Go

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Go dans le guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API BigQuery Go.

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
ts := client.Dataset(datasetID).Tables(ctx)
for {
	t, err := ts.Next()
	if err == iterator.Done {
		break
	}
	if err != nil {
		return err
	}
	fmt.Fprintf(w, "Table: %q\n", t.TableID)
}

Python

Avant de tester cet exemple, suivez la procédure de configuration de Python dans le 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 Python.

# from google.cloud import bigquery
# client = bigquery.Client()
# dataset_ref = client.dataset('my_dataset')

tables = list(client.list_tables(dataset_ref))  # API request(s)
assert len(tables) == 0

table_ref = dataset.table('my_table')
table = bigquery.Table(table_ref)
client.create_table(table)                  # API request
tables = list(client.list_tables(dataset))  # API request(s)

assert len(tables) == 1
assert tables[0].table_id == 'my_table'

Obtenir des métadonnées de vue à l'aide de métatables

BigQuery offre des tables spéciales qui représentent les métadonnées, telles que la liste des tables et les vues d'un ensemble de données. Les "métatables" sont en lecture seule. Pour accéder aux métadonnées sur les tables et les vues d'un ensemble de données, servez-vous de la métatable __TABLES_SUMMARY__ dans l'instruction de requête SELECT. Vous pouvez exécuter la requête à l'aide de la console, de l'interface utilisateur Web classique de BigQuery, de la commande bq query de l'outil de ligne de commande, ou en appelant la méthode API jobs.insert et en configurant une tâche de requête.

Une requête qui utilise la métatable __TABLES_SUMMARY__ ressemble à ce qui suit :

    SELECT [FIELD] FROM [DATASET].__TABLES_SUMMARY__

Où :

  • DATASET est le nom de votre ensemble de données.
  • FIELD est l'une des valeurs suivantes :
Valeur Description
project_id Nom du projet.
dataset_id Nom de l'ensemble de données.
table_id Nom de la table ou de la vue.
creation_time Heure à laquelle la table ou la vue a été créée, en millisecondes, depuis le 1er janvier 1970 UTC.
type Un entier représentant le type de table : une table régulière (1) ou une vue (2).

Autorisations requises

Pour exécuter une tâche de requête utilisant la métatable __TABLES_SUMMARY__, vous devez disposer des autorisations bigquery.jobs.create. Les rôles IAM suivants, prédéfinis au niveau du projet, incluent les autorisations bigquery.jobs.create :

Vous devez également disposer du rôle READER au niveau de l'ensemble de données, ou bien d'un rôle IAM (au niveau du projet) incluant les autorisations bigquery.tables.getData. Tous les rôles IAM prédéfinis au niveau du projet incluent les autorisations bigquery.tables.getData, à l'exception de bigquery.user, bigquery.jobUser et bigquery.metadataViewer.

Limitations des métatables

Les métatables BigQuery sont soumises aux limitations suivantes :

  • En règle générale, __TABLES_SUMMARY__ est relativement rapide pour les ensembles de données contenant quelques milliers de tables. Pour les ensembles de données plus importants, __TABLES_SUMMARY__ devient de plus en plus lent et peut dépasser les ressources disponibles.
  • Les métatables ne peuvent pas être utilisées avec la méthode tables.insert.
  • Les métatables ne peuvent pas être utilisées en tant que tables de destination.
  • Les métatables ne sont pas compatibles avec les décorateurs de tables en ancien SQL.
  • Les métatables n'apparaissent pas lorsque vous répertoriez les tables dans un ensemble de données.

Exemples de métatables

La requête suivante récupère toutes les métadonnées pour l'ensemble de données bigquery-public-data.samples.

Interface utilisateur classique

#standardSQL
SELECT
  *
FROM
  `bigquery-public-data.samples.__TABLES_SUMMARY__`

Ligne de commande

bq --location=US query --use_legacy_sql=false '
SELECT
  *
FROM
  `bigquery-public-data.samples.__TABLES_SUMMARY__`'

Le résultat doit se présenter sous la forme suivante :

+----------------------+------------+-----------------+---------------+------+
| project_id           | dataset_id |    table_id     | creation_time | type |
+----------------------+------------+-----------------+---------------+------+
| bigquery-public-data | samples    | github_nested   | 1348782587310 |    1 |
| bigquery-public-data | samples    | github_timeline | 1335915950690 |    1 |
| bigquery-public-data | samples    | gsod            | 1335916040125 |    1 |
| bigquery-public-data | samples    | natality        | 1335916045005 |    1 |
| bigquery-public-data | samples    | shakespeare     | 1335916045099 |    1 |
| bigquery-public-data | samples    | trigrams        | 1335916127449 |    1 |
| bigquery-public-data | samples    | wikipedia       | 1335916132870 |    1 |
+----------------------+------------+-----------------+---------------+------+

La requête suivante extrait toutes les tables et les vues de l'ensemble de données bigquery-public-data.samples.

Interface utilisateur classique

#standardSQL
SELECT
  table_id
FROM
  `bigquery-public-data.samples.__TABLES_SUMMARY__`

Ligne de commande

bq --location=US query --use_legacy_sql=false '
SELECT
  table_id
FROM
  `bigquery-public-data.samples.__TABLES_SUMMARY__`'

Le résultat doit se présenter sous la forme suivante :

+-----------------+
|    table_id     |
+-----------------+
| github_nested   |
| github_timeline |
| gsod            |
| natality        |
| shakespeare     |
| trigrams        |
| wikipedia       |
+-----------------+

La requête suivante répertorie le type de chacune des tables de l'ensemble de données bigquery-public-data.samples.

Interface utilisateur classique

#standardSQL
SELECT
  table_id, type
FROM
  `bigquery-public-data.samples.__TABLES_SUMMARY__`

Ligne de commande

bq --location=US query --use_legacy_sql=false '
SELECT
  table_id, type
FROM
  `bigquery-public-data.samples.__TABLES_SUMMARY__`'

La sortie ressemble à ceci :

+-----------------+------+
|    table_id     | type |
+-----------------+------+
| github_nested   |   1  |
| github_timeline |   1  |
| gsod            |   1  |
| natality        |   1  |
| shakespeare     |   1  |
| trigrams        |   1  |
| wikipedia       |   1  |
+-----------------+------+

Accorder à une vue l'accès à un ensemble de données

La création d'une vue autorisée dans BigQuery consiste à permettre à une vue d'accéder à un ensemble de données. Une vue autorisée vous permet de partager des résultats de requête avec des utilisateurs et des groupes particuliers sans leur donner accès aux tables sous-jacentes. Vous pouvez également utiliser la requête SQL de la vue pour limiter les colonnes (champs) que les utilisateurs peuvent interroger.

La vue que vous créez doit être placée dans un ensemble de données distinct de celui qui contient les données sources interrogées par la vue. Vous ne pouvez affecter des contrôles d'accès qu'au niveau de l'ensemble de données. Par conséquent, si la vue est créée dans le même ensemble de données que les données sources, vos utilisateurs de données auront accès aux données aussi bien qu'à la vue.

Pour consulter un tutoriel sur la création d'une vue autorisée, consultez la page : Créer une vue autorisée dans BigQuery.

Autorisations requises

Pour permettre à une vue d'accéder à un ensemble de données, vous devez disposer d'un accès OWNER au niveau de l'ensemble de données, ou bien d'un rôle IAM au niveau du projet qui inclut les autorisations bigquery.datasets.update. Voici les rôles IAM prédéfinis au niveau du projet qui incluent les autorisations bigquery.datasets.update :

En outre, comme le rôle bigquery.user dispose des autorisations bigquery.datasets.create, un utilisateur ayant le rôle bigquery.user peut mettre à jour les ensembles de données qu'il crée. Lorsqu'un utilisateur détenant le rôle bigquery.user crée un ensemble de données, il bénéficie d'un accès OWNER à celui-ci. L'accès OWNER donne à l'utilisateur un contrôle total sur l'ensemble de données.

Pour en savoir plus sur les rôles et les autorisations IAM dans BigQuery, consultez la section Contrôle des accès. Pour en savoir plus sur les rôles au niveau de l'ensemble de données, consultez la section Rôles primitifs pour les ensembles de données.

Accorder l'accès à une vue

Pour accorder à une vue l'accès à un ensemble de données :

UI Web

Ces étapes illustrent l'affectation de contrôles d'accès à un ensemble de données via l'interface utilisateur Web classique de BigQuery. Il n'est actuellement pas possible d'affecter des contrôles d'accès à l'aide de la console.
  1. Cliquez sur le menu déroulant à droite de l'ensemble de données contenant les tables sources, et sélectionnez Partager l'ensemble de données.

  2. Dans la boîte de dialogue Partager l'ensemble de données, cliquez sur le menu déroulant situé à gauche du champ Ajouter des personnes, puis choisissez Vue autorisée.

  3. Cliquez sur Sélectionner une vue.

  4. Dans la boîte de dialogue Sélectionner une vue :

    • Dans le champ Projet, vérifiez le nom du projet. Si la vue se trouve dans un autre projet, veillez à le sélectionner.
    • Pour le champ Ensemble de données, choisissez l'ensemble de données qui contient la vue.
    • Dans le champ ID de table, saisissez le nom de la vue que vous autorisez.
    • Cliquez sur OK.

      Sélectionner la vue autorisée

  5. Cliquez sur Ajouter, puis sur Enregistrer les modifications.

Ligne de commande

  1. Écrivez les informations sur l'ensemble de données existant (y compris les contrôles d'accès) dans un fichier JSON à l'aide de la commande show. Si l'ensemble de données se trouve dans un projet autre que votre projet par défaut, ajoutez l'ID de ce projet au nom de l'ensemble de données, au format suivant : [PROJECT_ID]:[DATASET].

    bq show --format=prettyjson [PROJECT_ID]:[DATASET] > [PATH_TO_FILE]
    

    Où :

    • [PROJECT_ID] correspond à l'ID de votre projet.
    • [DATASET] est le nom de votre ensemble de données.
    • [PATH_TO_FILE] est le chemin d'accès au fichier JSON sur votre ordinateur local.

      Exemples :

      Saisissez la commande suivante pour écrire les contrôles d'accès pour mydataset dans un fichier JSON. mydataset se trouve dans votre projet par défaut.

      bq show --format=prettyjson mydataset > /tmp/mydataset.json

      Saisissez la commande suivante pour écrire les contrôles d'accès pour mydataset dans un fichier JSON. mydataset se trouve dans myotherproject

      bq show --format=prettyjson myotherproject:mydataset > /tmp/mydataset.json

  2. Ajoutez la vue autorisée à la section "access" du fichier JSON.

    Par exemple, la section d'accès du fichier JSON d'un ensemble de données ressemblerait à ceci :

    {
     "access": [
      {
       "role": "READER",
       "specialGroup": "projectReaders"
      },
      {
       "role": "WRITER",
       "specialGroup": "projectWriters"
      },
      {
       "role": "OWNER",
       "specialGroup": "projectOwners"
      }
      {
       "role": "READER",
       "specialGroup": "allAuthenticatedUsers"
      }
      {
       "role": "READER",
       "domain": "[DOMAIN_NAME]"
      }
      {
       "role": "WRITER",
       "userByEmail": "[USER_EMAIL]"
      }
      {
       "role": "READER",
       "groupByEmail": "[GROUP_EMAIL]"
      },
      {
       "view":{
       "datasetId": "[DATASET_NAME]",
       "projectId": "[PROJECT_NAME]",
       "tableId": "[VIEW_NAME]"
      }
     ],
    }
    

  3. Une fois les modifications effectuées, utilisez la commande update avec l'indicateur --source pour inclure le fichier JSON. Si l'ensemble de données se trouve dans un projet autre que votre projet par défaut, ajoutez l'ID de ce projet au nom de l'ensemble de données, au format suivant : [PROJECT_ID]:[DATASET].

    bq update --source [PATH_TO_FILE] [PROJECT_ID]:[DATASET]
    

    Où :

    • [PATH_TO_FILE] est le chemin d'accès au fichier JSON sur votre ordinateur local.
    • [PROJECT_ID] correspond à l'ID de votre projet.
    • [DATASET] est le nom de votre ensemble de données.

      Exemples :

      Saisissez la commande suivante pour mettre à jour les contrôles d'accès pour mydataset. mydataset se trouve dans votre projet par défaut.

      bq update --source /tmp/mydataset.json mydataset
      

      Saisissez la commande suivante pour mettre à jour les contrôles d'accès pour mydataset. mydataset se trouve dans myotherproject.

      bq update --source /tmp/mydataset.json myotherproject:mydataset
      
  4. Pour vérifier les modifications de vos contrôles d'accès, saisissez de nouveau la commande show sans écrire les informations dans un fichier.

    bq show --format=prettyjson [DATASET]
    

    ou

    bq show --format=prettyjson [PROJECT_ID]:[DATASET]
    

API

Appelez la méthode datasets.patch et utilisez la propriété access pour mettre à jour vos contrôles d'accès. Pour plus d'informations, consultez la section Ensembles de données.

Comme la méthode datasets.update remplace la totalité de la ressource d'ensemble de données, il est préférable d'utiliser la méthode datasets.patch pour mettre à jour les contrôles d'accès.

Go

Avant d'essayer l'exemple ci-dessous, suivez la procédure de configuration pour Go dans le guide de démarrage rapide de BigQuery : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence sur l'API BigQuery Go.

// To run this sample, you will need to create (or reuse) a context and
// an instance of the bigquery client.  For example:
// import "cloud.google.com/go/bigquery"
// ctx := context.Background()
// client, err := bigquery.NewClient(ctx, "your-project-id")
srcDataset := client.Dataset(srcDatasetID)
viewDataset := client.Dataset(viewDatasetID)
view := viewDataset.Table(viewID)

// First, we'll add a group to the ACL for the dataset containing the view.  This will allow users within
// that group to query the view, but they must have direct access to any tables referenced by the view.
vMeta, err := viewDataset.Metadata(ctx)
if err != nil {
	return err
}
vUpdateMeta := bigquery.DatasetMetadataToUpdate{
	Access: append(vMeta.Access, &bigquery.AccessEntry{
		Role:       bigquery.ReaderRole,
		EntityType: bigquery.GroupEmailEntity,
		Entity:     "example-analyst-group@google.com",
	}),
}
if _, err := viewDataset.Update(ctx, vUpdateMeta, vMeta.ETag); err != nil {
	return err
}

// Now, we'll authorize a specific view against a source dataset, delegating access enforcement.
// Once this has been completed, members of the group previously added to the view dataset's ACL
// no longer require access to the source dataset to successfully query the view.
srcMeta, err := srcDataset.Metadata(ctx)
if err != nil {
	return err
}
srcUpdateMeta := bigquery.DatasetMetadataToUpdate{
	Access: append(srcMeta.Access, &bigquery.AccessEntry{
		EntityType: bigquery.ViewEntity,
		View:       view,
	}),
}
if _, err := srcDataset.Update(ctx, srcUpdateMeta, srcMeta.ETag); err != nil {
	return err
}

Python

Avant de tester cet exemple, suivez la procédure de configuration de Python dans le 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 Python.

# from google.cloud import bigquery
# client = bigquery.Client()

# Assign access controls to the dataset containing the view
# shared_dataset_id = 'my_shared_dataset'
# analyst_group_email = 'data_analysts@example.com'
shared_dataset = client.get_dataset(
    client.dataset(shared_dataset_id))  # API request
access_entries = shared_dataset.access_entries
access_entries.append(
    bigquery.AccessEntry('READER', 'groupByEmail', analyst_group_email)
)
shared_dataset.access_entries = access_entries
shared_dataset = client.update_dataset(
    shared_dataset, ['access_entries'])  # API request

# Authorize the view to access the source dataset
# project = 'my-project'
# source_dataset_id = 'my_source_dataset'
source_dataset = client.get_dataset(
    client.dataset(source_dataset_id))  # API request
view_reference = {
    'projectId': project,
    'datasetId': shared_dataset_id,
    'tableId': 'my_shared_view',
}
access_entries = source_dataset.access_entries
access_entries.append(
    bigquery.AccessEntry(None, 'view', view_reference)
)
source_dataset.access_entries = access_entries
source_dataset = client.update_dataset(
    source_dataset, ['access_entries'])  # API request

Appliquer un accès de niveau ligne à l'aide d'une vue

Les vues peuvent permettre de restreindre l'accès à des colonnes (champs) particulières. Si vous souhaitez restreindre l'accès à des lignes individuelles de votre table, vous n'avez pas besoin de créer des vues distinctes pour chaque utilisateur ou groupe. Au lieu de cela, vous pouvez utiliser la fonction SESSION_USER() pour renvoyer l'adresse e-mail de l'utilisateur actuel.

Pour afficher différentes lignes pour différents utilisateurs, ajoutez à votre table un champ contenant l'utilisateur autorisé à voir la ligne. Ensuite, créez une vue qui utilise la fonction SESSION_USER(). Dans l'exemple suivant, les noms d'utilisateur sont stockés dans le champ allowed_viewer :

#standardSQL
SELECT [COLUMN_1, COLUMN_2]
FROM `[DATASET.VIEW]`
WHERE allowed_viewer = SESSION_USER()

La limite de cette approche est que vous ne pouvez accorder l'accès qu'à un seul utilisateur à la fois. Vous pouvez contourner cette limite en faisant de allowed_viewer un champ répété. Cette approche permet de fournir une liste d'utilisateurs pour chaque ligne, mais même si vous utilisez un champ répété, le stockage des noms d'utilisateur dans la table nécessite toujours de suivre manuellement chaque utilisateur ayant accès à chaque ligne.

À la place, indiquez des noms de groupe dans le champ allowed_viewer, puis créez une table distincte mappant les groupes aux utilisateurs. La table qui mappe les groupes aux utilisateurs possède un schéma qui stocke les noms de groupe et les noms d'utilisateur. Par exemple : {group:string, user_name:string}. Cette approche vous permet de gérer les informations relatives aux utilisateurs et aux groupes séparément de la table contenant les données.

Si la table de mappage s'appelle private.access_control, la requête SQL utilisée pour créer la vue autorisée serait :

#standardSQL
SELECT c.customer, c.id
FROM `private.customers` c
INNER JOIN (
    SELECT group
    FROM `private.access_control`
    WHERE SESSION_USER() = user_name) g
ON c.allowed_group = g.group

Étapes suivantes

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

Envoyer des commentaires concernant…

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