Autorisierte Ansichten erstellen

In diesem Dokument wird beschrieben, wie Sie autorisierte Ansichten in BigQuery erstellen.

Eine autorisierte Ansicht können Sie in BigQuery auf folgende Weise erstellen:

  • Mit der Cloud Console oder der klassischen BigQuery-Web-UI
  • Mit dem Befehl bq mk des Befehlszeilentools
  • Durch Aufrufen der API-Methode tables.insert
  • Durch Senden einer CREATE VIEW-DDL-Anweisung (Data Definition Language, Datendefinitionssprache)
  • Mit den Clientbibliotheken

Überblick

Wenn einer Ansicht Zugriff auf ein Dataset gewährt wird, spricht man auch vom Erstellen einer autorisierten Ansicht in BigQuery. Mit einer autorisierten Ansicht können Sie Abfrageergebnisse mit bestimmten Nutzern und Gruppen teilen, ohne diesen Zugriff auf die zugrunde liegenden Tabellen zu erteilen. Sie können auch die SQL-Abfrage der Ansicht verwenden, um die Spalten (Felder) einzuschränken, die die Nutzer abfragen können.

Eine Ansicht muss in einem Dataset erstellt werden, das von den Quelldaten getrennt ist, die von der Ansicht abgefragt werden. Da Sie Zugriffssteuerungen nur auf Dataset-Ebene zuweisen können, haben die Nutzer Zugriff auf die Ansicht und die Daten, wenn die Ansicht in demselben Dataset wie die Quelldaten erstellt wird.

Eine Anleitung zum Erstellen autorisierter Ansichten finden Sie unter Autorisierte Ansicht in BigQuery erstellen.

Erforderliche Berechtigungen

Zum Erstellen einer autorisierten Ansicht benötigen Sie Berechtigungen für das Dataset, das die Ansicht enthält, und für das Dataset, das den Zugriff auf die Ansicht ermöglicht.

Dataset, das die Ansicht enthält

Ansichten werden in BigQuery als Tabellenressourcen behandelt. Daher sind für das Erstellen einer Ansicht dieselben Berechtigungen erforderlich wie für das Erstellen einer Tabelle. Zum Erstellen eines Datasets benötigen Sie mindestens Berechtigungen des Typs bigquery.tables.create. Die folgenden vordefinierten Cloud IAM-Rollen enthalten die Berechtigungen des Typs bigquery.tables.create:

  • bigquery.dataEditor
  • bigquery.dataOwner
  • bigquery.admin

Wenn ein Nutzer mit Berechtigungen vom Typ bigquery.datasets.create ein Dataset erstellt, hat er dafür außerdem bigquery.dataOwner-Zugriff. Mit bigquery.dataOwner-Zugriff haben Nutzer die Möglichkeit, Ansichten im Dataset zu erstellen.

Weitere Informationen zu Cloud IAM-Rollen und Berechtigungen in BigQuery finden Sie unter Vordefinierte Rollen und Berechtigungen.

Dataset, das Zugriff auf die Ansicht gewährt

Sie benötigen mindestens die Berechtigungen bigquery.datasets.update und bigquery.datasets.get, um Dataset-Attribute zu aktualisieren. Die folgenden vordefinierten Cloud IAM-Rollen enthalten die Berechtigungen bigquery.datasets.update und bigquery.datasets.get:

  • bigquery.dataOwner
  • bigquery.admin

Wenn ein Nutzer mit Berechtigungen vom Typ bigquery.datasets.create ein Dataset erstellt, hat er dafür außerdem bigquery.dataOwner-Zugriff. Mit bigquery.dataOwner-Zugriff haben Nutzer die Möglichkeit, Attribute für die von ihnen erstellten Datasets zu erstellen.

Weitere Informationen zu Cloud IAM-Rollen und Berechtigungen in BigQuery finden Sie unter Zugriffssteuerung.

Ansichten Zugriff auf Datasets gewähren

So gewähren Sie einer Ansicht Zugriff auf ein Dataset:

