Zugriff auf Datasets steuern

In diesem Dokument wird gezeigt, wie Sie den Zugriff auf Datasets in BigQuery steuern.

Darüber hinaus können Sie Folgendes tun:

Übersicht

Berechtigungen auf Dataset-Ebene legen fest, welche Nutzer, Gruppen und Dienstkonten auf die Tabellen, Ansichten und Tabellendaten in einem bestimmten Dataset zugreifen dürfen. Wenn Sie einem Nutzer beispielsweise die IAM-Rolle bigquery.dataOwner für ein bestimmtes Dataset zuweisen, kann dieser Nutzer Tabellen und Ansichten im Dataset erstellen, aktualisieren und löschen.

Sie können die API-Methode datasets.insert aufrufen, um Zugriffssteuerungen während der Dataset-Erstellung anzuwenden.

Zugriffssteuerungen können nicht während der Dataset-Erstellung in der Cloud Console oder dem bq-Befehlszeilentools angewendet werden.

Zugriffssteuerungen können auf folgenden Wegen auf ein Dataset angewendet werden, nachdem es erstellt ist:

  • Mit der Cloud Console
  • Mit dem Befehl bq update im bq-Befehlszeilentool
  • Durch Aufruf der API-Methode datasets.patch
  • Mithilfe der Clientbibliotheken

Erforderliche Berechtigungen

Zum Zuweisen oder Aktualisieren von Zugriffssteuerungen müssen Sie mindestens die Berechtigungen bigquery.datasets.update und bigquery.datasets.get erhalten. Diese vordefinierten 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, von ihnen erstellte Datasets zu aktualisieren.

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

Zugriff auf ein Dataset steuern

So weisen Sie einem Dataset Zugriffssteuerungen zu:

Console

  1. Wählen Sie aus Resources (Ressourcen) ein Dataset aus und klicken Sie dann rechts im Fenster auf Share dataset (Dataset freigeben).

    Personen zu Dataset hinzufügen

  2. Geben Sie auf dem Tab Dataset-Berechtigungen im Feld Dataset freigeben die Entität ein, die Sie in das Feld Mitglieder hinzufügen einfügen möchten. Sie können eine der folgenden Entitäten wählen:

    • Google-Konto-E-Mail: Gewährt einem einzelnen Google-Konto Zugriff auf das Dataset
    • Google-Gruppe: Gewährt allen Mitgliedern einer Google-Gruppe Zugriff auf das Dataset.
    • Google Apps-Domain: Gewährt allen Nutzern und Gruppen in einer Google-Domain Zugriff auf das Dataset.
    • Dienstkonto: Gewährt einem Dienstkonto Zugriff auf das Dataset.
    • Alle Nutzer: Geben Sie allUsers ein, um der Allgemeinheit Zugriff zu gewähren.
    • Alle Google-Konten: Geben Sie allAuthenticatedUsers ein, wenn Sie allen bei einem Google-Konto angemeldeten Nutzern den Zugriff gewähren möchten
  3. Wählen Sie unter Rolle auswählen die Option BigQuery und eine geeignete vordefinierte IAM-Rolle für die neuen Mitglieder aus. Weitere Informationen zu den Berechtigungen, die jeder vordefinierten BigQuery-Rolle zugewiesen sind, finden Sie auf der Seite "Zugriffssteuerung" im Abschnitt Rollen.

  4. Klicken Sie auf Fertig.

bq

  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
    

    Ersetzen Sie Folgendes:

    • project_id ist die 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. mydataset 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. Nehmen Sie die Änderungen im Abschnitt "access" der JSON-Datei vor. Sie können specialGroup-Einträge beliebig einfügen oder entfernen: projectOwners, projectWriters, projectReaders und allAuthenticatedUsers. Außerdem können Sie folgende Einträge angeben, entfernen oder ändern: userByEmail, groupByEmail und domain.

    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"
      }
     ],
     ...
    }
    

  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
    

    Ersetzen Sie Folgendes:

    • path_to_file ist der Pfad zur JSON-Datei auf Ihrem lokalen Computer.
    • project_id ist die Projekt-ID.
    • dataset ist der Name des 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 datasets.insert mit einer definierten Dataset-Ressource auf, um Zugriffssteuerungen anzuwenden, wenn das Dataset erstellt wird. Rufen Sie datasets.patch auf und verwenden Sie das Attribut access in der Dataset-Ressource, um die Zugriffssteuerungen zu aktualisieren.

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 Angaben finden Sie in der Referenzdokumentation zur BigQuery Go API.

