Créer des vues autorisées

Ce document explique comment créer des vues autorisées dans BigQuery.

Vous pouvez créer une vue autorisée dans BigQuery selon les méthodes suivantes :

  • Utilisation de l'UI Web classique de BigQuery
    • Actuellement, vous ne pouvez pas créer de vues autorisées à l'aide de la console GCP, car vous ne pouvez pas attribuer de contrôles d'accès aux ensembles de données dans cette dernière.
  • Utilisation de la commande bq mk de l'outil de ligne de commande
  • Appel de la méthode d'API tables.insert
  • Soumission d'une instruction du langage de définition de données (DDL, Data Definition Language) CREATE VIEW

Présentation

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 accorder à une vue l'accès à un ensemble de données, vous devez disposer d'un accès OWNER au niveau de l'ensemble de données, ou bien détenir au niveau du projet un rôle IAM qui comprend 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 aux vues l'accès aux ensembles de données

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

Interface utilisateur classique

Ces étapes illustrent l'attribution de contrôles d'accès à un ensemble de données via l'UI Web classique de BigQuery. Actuellement, vous ne pouvez pas attribuer de contrôles d'accès à l'aide de la console GCP.
  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 celui par défaut, ajoutez l'ID du projet au nom de l'ensemble de données, en respectant le 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 afin d'é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 afin d'é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 afin de 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 afin de 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 de 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.