Console

  1. Maximieren Sie im Navigationsbereich im Abschnitt Ressourcen Ihr Projekt und wählen Sie ein Dataset aus.

  2. Klicken Sie rechts im Fenster auf Dataset freigeben.

  3. Wählen Sie im Bereich Dataset-Berechtigungen den Tab Autorisierte Ansichten aus.

  4. Im Abschnitt Autorisierte Ansicht teilen:

    • Überprüfen Sie unter Projekt auswählen den Projektnamen. Wenn sich die Ansicht in einem anderen Projekt befindet, müssen Sie dieses auswählen.
    • Wählen Sie unter Dataset auswählen das Dataset aus, das die Ansicht enthält.
    • Wählen Sie unter Ansicht auswählen die Ansicht aus, die Sie autorisieren möchten.
  5. Klicken Sie auf Hinzufügen und dann auf Fertig.

Klassische UI

  1. Klicken Sie rechts neben dem Dataset, das die Quelltabellen enthält, auf den Abwärtspfeil und wählen Sie Dataset freigeben aus.

  2. Klicken Sie im Dialogfeld Dataset freigeben für Personen hinzufügen auf das Drop-down-Menü links neben dem Feld und wählen Sie die Option Autorisierte Ansicht aus.

  3. Klicken Sie auf Ansicht auswählen.

  4. Führen Sie im Dialogfeld Ansicht auswählen die folgenden Schritte aus:

    • Überprüfen Sie den Projektnamen in Projekt. Wenn sich die Ansicht in einem anderen Projekt befindet, müssen Sie dieses auswählen.
    • Wählen Sie als Dataset das Dataset aus, das die Ansicht enthält.
    • Geben Sie als Tabellen-ID den Namen der Ansicht ein, die Sie autorisieren möchten.
    • Klicken Sie auf OK.

      Autorisierte Ansicht auswählen

  5. Klicken Sie auf Hinzufügen und dann auf Änderungen speichern.

Befehlszeile

  1. Schreiben Sie die vorhandenen Dataset-Informationen (einschließlich Zugriffssteuerungen) mit dem Befehl show in eine JSON-Datei. Wenn sich das Dataset in einem anderen Projekt als Ihrem Standardprojekt befindet, fügen Sie dem Dataset-Namen die Projekt-ID im folgenden Format hinzu: project_id:dataset.

    bq show \
    --format=prettyjson \
    project_id:dataset > path_to_file
    

    Dabei gilt:

    • project_id ist Ihre Projekt-ID.
    • dataset ist der Name des Datasets.
    • path_to_file ist der Pfad zur JSON-Datei auf Ihrem lokalen Computer.

    Beispiele:

    Geben Sie den folgenden Befehl ein, um die Zugriffssteuerungen für mydataset in eine JSON-Datei zu schreiben. befindet sich in Ihrem Standardprojekt.

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

    Geben Sie den folgenden Befehl ein, um die Zugriffssteuerungen für mydataset in eine JSON-Datei zu schreiben. mydataset befindet sich in myotherproject.

    bq show --format=prettyjson \
    myotherproject:mydataset > /tmp/mydataset.json
    
  2. Fügen Sie die autorisierte Ansicht zum Bereich "Zugriff" der JSON-Datei hinzu.

    Der Abschnitt "access" der JSON-Datei eines Datasets sieht zum Beispiel so aus:

    {
     "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. Wenn die Änderungen abgeschlossen sind, führen Sie den Befehl update aus und fügen mit dem Flag --source die JSON-Datei hinzu. Wenn sich das Dataset in einem anderen Projekt als Ihrem Standardprojekt befindet, fügen Sie dem Dataset-Namen die Projekt-ID im folgenden Format hinzu: project_id:dataset.

    bq update \
    --source path_to_file \
    project_id:dataset
    

    Wobei:

    • path_to_file ist der Pfad zur JSON-Datei auf Ihrem lokalen Computer.
    • project_id ist Ihre Projekt-ID.
    • dataset ist der Name Ihres Datasets.

    Beispiele:

    Geben Sie den folgenden Befehl ein, um die Zugriffssteuerungen für mydataset zu aktualisieren. mydataset befindet sich in Ihrem Standardprojekt.

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

    Geben Sie den folgenden Befehl ein, um die Zugriffssteuerungen für mydataset zu aktualisieren. mydataset befindet sich in myotherproject.

     bq update --source /tmp/mydataset.json myotherproject:mydataset
    
  4. Geben Sie den Befehl show noch einmal ein, ohne die Informationen in eine Datei zu schreiben, um die Änderungen der Zugriffssteuerung zu prüfen.

    bq show --format=prettyjson [DATASET]
    

    oder

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

API

Rufen Sie die Methode datasets.patch auf und verwenden Sie das Attribut access, um die Zugriffssteuerungen zu aktualisieren. Weitere Informationen finden Sie unter Datasets.

Da die Methode datasets.update die gesamte Dataset-Ressource ersetzt, ist datasets.patch die bevorzugte Methode zum Aktualisieren von Zugriffssteuerungen.

Go

Bevor Sie dieses Beispiel ausprobieren, folgen Sie den Schritten zur Einrichtung von Go in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Go API.

import (
	"context"
	"fmt"

	"cloud.google.com/go/bigquery"
)

// updateViewDelegated demonstrates the setup of an authorized view, which allows access to a view's results
// without the caller having direct access to the underlying source data.
func updateViewDelegated(projectID, srcDatasetID, viewDatasetID, viewID string) error {
	// projectID := "my-project-id"
	// srcDatasetID := "sourcedata"
	// viewDatasetID := "views"
	// viewID := "myview"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}

	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
	}
	return nil
}