Das Attribut dataset.access_entries legen Sie mit den Zugriffssteuerungen für ein Dataset fest. Rufen Sie dann die Funktion client.update_dataset() auf, um das Attribut zu aktualisieren.

import (
	"context"
	"fmt"

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

// updateDatasetAccessControl demonstrates how the access control policy of a dataset
// can be amended by adding an additional entry corresponding to a specific user identity.
func updateDatasetAccessControl(projectID, datasetID string) error {
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	ctx := context.Background()
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %v", err)
	}
	defer client.Close()

	ds := client.Dataset(datasetID)
	meta, err := ds.Metadata(ctx)
	if err != nil {
		return err
	}
	// Append a new access control entry to the existing access list.
	update := bigquery.DatasetMetadataToUpdate{
		Access: append(meta.Access, &bigquery.AccessEntry{
			Role:       bigquery.ReaderRole,
			EntityType: bigquery.UserEmailEntity,
			Entity:     "sample.bigquery.dev@gmail.com"},
		),
	}

	// Leverage the ETag for the update to assert there's been no modifications to the
	// dataset since the metadata was originally read.
	if _, err := ds.Update(ctx, update, meta.ETag); err != nil {
		return err
	}
	return nil
}

Java

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

import com.google.cloud.bigquery.Acl;
import com.google.cloud.bigquery.Acl.Role;
import com.google.cloud.bigquery.Acl.User;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.Dataset;
import java.util.ArrayList;

public class UpdateDatasetAccess {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    String datasetName = "MY_DATASET_NAME";
    // Create a new ACL granting the READER role to "sample.bigquery.dev@gmail.com"
    // For more information on the types of ACLs available see:
    // https://cloud.google.com/storage/docs/access-control/lists
    Acl newEntry = Acl.of(new User("sample.bigquery.dev@gmail.com"), Role.READER);

    updateDatasetAccess(datasetName, newEntry);
  }

  public static void updateDatasetAccess(String datasetName, Acl newEntry) {
    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();

      Dataset dataset = bigquery.getDataset(datasetName);

      // Get a copy of the ACLs list from the dataset and append the new entry
      ArrayList<Acl> acls = new ArrayList<>(dataset.getAcl());
      acls.add(newEntry);

      bigquery.update(dataset.toBuilder().setAcl(acls).build());
      System.out.println("Dataset Access Control updated successfully");
    } catch (BigQueryException e) {
      System.out.println("Dataset Access control was not updated \n" + e.toString());
    }
  }
}

Python

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

Das Attribut dataset.access_entries legen Sie mit den Zugriffssteuerungen für ein Dataset fest. Rufen Sie dann die Funktion client.update_dataset() auf, um das Attribut zu aktualisieren.
from google.cloud import bigquery

# Construct a BigQuery client object.
client = bigquery.Client()

# TODO(developer): Set dataset_id to the ID of the dataset to fetch.
# dataset_id = 'your-project.your_dataset'

dataset = client.get_dataset(dataset_id)  # Make an API request.

entry = bigquery.AccessEntry(
    role="READER",
    entity_type="userByEmail",
    entity_id="sample.bigquery.dev@gmail.com",
)

entries = list(dataset.access_entries)
entries.append(entry)
dataset.access_entries = entries

dataset = client.update_dataset(dataset, ["access_entries"])  # Make an API request.

full_dataset_id = "{}.{}".format(dataset.project, dataset.dataset_id)
print(
    "Updated dataset '{}' with modified user permissions.".format(full_dataset_id)
)

Tipp