Python

Bevor Sie dieses Beispiel ausprobieren, folgen Sie der Anleitung zum Einrichten von Python in der BigQuery-Kurzanleitung: Clientbibliotheken verwenden. Weitere Informationen finden Sie in der Referenzdokumentation zur BigQuery Python API.

# 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

Zugriff auf Zeilenebene mithilfe einer Ansicht erzwingen

Mit Ansichten kann der Zugriff auf bestimmte Spalten (Felder) beschränkt werden. Wenn Sie den Zugriff auf einzelne Zeilen in einer Tabelle beschränken möchten, müssen Sie keine separaten Ansichten für jeden Nutzer oder jede Gruppe erstellen. Stattdessen können Sie die SESSION_USER()-Funktion verwenden, um die E-Mail-Adresse des aktuellen Nutzers zurückzugeben.

Wenn Sie verschiedenen Nutzern unterschiedliche Zeilen anzeigen möchten, fügen Sie der Tabelle ein weiteres Feld hinzu, das den Nutzer enthält, der die Zeile sehen darf. Erstellen Sie dann eine Ansicht, die die SESSION_USER()-Funktion nutzt. Im folgenden Beispiel werden die Nutzernamen im Feld allowed_viewer gespeichert:

SELECT
  COLUMN_1,
  COLUMN_2
FROM
  `dataset.view`
WHERE
  allowed_viewer = SESSION_USER()

Die Beschränkung bei diesem Ansatz besteht darin, dass Sie immer nur einem Nutzer gleichzeitig Zugriff gewähren können. Sie können sie dadurch umgehen, dass Sie allowed_viewer zu einem wiederkehrenden Feld machen. Es ist möglich, für jede Zeile eine Liste von Nutzern anzugeben. Sie müssen aber auch bei der Verwendung eines wiederholten Felds manuell einzeln die Nutzer herausfinden, die Zugriff auf die jeweiligen Zeilen haben.

Füllen Sie stattdessen das Feld allowed_viewer mit Gruppennamen und erstellen Sie eine separate Tabelle, die den Nutzern Gruppen zuordnet. Die Tabelle, die Gruppen zu Nutzern zuweist, muss über ein Schema verfügen, das Gruppen- und Nutzernamen speichert. Beispiel: {group:string, user_name:string}. So können Sie die Nutzer- und Gruppeninformationen getrennt von der Tabelle verwalten, die die Daten enthält.

Wenn die Zuordnungstabelle den Namen private.access_control hat, lautet die SQL-Abfrage zum Erstellen der autorisierten Ansicht:

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

Weitere Informationen