Zugriff auf Ressourcen mit IAM steuern

In diesem Dokument wird beschrieben, wie Sie Zugriffssteuerungen für BigQuery-Datasets und die Ressourcen in Datasets (Tabellen, Ansichten und Routinen) aufrufen, gewähren und widerrufen. Obwohl Modelle auch Ressourcen auf Dataset-Ebene sind, können Sie mit IAM-Rollen keinen Zugriff auf einzelne Modelle gewähren.

Sie können Zugriff auf Google Cloud -Ressourcen gewähren, indem Sie Zulassungsrichtlinien verwenden. Diese werden auch als IAM-Richtlinien (Identity and Access Management) bezeichnet und mit Ressourcen verknüpft. Sie können jeweils nur eine Zulassungsrichtlinie an eine Ressource anhängen. Die Zulassungsrichtlinie steuert den Zugriff auf die Ressource selbst sowie auf alle Nachfolgerelemente dieser Ressource, die die Zulassungsrichtlinie übernehmen.

Weitere Informationen zu Zulassungsrichtlinien finden Sie in der IAM-Dokumentation unter Richtlinienstruktur.

In diesem Dokument wird davon ausgegangen, dass Sie mit Identity and Access Management (IAM) in Google Cloudvertraut sind.

Beschränkungen

  • Access Control Lists (ACLs) für Routinen sind nicht in replizierten Routinen enthalten.
  • Routinen in externen oder verknüpften Datasets unterstützen keine Zugriffssteuerungen.
  • Tabellen in externen oder verknüpften Datasets unterstützen keine Zugriffssteuerungen.
  • Zugriffssteuerungen für Abläufe können nicht mit Terraform festgelegt werden.
  • Regelmäßige Zugriffssteuerungen können nicht mit dem Google Cloud SDK festgelegt werden.
  • Routinezugriffssteuerungen können nicht mit der BigQuery Data Control Language (DCL) festgelegt werden.
  • Data Catalog unterstützt keine routinemäßigen Zugriffssteuerungen. Wenn ein Nutzer den Zugriff auf Routinen auf Bedingungsebene gewährt hat, werden seine Routinen nicht in der BigQuery-Seitenleiste angezeigt. Als Problemumgehung können Sie stattdessen Zugriff auf Dataset-Ebene gewähren.
  • In der INFORMATION_SCHEMA.OBJECT_PRIVILEGES-Ansicht werden keine Zugriffssteuerungen für Routinen angezeigt.

Hinweise

Weisen Sie IAM-Rollen (Identity and Access Management) zu, die Nutzern die erforderlichen Berechtigungen zum Ausführen der einzelnen Aufgaben in diesem Dokument gewähren.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle BigQuery-Dateninhaber (roles/bigquery.dataOwner) für das Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Ändern von IAM-Richtlinien für Ressourcen benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Diese vordefinierte Rolle enthält die Berechtigungen, die zum Ändern von IAM-Richtlinien für Ressourcen erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind erforderlich, um IAM-Richtlinien für Ressourcen zu ändern:

  • bigquery.datasets.get: zum Abrufen der Zugriffsrichtlinie eines Datasets.
  • bigquery.datasets.update: zum Abrufen der Zugriffsrichtlinie eines Datasets.
  • So rufen Sie die Zugriffsrichtlinie eines Datasets ab (nurGoogle Cloud -Konsole): bigquery.datasets.getIamPolicy
  • So legen Sie die Zugriffsrichtlinie eines Datasets (nur Konsole) fest: bigquery.datasets.setIamPolicy
  • bigquery.tables.getIamPolicy: zum Abrufen der Zugriffsrichtlinie einer Tabelle oder Ansicht.
  • bigquery.tables.setIamPolicy: zum Festlegen der Zugriffsrichtlinie einer Tabelle oder Ansicht.
  • So rufen Sie die Zugriffsrichtlinie einer Routine ab: bigquery.routines.getIamPolicy
  • So legen Sie die Zugriffsrichtlinie einer Routine fest: bigquery.routines.setIamPolicy
  • So erstellen Sie das bq-Tool oder SQL BigQuery-Jobs (optional): bigquery.jobs.create

Sie können diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

Mit Dataset-Zugriffssteuerungen arbeiten

Sie können Zugriff auf ein Dataset gewähren, indem Sie einem IAM-Hauptkonto eine vordefinierte oder benutzerdefinierte Rolle zuweisen, die festlegt, was das Hauptkonto mit dem Dataset tun kann. Dies wird auch als Anhängen einer Zulassungsrichtlinie an eine Ressource bezeichnet. Nachdem Sie Zugriff gewährt haben, können Sie die Zugriffssteuerungen des Datasets aufrufen und den Zugriff auf das Dataset widerrufen.

Zugriff auf ein Dataset gewähren

Sie können beim Erstellen eines Datasets mit der BigQuery-Web-UI oder dem bq-Befehlszeilentool keinen Zugriff auf das Dataset gewähren. Sie müssen zuerst das Dataset erstellen und dann Zugriff darauf gewähren. Mit der API können Sie Zugriff während der Dataset-Erstellung gewähren, indem Sie die Methode datasets.insert mit einer definierten Dataset-Ressource aufrufen.

Ein Projekt ist die übergeordnete Ressource für ein Dataset und ein Dataset ist die übergeordnete Ressource für Tabellen und Ansichten, Routinen und Modelle. Wenn Sie eine Rolle auf Projektebene zuweisen, werden die Rolle und ihre Berechtigungen vom Dataset und den Ressourcen des Datasets übernommen. Wenn Sie eine Rolle auf Dataset-Ebene zuweisen, werden die Rolle und ihre Berechtigungen von den Ressourcen innerhalb des Datasets übernommen.

Sie können Zugriff auf ein Dataset gewähren, indem Sie eine IAM-Rolle mit der Berechtigung für den Zugriff auf das Dataset zuweisen oder den Zugriff mithilfe einer IAM-Bedingung bedingt gewähren. Weitere Informationen zum Gewähren von bedingtem Zugriff finden Sie unter Zugriff mit IAM Conditions steuern.

Wenn Sie einer IAM-Rolle Zugriff auf ein Dataset gewähren möchten, ohne Bedingungen zu verwenden, wählen Sie eine der folgenden Optionen aus:

Console

  1. Rufen Sie die Seite BigQuery auf.

    BigQuery aufrufen

  2. Maximieren Sie im Bereich Explorer Ihr Projekt und wählen Sie ein Dataset für die Freigabe aus.

  3. Klicken Sie auf  Freigabe > Berechtigungen.

  4. Klicken Sie auf Hauptkonto hinzufügen.

  5. Geben Sie im Feld Neue Hauptkonten ein Hauptkonto ein.

  6. Wählen Sie in der Liste Rolle auswählen eine vordefinierte oder eine benutzerdefinierte Rolle aus.

  7. Klicken Sie auf Speichern.

  8. Klicken Sie auf Schließen, um zu den Dataset-Informationen zurückzukehren.

SQL

Verwenden Sie die DCL-Anweisung GRANT, um Hauptkonten Zugriff auf Datasets zu gewähren:

  1. Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

    BigQuery aufrufen

  2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

    GRANT `ROLE_LIST`
ON SCHEMA RESOURCE_NAME
TO "USER_LIST"

    Ersetzen Sie Folgendes:

    • ROLE_LIST: eine Rolle oder Liste mit durch Kommas getrennten Rollen, die Sie zuweisen möchten
    • RESOURCE_NAME: der Name des Datasets, für das Sie Zugriff gewähren

    • USER_LIST: eine durch Kommas getrennte Liste von Nutzern, denen die Rolle zugewiesen wird

      Eine Liste der gültigen Formate finden Sie unter user_list.

  3. Klicken Sie auf Ausführen.

Informationen zum Ausführen von Abfragen finden Sie unter Interaktive Abfrage ausführen.

Im folgenden Beispiel wird myDataset die Rolle „BigQuery Data Viewer“ zugewiesen:

GRANT `roles/bigquery.dataViewer`
ON SCHEMA `myProject`.myDataset
TO "user:user@example.com", "user:user2@example.com"

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Verwenden Sie den Befehl bq show, um die vorhandenen Dataset-Informationen (einschließlich Zugriffssteuerungen) in eine JSON-Datei zu schreiben:

    bq show \
    --format=prettyjson \
    PROJECT_ID:DATASET > PATH_TO_FILE

    Ersetzen Sie Folgendes:

    • PROJECT_ID: Ihre Projekt-ID
    • DATASET: der Name Ihres Datasets
    • PATH_TO_FILE: der Pfad zur JSON-Datei auf dem lokalen Computer

  3. Nehmen Sie die Änderungen im Abschnitt access der JSON-Datei vor. Sie können jeden der specialGroup-Einträge verwenden: projectOwners, projectWriters, projectReaders und allAuthenticatedUsers. Sie können auch eine der folgenden Optionen hinzufügen: 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"
  }
 ],
 ...
}

  4. Wenn die Änderungen abgeschlossen sind, führen Sie den Befehl bq update aus und fügen die JSON-Datei mit dem Flag --source hinzu. Wenn sich das Dataset in einem anderen Projekt als Ihrem Standardprojekt befindet, fügen Sie dem Dataset-Namen die Projekt-ID im Format PROJECT_ID:DATASET hinzu.

      bq update 
    
  --source PATH_TO_FILE 
    
  PROJECT_ID:DATASET

  5. Geben Sie den Befehl bq show noch einmal ein, ohne die Informationen in eine Datei zu schreiben, um die Änderungen der Zugriffssteuerung zu prüfen:

    bq show --format=prettyjson PROJECT_ID:DATASET

    6. Terraform

    Verwenden Sie die google_bigquery_dataset_iam-Ressourcen, um den Zugriff auf ein Dataset zu aktualisieren.

    Zugriffsrichtlinie für ein Dataset abrufen

    Im folgenden Beispiel wird gezeigt, wie Sie mit der google_bigquery_dataset_iam_policy-Ressource die IAM-Richtlinie für das Dataset mydataset festlegen. Dadurch wird jede vorhandene Richtlinie ersetzt, die bereits an das Dataset angehängt ist:

    # This file sets the IAM policy for the dataset created by
# https://github.com/terraform-google-modules/terraform-docs-samples/blob/main/bigquery/bigquery_create_dataset/main.tf.
# You must place it in the same local directory as that main.tf file,
# and you must have already applied that main.tf file to create
# the "default" dataset resource with a dataset_id of "mydataset".

data "google_iam_policy" "iam_policy" {
  binding {
    role = "roles/bigquery.admin"
    members = [
      "user:user@example.com",
    ]
  }
  binding {
    role = "roles/bigquery.dataOwner"
    members = [
      "group:data.admin@example.com",
    ]
  }
  binding {
    role = "roles/bigquery.dataEditor"
    members = [
      "serviceAccount:bqcx-1234567891011-12a3@gcp-sa-bigquery-condel.iam.gserviceaccount.com",
    ]
  }
}

resource "google_bigquery_dataset_iam_policy" "dataset_iam_policy" {
  dataset_id  = google_bigquery_dataset.default.dataset_id
  policy_data = data.google_iam_policy.iam_policy.policy_data
}

    Rollenmitgliedschaft für ein Dataset festlegen

    Im folgenden Beispiel wird gezeigt, wie Sie mit der Ressource google_bigquery_dataset_iam_binding die Mitgliedschaft in einer bestimmten Rolle für das Dataset mydataset festlegen. Dadurch wird jede vorhandene Mitgliedschaft in dieser Rolle ersetzt. Andere Rollen in der IAM-Richtlinie für das Dataset werden beibehalten:

    # This file sets membership in an IAM role for the dataset created by
# https://github.com/terraform-google-modules/terraform-docs-samples/blob/main/bigquery/bigquery_create_dataset/main.tf.
# You must place it in the same local directory as that main.tf file,
# and you must have already applied that main.tf file to create
# the "default" dataset resource with a dataset_id of "mydataset".

resource "google_bigquery_dataset_iam_binding" "dataset_iam_binding" {
  dataset_id = google_bigquery_dataset.default.dataset_id
  role       = "roles/bigquery.jobUser"

  members = [
    "user:user@example.com",
    "group:group@example.com"
  ]
}

    Rollenmitgliedschaft für ein einzelnes Hauptkonto festlegen

    Im folgenden Beispiel wird gezeigt, wie Sie die google_bigquery_dataset_iam_member-Ressource verwenden, um die IAM-Richtlinie für das Dataset mydataset zu aktualisieren und einem Hauptkonto eine Rolle zuzuweisen. Das Aktualisieren dieser IAM-Richtlinie hat keine Auswirkungen auf den Zugriff anderer Principals, denen diese Rolle für das Dataset zugewiesen wurde.

    # This file adds a member to an IAM role for the dataset created by
# https://github.com/terraform-google-modules/terraform-docs-samples/blob/main/bigquery/bigquery_create_dataset/main.tf.
# You must place it in the same local directory as that main.tf file,
# and you must have already applied that main.tf file to create
# the "default" dataset resource with a dataset_id of "mydataset".

resource "google_bigquery_dataset_iam_member" "dataset_iam_member" {
  dataset_id = google_bigquery_dataset.default.dataset_id
  role       = "roles/bigquery.user"
  member     = "user:user@example.com"
}

    Führen Sie die Schritte in den folgenden Abschnitten aus, um Ihre Terraform-Konfiguration auf ein Google Cloud -Projekt anzuwenden.

    Cloud Shell vorbereiten

    1. Rufen Sie Cloud Shell auf.

    2. Legen Sie das Standardprojekt Google Cloud fest, auf das Sie Ihre Terraform-Konfigurationen anwenden möchten.

      Sie müssen diesen Befehl nur einmal pro Projekt und in jedem beliebigen Verzeichnis ausführen.

      export GOOGLE_CLOUD_PROJECT=PROJECT_ID

      Umgebungsvariablen werden überschrieben, wenn Sie in der Terraform-Konfigurationsdatei explizite Werte festlegen.

    Verzeichnis vorbereiten

    Jede Terraform-Konfigurationsdatei muss ein eigenes Verzeichnis haben (auch als Stammmodul bezeichnet).

    1. Erstellen Sie in Cloud Shell ein Verzeichnis und eine neue Datei in diesem Verzeichnis. Der Dateiname muss die Erweiterung .tf haben, z. B. main.tf. In dieser Anleitung wird die Datei als main.tf bezeichnet. 
      mkdir DIRECTORY && cd DIRECTORY && touch main.tf

    2. Wenn Sie einer Anleitung folgen, können Sie den Beispielcode in jedem Abschnitt oder Schritt kopieren.

      Kopieren Sie den Beispielcode in das neu erstellte main.tf.

      Kopieren Sie optional den Code aus GitHub. Dies wird empfohlen, wenn das Terraform-Snippet Teil einer End-to-End-Lösung ist.

    3. Prüfen und ändern Sie die Beispielparameter, die auf Ihre Umgebung angewendet werden sollen.
    4. Speichern Sie die Änderungen.
    5. Initialisieren Sie Terraform. Dies ist nur einmal für jedes Verzeichnis erforderlich. 
      terraform init

      Fügen Sie optional die Option -upgrade ein, um die neueste Google-Anbieterversion zu verwenden: 

      terraform init -upgrade

    Änderungen anwenden

    1. Prüfen Sie die Konfiguration und prüfen Sie, ob die Ressourcen, die Terraform erstellen oder aktualisieren wird, Ihren Erwartungen entsprechen: 
      terraform plan

      Korrigieren Sie die Konfiguration nach Bedarf.

    2. Wenden Sie die Terraform-Konfiguration an. Führen Sie dazu den folgenden Befehl aus und geben Sie yes an der Eingabeaufforderung ein: 
      terraform apply

      Warten Sie, bis Terraform die Meldung „Apply complete“ anzeigt.

    3. Öffnen Sie Ihr Google Cloud Projekt, um die Ergebnisse aufzurufen. Rufen Sie in der Google Cloud Console Ihre Ressourcen in der Benutzeroberfläche auf, um sicherzustellen, dass Terraform sie erstellt oder aktualisiert hat.

    API

    Rufen Sie die Methode datasets.insert mit einer definierten Dataset-Ressource auf, um Zugriffssteuerungen anzuwenden, wenn das Dataset erstellt wird. Rufen Sie zum Aktualisieren Ihrer Zugriffssteuerungen die Methode datasets.patch auf und verwenden Sie das Attribut access in der Ressource Dataset.

    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 anwenden, folgen Sie den Schritten zur Einrichtung von Go in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Go API.

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

    Legen Sie die neue Zugriffsliste fest, indem Sie den neuen Eintrag mit DatasetMetadataToUpdate type an die vorhandene Liste anhängen. Rufen Sie dann die dataset.Update()-Funktion auf, um das Attribut zu aktualisieren. 
    import (
	"context"
	"fmt"
	"io"

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

// grantAccessToDataset creates a new ACL conceding the READER role to the group "example-analyst-group@google.com"
// For more information on the types of ACLs available see:
// https://cloud.google.com/storage/docs/access-control/lists
func grantAccessToDataset(w io.Writer, projectID, datasetID string) error {
	// TODO(developer): uncomment and update the following lines:
	// projectID := "my-project-id"
	// datasetID := "mydataset"

	ctx := context.Background()

	// Create BigQuery handler.
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	// Create dataset handler
	dataset := client.Dataset(datasetID)

	// Get metadata
	meta, err := dataset.Metadata(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Metadata: %w", err)
	}

	// Find more details about BigQuery Entity Types here:
	// https://pkg.go.dev/cloud.google.com/go/bigquery#EntityType
	//
	// Find more details about BigQuery Access Roles here:
	// https://pkg.go.dev/cloud.google.com/go/bigquery#AccessRole

	entityType := bigquery.GroupEmailEntity
	entityID := "example-analyst-group@google.com"
	roleType := bigquery.ReaderRole

	// Append a new access control entry to the existing access list.
	update := bigquery.DatasetMetadataToUpdate{
		Access: append(meta.Access, &bigquery.AccessEntry{
			Role:       roleType,
			EntityType: entityType,
			Entity:     entityID,
		}),
	}

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

	fmt.Fprintf(w, "Details for Access entries in dataset %v.\n", datasetID)
	for _, access := range meta.Access {
		fmt.Fprintln(w)
		fmt.Fprintf(w, "Role: %s\n", access.Role)
		fmt.Fprintf(w, "Entities: %v\n", access.Entity)
	}

	return nil
}

    Java

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

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

    import com.google.cloud.bigquery.Acl;
import com.google.cloud.bigquery.Acl.Entity;
import com.google.cloud.bigquery.Acl.Group;
import com.google.cloud.bigquery.Acl.Role;
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 com.google.cloud.bigquery.DatasetId;
import java.util.ArrayList;
import java.util.List;

public class GrantAccessToDataset {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    // Project and dataset from which to get the access policy
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    // Group to add to the ACL
    String entityEmail = "group-to-add@example.com";

    grantAccessToDataset(projectId, datasetName, entityEmail);
  }

  public static void grantAccessToDataset(
      String projectId, String datasetName, String entityEmail) {
    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();

      // Create datasetId with the projectId and the datasetName.
      DatasetId datasetId = DatasetId.of(projectId, datasetName);
      Dataset dataset = bigquery.getDataset(datasetId);

      // Create a new Entity with the corresponding type and email
      // "user-or-group-to-add@example.com"
      // For more information on the types of Entities available see:
      // https://cloud.google.com/java/docs/reference/google-cloud-bigquery/latest/com.google.cloud.bigquery.Acl.Entity
      // and
      // https://cloud.google.com/java/docs/reference/google-cloud-bigquery/latest/com.google.cloud.bigquery.Acl.Entity.Type
      Entity entity = new Group(entityEmail);

      // Create a new ACL granting the READER role to the group with the entity email
      // "user-or-group-to-add@example.com"
      // For more information on the types of ACLs available see:
      // https://cloud.google.com/storage/docs/access-control/lists
      Acl newEntry = Acl.of(entity, Role.READER);

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

      // Update the ACLs by setting the new list.
      Dataset updatedDataset = bigquery.update(dataset.toBuilder().setAcl(acls).build());
      System.out.println(
          "ACLs of dataset \""
              + updatedDataset.getDatasetId().getDataset()
              + "\" updated successfully");
    } catch (BigQueryException e) {
      System.out.println("ACLs were not updated \n" + e.toString());
    }
  }
}

    Node.js

    Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

    Legen Sie die neue Zugriffsliste fest, indem Sie den neuen Eintrag mit der Methode Dataset#metadata an die vorhandene Liste anhängen. Rufen Sie dann die Funktion Dataset#setMetadata() auf, um das Attribut zu aktualisieren. 
    
/**
 * TODO(developer): Update and un-comment below lines.
 */

// const datasetId = "my_project_id.my_dataset_name";

// ID of the user or group from whom you are adding access.
// const entityId = "user-or-group-to-add@example.com";

// One of the "Basic roles for datasets" described here:
// https://cloud.google.com/bigquery/docs/access-control-basic-roles#dataset-basic-roles
// const role = "READER";

const {BigQuery} = require('@google-cloud/bigquery');

// Instantiate a client.
const client = new BigQuery();

// Type of entity you are granting access to.
// Find allowed allowed entity type names here:
// https://cloud.google.com/bigquery/docs/reference/rest/v2/datasets#resource:-dataset
const entityType = 'groupByEmail';

async function grantAccessToDataset() {
  const [dataset] = await client.dataset(datasetId).get();

  // The 'access entries' array is immutable. Create a copy for modifications.
  const entries = [...dataset.metadata.access];

  // Append an AccessEntry to grant the role to a dataset.
  // Find more details about the AccessEntry object in the BigQuery documentation:
  // https://cloud.google.com/python/docs/reference/bigquery/latest/google.cloud.bigquery.dataset.AccessEntry
  entries.push({
    role,
    [entityType]: entityId,
  });

  // Assign the array of AccessEntries back to the dataset.
  const metadata = {
    access: entries,
  };

  // Update will only succeed if the dataset
  // has not been modified externally since retrieval.
  //
  // See the BigQuery client library documentation for more details on metadata updates:
  // https://cloud.google.com/nodejs/docs/reference/bigquery/latest

  // Update just the 'access entries' property of the dataset.
  await client.dataset(datasetId).setMetadata(metadata);

  console.log(
    `Role '${role}' granted for entity '${entityId}' in '${datasetId}'.`
  );
}

    Python

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

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

    Legen Sie das Attribut dataset.access_entries mit den Zugriffssteuerungen für ein Dataset fest. Rufen Sie dann die client.update_dataset()-Funktion auf, um das Attribut zu aktualisieren. 
    from google.api_core.exceptions import PreconditionFailed
from google.cloud import bigquery
from google.cloud.bigquery.enums import EntityTypes

# TODO(developer): Update and uncomment the lines below.

# ID of the dataset to grant access to.
# dataset_id = "my_project_id.my_dataset"

# ID of the user or group receiving access to the dataset.
# Alternatively, the JSON REST API representation of the entity,
# such as the view's table reference.
# entity_id = "user-or-group-to-add@example.com"

# One of the "Basic roles for datasets" described here:
# https://cloud.google.com/bigquery/docs/access-control-basic-roles#dataset-basic-roles
# role = "READER"

# Type of entity you are granting access to.
# Find allowed allowed entity type names here:
# https://cloud.google.com/python/docs/reference/bigquery/latest/enums#class-googlecloudbigqueryenumsentitytypesvalue
entity_type = EntityTypes.GROUP_BY_EMAIL

# Instantiate a client.
client = bigquery.Client()

# Get a reference to the dataset.
dataset = client.get_dataset(dataset_id)

# The `access_entries` list is immutable. Create a copy for modifications.
entries = list(dataset.access_entries)

# Append an AccessEntry to grant the role to a dataset.
# Find more details about the AccessEntry object here:
# https://cloud.google.com/python/docs/reference/bigquery/latest/google.cloud.bigquery.dataset.AccessEntry
entries.append(
    bigquery.AccessEntry(
        role=role,
        entity_type=entity_type,
        entity_id=entity_id,
    )
)

# Assign the list of AccessEntries back to the dataset.
dataset.access_entries = entries

# Update will only succeed if the dataset
# has not been modified externally since retrieval.
#
# See the BigQuery client library documentation for more details on `update_dataset`:
# https://cloud.google.com/python/docs/reference/bigquery/latest/google.cloud.bigquery.client.Client#google_cloud_bigquery_client_Client_update_dataset
try:
    # Update just the `access_entries` property of the dataset.
    dataset = client.update_dataset(
        dataset,
        ["access_entries"],
    )

    # Show a success message.
    full_dataset_id = f"{dataset.project}.{dataset.dataset_id}"
    print(
        f"Role '{role}' granted for entity '{entity_id}'"
        f" in dataset '{full_dataset_id}'."
    )
except PreconditionFailed:  # A read-modify-write error
    print(
        f"Dataset '{dataset.dataset_id}' was modified remotely before this update. "
        "Fetch the latest version and retry."
    )

Vordefinierte Rollen, die Zugriff auf Datasets gewähren

Sie können den folgenden vordefinierten IAM-Rollen Zugriff auf ein Dataset gewähren.

Rolle Beschreibung
BigQuery-Dateninhaber (roles/bigquery.dataOwner) Wenn diese Rolle für ein Dataset gewährt wird, werden die folgenden Berechtigungen erteilt:
  • Alle Berechtigungen für das Dataset und für alle Ressourcen im Dataset: Tabellen und Ansichten, Modelle und Routinen.
BigQuery-Dateneditor (roles/bigquery.dataEditor) Wenn diese Rolle für ein Dataset gewährt wird, werden die folgenden Berechtigungen erteilt:
  • Metadaten und Berechtigungen für das Dataset abrufen.
  • Für Tabellen und Ansichten:
    • Tabellen und Ansichten des Datasets erstellen, aktualisieren, abrufen, auflisten und löschen.
    • Tabellendaten lesen (abfragen), exportieren, replizieren und aktualisieren.
    • Indexe erstellen, aktualisieren und löschen.
    • Snapshots erstellen und wiederherstellen.
  • Alle Berechtigungen für die Routinen und Modelle des Datasets.
BigQuery Data Viewer (roles/bigquery.dataViewer) Wenn diese Rolle für ein Dataset gewährt wird, werden die folgenden Berechtigungen erteilt:
  • Metadaten und Berechtigungen für das Dataset abrufen.
  • Tabellen, Ansichten und Modelle eines Datasets auflisten
  • Metadaten und Zugriffssteuerungen für die Tabellen und Ansichten des Datasets abrufen.
  • Tabellendaten lesen (abfragen), replizieren und exportieren sowie Snapshots erstellen
  • Routinen des Datasets auflisten und aufrufen.
BigQuery Metadata Viewer (roles/bigquery.metadataViewer) Wenn diese Rolle für ein Dataset gewährt wird, werden die folgenden Berechtigungen erteilt:
  • Metadaten und Zugriffssteuerungen für das Dataset abrufen.
  • Metadaten und Zugriffssteuerungen für Tabellen und Ansichten abrufen.
  • Metadaten aus den Modellen und Routinen des Datasets abrufen.
  • Tabellen, Ansichten, Modelle und Routinen im Dataset auflisten.

Dataset-Berechtigungen

Die meisten Berechtigungen, die mit bigquery.datasets beginnen, gelten auf Dataset-Ebene. bigquery.datasets.create nicht. Zum Erstellen von Datasets muss einer Rolle im übergeordneten Container (dem Projekt) die Berechtigung bigquery.datasets.create gewährt werden.

In der folgenden Tabelle sind alle Berechtigungen für Datasets und die Ressource der niedrigsten Ebene aufgeführt, auf die die Berechtigung angewendet werden kann.

Berechtigung Ressource Aktion
bigquery.datasets.create Projekt Neue Datasets im Projekt erstellen
bigquery.datasets.get Dataset Metadaten und Zugriffssteuerungen für das Dataset abrufen. Zum Aufrufen von Berechtigungen in der Konsole ist außerdem die Berechtigung bigquery.datasets.getIamPolicy erforderlich.
bigquery.datasets.getIamPolicy Dataset Von der Konsole benötigt, um dem Nutzer die Berechtigung zu erteilen, die Zugriffssteuerung eines Datasets abzurufen. Fails open. Außerdem ist die Berechtigung bigquery.datasets.get erforderlich, um das Dataset in der Console aufzurufen.
bigquery.datasets.update Dataset Metadaten und Zugriffssteuerungen für das Dataset aktualisieren. Zum Aktualisieren von Zugriffssteuerungen in der Konsole ist außerdem die Berechtigung bigquery.datasets.setIamPolicy erforderlich.
bigquery.datasets.setIamPolicy Dataset Von der Konsole benötigt, um dem Nutzer die Berechtigung zum Festlegen der Zugriffssteuerung eines Datasets zu erteilen. Fails open. Für die Konsole ist außerdem die Berechtigung bigquery.datasets.update erforderlich, um das Dataset zu aktualisieren.
bigquery.datasets.delete Dataset Datasets löschen.
bigquery.datasets.createTagBinding Dataset Hängen Sie Tags an das Dataset an.
bigquery.datasets.deleteTagBinding Dataset Trennen Sie die Tags vom Dataset.
bigquery.datasets.listTagBindings Dataset Tags für das Dataset auflisten.
bigquery.datasets.listEffectiveTags Dataset Gültige Tags (angewendet und übernommen) für das Dataset auflisten.
bigquery.datasets.link Dataset Erstellen Sie ein verknüpftes Dataset.
bigquery.datasets.listSharedDatasetUsage Projekt Listet Nutzungsstatistiken für freigegebene Datasets auf, auf die Sie im Projekt Zugriff haben. Diese Berechtigung ist zum Abfragen der Ansicht INFORMATION_SCHEMA.SHARED_DATASET_USAGE erforderlich.

Zugriffssteuerungen für ein Dataset ansehen

Sie können die explizit festgelegten Zugriffssteuerungen für ein Dataset auf eine der folgenden Arten aufrufen. Wenn Sie geerbte Rollen für ein Dataset ansehen möchten, verwenden Sie die BigQuery-Web-UI.

Console

  1. Rufen Sie die Seite BigQuery auf.

    BigQuery aufrufen

  2. Maximieren Sie im Bereich Explorer Ihr Projekt und wählen Sie ein Dataset aus.

  3. Klicken Sie auf Freigabe > Berechtigungen.

    Die Zugriffssteuerung des Datasets wird im Bereich Dataset-Berechtigungen angezeigt.

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Verwenden Sie in Cloud Shell den Befehl bq show, um eine vorhandene Richtlinie abzurufen und in eine lokale Datei in JSON auszugeben:

    bq show \
   --format=prettyjson \
   PROJECT_ID:DATASET > PATH_TO_FILE

    Ersetzen Sie Folgendes:

    • PROJECT_ID: Ihre Projekt-ID
    • DATASET: der Name Ihres Datasets
    • PATH_TO_FILE: der Pfad zur JSON-Datei auf dem lokalen Computer

    3. SQL

    Fragen Sie die Ansicht INFORMATION_SCHEMA.OBJECT_PRIVILEGES ab. Bei Abfragen zum Abrufen von Zugriffssteuerungen für ein Dataset muss der object_name angegeben werden.

    1. Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

      BigQuery aufrufen

    2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

      SELECT
COLUMN_LIST
FROM
  PROJECT_ID.`region-REGION`.INFORMATION_SCHEMA.OBJECT_PRIVILEGES
WHERE
object_name = "DATASET";

      Ersetzen Sie Folgendes:

    3. Klicken Sie auf Ausführen.

    Informationen zum Ausführen von Abfragen finden Sie unter Interaktive Abfrage ausführen.

    Beispiel:

    Mit dieser Abfrage werden die Zugriffssteuerungen für mydataset abgerufen.

    SELECT
object_name, privilege_type, grantee
FROM
my_project.`region-us`.INFORMATION_SCHEMA.OBJECT_PRIVILEGES
WHERE
object_name = "mydataset";

    Die Ausgabe sollte so aussehen:

    +------------------+-----------------------------+-------------------------+
|   object_name    |  privilege_type             | grantee                 |
+------------------+-----------------------------+-------------------------+
| mydataset        | roles/bigquery.dataOwner    | projectOwner:myproject  |
| mydataset        | roles/bigquery.dataViwer    | user:user@example.com   |
+------------------+-----------------------------+-------------------------+

    API

    Rufen Sie die Methode datasets.get mit einer definierten dataset-Ressource auf, um die Zugriffssteuerungen für ein Dataset aufzurufen.

    Die Zugriffssteuerungen werden im Attribut access der Ressource dataset angezeigt.

    Go

    Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Go in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Go API.

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

    Rufen Sie die Funktion client.Dataset().Metadata() auf. Die Zugriffsrichtlinie ist in der Access-Property verfügbar. 
    import (
	"context"
	"fmt"
	"io"

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

// viewDatasetAccessPolicies retrieves the ACL for the given dataset
// For more information on the types of ACLs available see:
// https://cloud.google.com/storage/docs/access-control/lists
func viewDatasetAccessPolicies(w io.Writer, projectID, datasetID string) error {
	// TODO(developer): uncomment and update the following lines:
	// projectID := "my-project-id"
	// datasetID := "mydataset"

	ctx := context.Background()

	// Create new client.
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	// Get dataset's metadata.
	meta, err := client.Dataset(datasetID).Metadata(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Client.Dataset.Metadata: %w", err)
	}

	fmt.Fprintf(w, "Details for Access entries in dataset %v.\n", datasetID)

	// Iterate over access permissions.
	for _, access := range meta.Access {
		fmt.Fprintln(w)
		fmt.Fprintf(w, "Role: %s\n", access.Role)
		fmt.Fprintf(w, "Entity: %v\n", access.Entity)
	}

	return nil
}

    Java

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

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

    
import com.google.cloud.bigquery.Acl;
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 com.google.cloud.bigquery.DatasetId;
import java.util.List;

public class GetDatasetAccessPolicy {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    // Project and dataset from which to get the access policy.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    getDatasetAccessPolicy(projectId, datasetName);
  }

  public static void getDatasetAccessPolicy(String projectId, String datasetName) {
    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();

      // Create datasetId with the projectId and the datasetName.
      DatasetId datasetId = DatasetId.of(projectId, datasetName);
      Dataset dataset = bigquery.getDataset(datasetId);

      // Show ACL details.
      // Find more information about ACL and the Acl Class here:
      // https://cloud.google.com/storage/docs/access-control/lists
      // https://cloud.google.com/java/docs/reference/google-cloud-bigquery/latest/com.google.cloud.bigquery.Acl
      List<Acl> acls = dataset.getAcl();
      System.out.println("ACLs in dataset \"" + dataset.getDatasetId().getDataset() + "\":");
      System.out.println(acls.toString());
      for (Acl acl : acls) {
        System.out.println();
        System.out.println("Role: " + acl.getRole());
        System.out.println("Entity: " + acl.getEntity());
      }
    } catch (BigQueryException e) {
      System.out.println("ACLs info not retrieved. \n" + e.toString());
    }
  }
}

    Node.js

    Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

    Rufen Sie die Dataset-Metadaten mit der Dataset#getMetadata()-Funktion ab. Die Zugriffsrichtlinie ist in der Eigenschaft „access“ des resultierenden Metadatenobjekts verfügbar. 
    
/**
 * TODO(developer): Update and un-comment below lines
 */
// const datasetId = "my_project_id.my_dataset";

const {BigQuery} = require('@google-cloud/bigquery');

// Instantiate a client.
const bigquery = new BigQuery();

async function viewDatasetAccessPolicy() {
  const dataset = bigquery.dataset(datasetId);

  const [metadata] = await dataset.getMetadata();
  const accessEntries = metadata.access || [];

  // Show the list of AccessEntry objects.
  // More details about the AccessEntry object in the BigQuery documentation:
  // https://cloud.google.com/nodejs/docs/reference/bigquery/latest
  console.log(
    `${accessEntries.length} Access entries in dataset '${datasetId}':`
  );
  for (const accessEntry of accessEntries) {
    console.log(`Role: ${accessEntry.role || 'null'}`);
    console.log(`Special group: ${accessEntry.specialGroup || 'null'}`);
    console.log(`User by Email: ${accessEntry.userByEmail || 'null'}`);
  }
}

    Python

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

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

    Rufen Sie die Funktion client.get_dataset() auf. Die Zugriffsrichtlinie ist in der dataset.access_entries-Property verfügbar. 
    from google.cloud import bigquery

# Instantiate a client.
client = bigquery.Client()

# TODO(developer): Update and uncomment the lines below.

# Dataset from which to get the access policy.
# dataset_id = "my_dataset"

# Get a reference to the dataset.
dataset = client.get_dataset(dataset_id)

# Show the list of AccessEntry objects.
# More details about the AccessEntry object here:
# https://cloud.google.com/python/docs/reference/bigquery/latest/google.cloud.bigquery.dataset.AccessEntry
print(
    f"{len(dataset.access_entries)} Access entries found "
    f"in dataset '{dataset_id}':"
)

for access_entry in dataset.access_entries:
    print()
    print(f"Role: {access_entry.role}")
    print(f"Special group: {access_entry.special_group}")
    print(f"User by Email: {access_entry.user_by_email}")

Zugriff auf ein Dataset widerrufen

Wählen Sie eine der folgenden Optionen aus, um den Zugriff auf ein Dataset zu widerrufen:

Console

  1. Rufen Sie die Seite BigQuery auf.

    BigQuery aufrufen

  2. Maximieren Sie im Bereich Explorer Ihr Projekt und wählen Sie ein Dataset aus.

  3. Klicken Sie im Detailbereich auf Freigabe > Berechtigungen.

  4. Erweitern Sie im Dialogfeld Dataset-Berechtigungen das Hauptkonto, dessen Zugriff Sie widerrufen möchten.

  5. Klicken Sie auf Hauptkonto entfernen.

  6. Klicken Sie im Dialogfeld Rolle aus Hauptkonto entfernen? auf Entfernen.

  7. Klicken Sie auf Schließen, um zu den Dataset-Details zurückzukehren.

SQL

Verwenden Sie die DCL-Anweisung REVOKE, um den Zugriff eines Hauptkontos auf ein Dataset zu entfernen:

  1. Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

    BigQuery aufrufen

  2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

    REVOKE `ROLE_LIST`
ON SCHEMA RESOURCE_NAME
FROM "USER_LIST"

    Ersetzen Sie Folgendes:

    • ROLE_LIST: eine Rolle oder Liste mit durch Kommas getrennten Rollen, die Sie widerrufen möchten
    • RESOURCE_NAME: der Name der Ressource, für die Sie die Berechtigung widerrufen möchten

    • USER_LIST: eine durch Kommas getrennte Liste von Nutzern, deren Rollen widerrufen werden

      Eine Liste der gültigen Formate finden Sie unter user_list.

  3. Klicken Sie auf Ausführen.

Informationen zum Ausführen von Abfragen finden Sie unter Interaktive Abfrage ausführen.

Im folgenden Beispiel wird die Rolle „BigQuery Data Owner“ für myDataset widerrufen:

REVOKE `roles/bigquery.dataOwner`
ON SCHEMA `myProject`.myDataset
FROM "group:group@example.com", "serviceAccount:user@test-project.iam.gserviceaccount.com"

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Verwenden Sie den Befehl bq show, um die vorhandenen Dataset-Informationen (einschließlich Zugriffssteuerungen) in eine JSON-Datei zu schreiben:

    bq show \
    --format=prettyjson \
    PROJECT_ID:DATASET > PATH_TO_FILE

    Ersetzen Sie Folgendes:

    • PROJECT_ID: Ihre Projekt-ID
    • DATASET: der Name Ihres Datasets
    • PATH_TO_FILE: der Pfad zur JSON-Datei auf dem lokalen Computer

  3. Nehmen Sie die Änderungen im Abschnitt access der JSON-Datei vor. Sie können alle specialGroup-Einträge entfernen: projectOwners, projectWriters, projectReaders und allAuthenticatedUsers. Sie können auch die folgenden Elemente entfernen: 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"
  }
 ],
 ...
}

  4. Wenn die Änderungen abgeschlossen sind, führen Sie den Befehl bq update aus und fügen die JSON-Datei mit dem Flag --source hinzu. Wenn sich das Dataset in einem anderen Projekt als Ihrem Standardprojekt befindet, fügen Sie dem Dataset-Namen die Projekt-ID im Format PROJECT_ID:DATASET hinzu.

      bq update 
    
      --source PATH_TO_FILE 
    
      PROJECT_ID:DATASET

  5. 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 PROJECT_ID:DATASET

    6. API

    Rufen Sie die Methode datasets.patch auf und verwenden Sie das Attribut access in der Ressource Dataset, 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 anwenden, folgen Sie den Schritten zur Einrichtung von Go in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Go API.

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

    Legen Sie die neue Zugriffsliste fest, indem Sie den Eintrag aus der vorhandenen Liste mit DatasetMetadataToUpdate-Typ entfernen. Rufen Sie dann die dataset.Update()-Funktion auf, um das Attribut zu aktualisieren. 
    import (
	"context"
	"fmt"
	"io"

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

// revokeAccessToDataset creates a new ACL removing the dataset access to "example-analyst-group@google.com" entity
// For more information on the types of ACLs available see:
// https://cloud.google.com/storage/docs/access-control/lists
func revokeAccessToDataset(w io.Writer, projectID, datasetID, entity string) error {
	// TODO(developer): uncomment and update the following lines:
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// entity := "user@mydomain.com"

	ctx := context.Background()

	// Create BigQuery client.
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	// Get dataset handler
	dataset := client.Dataset(datasetID)

	// Get dataset metadata
	meta, err := dataset.Metadata(ctx)
	if err != nil {
		return err
	}

	// Create new access entry list by copying the existing and omiting the access entry entity value
	var newAccessList []*bigquery.AccessEntry
	for _, entry := range meta.Access {
		if entry.Entity != entity {
			newAccessList = append(newAccessList, entry)
		}
	}

	// Only proceed with update if something in the access list was removed.
	// Additionally, we use the ETag from the initial metadata to ensure no
	// other changes were made to the access list in the interim.
	if len(newAccessList) < len(meta.Access) {
		update := bigquery.DatasetMetadataToUpdate{
			Access: newAccessList,
		}
		meta, err = dataset.Update(ctx, update, meta.ETag)
		if err != nil {
			return err
		}
	} else {
		return fmt.Errorf("any access entry was revoked")
	}

	fmt.Fprintf(w, "Details for Access entries in dataset %v.\n", datasetID)

	for _, access := range meta.Access {
		fmt.Fprintln(w)
		fmt.Fprintf(w, "Role: %s\n", access.Role)
		fmt.Fprintf(w, "Entity: %v\n", access.Entity)
	}

	return nil
}

    Java

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

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

    
import com.google.cloud.bigquery.Acl;
import com.google.cloud.bigquery.Acl.Entity;
import com.google.cloud.bigquery.Acl.Group;
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 com.google.cloud.bigquery.DatasetId;
import java.util.List;

public class RevokeDatasetAccess {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    // Project and dataset from which to get the access policy.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    // Group to remove from the ACL
    String entityEmail = "group-to-remove@example.com";

    revokeDatasetAccess(projectId, datasetName, entityEmail);
  }

  public static void revokeDatasetAccess(String projectId, String datasetName, String entityEmail) {
    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();

      // Create datasetId with the projectId and the datasetName.
      DatasetId datasetId = DatasetId.of(projectId, datasetName);
      Dataset dataset = bigquery.getDataset(datasetId);

      // Create a new Entity with the corresponding type and email
      // "user-or-group-to-remove@example.com"
      // For more information on the types of Entities available see:
      // https://cloud.google.com/java/docs/reference/google-cloud-bigquery/latest/com.google.cloud.bigquery.Acl.Entity
      // and
      // https://cloud.google.com/java/docs/reference/google-cloud-bigquery/latest/com.google.cloud.bigquery.Acl.Entity.Type
      Entity entity = new Group(entityEmail);

      // To revoke access to a dataset, remove elements from the Acl list.
      // Find more information about ACL and the Acl Class here:
      // https://cloud.google.com/storage/docs/access-control/lists
      // https://cloud.google.com/java/docs/reference/google-cloud-bigquery/latest/com.google.cloud.bigquery.Acl
      // Remove the entity from the ACLs list.
      List<Acl> acls =
          dataset.getAcl().stream().filter(acl -> !acl.getEntity().equals(entity)).toList();

      // Update the ACLs by setting the new list.
      bigquery.update(dataset.toBuilder().setAcl(acls).build());
      System.out.println("ACLs of \"" + datasetName + "\" updated successfully");
    } catch (BigQueryException e) {
      System.out.println("ACLs were not updated \n" + e.toString());
    }
  }
}

    Node.js

    Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

    Aktualisieren Sie die Liste mit dem Dataset-Zugriff, indem Sie den angegebenen Eintrag aus der vorhandenen Liste entfernen. Verwenden Sie dazu die Methode Dataset#get(), um die aktuellen Metadaten abzurufen. Ändern Sie das Attribut „access“, um die gewünschte Entität auszuschließen, und rufen Sie dann die Funktion Dataset#setMetadata() auf, um die aktualisierte Zugriffsliste anzuwenden. 
    
/**
 * TODO(developer): Update and un-comment below lines
 */

// const datasetId = "my_project_id.my_dataset"

// ID of the user or group from whom you are revoking access.
// const entityId = "user-or-group-to-remove@example.com"

const {BigQuery} = require('@google-cloud/bigquery');

// Instantiate a client.
const bigquery = new BigQuery();

async function revokeDatasetAccess() {
  const [dataset] = await bigquery.dataset(datasetId).get();

  // To revoke access to a dataset, remove elements from the access list.
  //
  // See the BigQuery client library documentation for more details on access entries:
  // https://cloud.google.com/nodejs/docs/reference/bigquery/latest

  // Filter access entries to exclude entries matching the specified entity_id
  // and assign a new list back to the access list.
  dataset.metadata.access = dataset.metadata.access.filter(entry => {
    return !(
      entry.entity_id === entityId ||
      entry.userByEmail === entityId ||
      entry.groupByEmail === entityId
    );
  });

  // Update will only succeed if the dataset
  // has not been modified externally since retrieval.
  //
  // See the BigQuery client library documentation for more details on metadata updates:
  // https://cloud.google.com/bigquery/docs/updating-datasets

  // Update just the 'access entries' property of the dataset.
  await dataset.setMetadata(dataset.metadata);

  console.log(`Revoked access to '${entityId}' from '${datasetId}'.`);
}

    Python

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

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

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

# TODO(developer): Update and uncomment the lines below.

# ID of the dataset to revoke access to.
# dataset_id = "my-project.my_dataset"

# ID of the user or group from whom you are revoking access.
# Alternatively, the JSON REST API representation of the entity,
# such as a view's table reference.
# entity_id = "user-or-group-to-remove@example.com"

# Instantiate a client.
client = bigquery.Client()

# Get a reference to the dataset.
dataset = client.get_dataset(dataset_id)

# To revoke access to a dataset, remove elements from the AccessEntry list.
#
# See the BigQuery client library documentation for more details on `access_entries`:
# https://cloud.google.com/python/docs/reference/bigquery/latest/google.cloud.bigquery.dataset.Dataset#google_cloud_bigquery_dataset_Dataset_access_entries

# Filter `access_entries` to exclude entries matching the specified entity_id
# and assign a new list back to the AccessEntry list.
dataset.access_entries = [
    entry for entry in dataset.access_entries
    if entry.entity_id != entity_id
]

# Update will only succeed if the dataset
# has not been modified externally since retrieval.
#
# See the BigQuery client library documentation for more details on `update_dataset`:
# https://cloud.google.com/python/docs/reference/bigquery/latest/google.cloud.bigquery.client.Client#google_cloud_bigquery_client_Client_update_dataset
try:
    # Update just the `access_entries` property of the dataset.
    dataset = client.update_dataset(
        dataset,
        ["access_entries"],
    )

    # Notify user that the API call was successful.
    full_dataset_id = f"{dataset.project}.{dataset.dataset_id}"
    print(f"Revoked dataset access for '{entity_id}' to ' dataset '{full_dataset_id}.'")
except PreconditionFailed:  # A read-modify-write error.
    print(
        f"Dataset '{dataset.dataset_id}' was modified remotely before this update. "
        "Fetch the latest version and retry."
    )

Mit Tabellen- und Ansichtszugriffssteuerungen arbeiten

Ansichten werden in BigQuery als Tabellenressourcen behandelt. Sie können den Zugriff auf eine Tabelle oder Ansicht gewähren, indem Sie einem IAM-Hauptkonto eine vordefinierte oder benutzerdefinierte Rolle zuweisen, die festlegt, was das Hauptkonto mit der Tabelle oder Ansicht tun kann. Dies wird auch als Anhängen einer Zulassungsrichtlinie an eine Ressource bezeichnet. Nachdem Sie Zugriff gewährt haben, können Sie die Zugriffssteuerungen für die Tabelle oder Ansicht aufrufen und den Zugriff auf die Tabelle oder Ansicht widerrufen.

Zugriff auf eine Tabelle oder Ansicht gewähren

Für eine detaillierte Zugriffssteuerung können Sie eine vordefinierte oder benutzerdefinierte IAM-Rolle für eine bestimmte Tabelle oder Ansicht zuweisen. Die Tabelle oder Ansicht erbt auch die Zugriffssteuerung, die auf Dataset- und höherer Ebene angegeben ist. Wenn Sie einem Hauptkonto beispielsweise die Rolle „BigQuery Data Owner“ für ein Dataset zuweisen, hat dieses Hauptkonto auch die Berechtigungen „BigQuery Data Owner“ für die Tabellen und Ansichten im Dataset.

Wählen Sie eine der folgenden Optionen aus, um Zugriff auf eine Tabelle oder Ansicht zu gewähren:

Console

  1. Rufen Sie die Seite BigQuery auf.

    BigQuery aufrufen

  2. Maximieren Sie im Bereich Explorer Ihr Projekt und wählen Sie eine Tabelle oder Ansicht aus, die Sie freigeben möchten.

  3. Klicken Sie auf Freigeben.

  4. Klicken Sie auf Hauptkonto hinzufügen.

  5. Geben Sie im Feld Neue Hauptkonten ein Hauptkonto ein.

  6. Wählen Sie in der Liste Rolle auswählen eine vordefinierte oder eine benutzerdefinierte Rolle aus.

  7. Klicken Sie auf Speichern.

  8. Klicken Sie auf Schließen, um zu den Tabellen- oder Ansichtsdetails zurückzukehren.

SQL

Verwenden Sie die DCL-Anweisung GRANT, um Hauptkonten Zugriff auf Tabellen oder Ansichten zu gewähren:

  1. Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

    BigQuery aufrufen

  2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

    GRANT `ROLE_LIST`
ON RESOURCE_TYPE RESOURCE_NAME
TO "USER_LIST"

    Ersetzen Sie Folgendes:

    • ROLE_LIST: eine Rolle oder Liste mit durch Kommas getrennten Rollen, die Sie widerrufen möchten

    • RESOURCE_TYPE: der Ressourcentyp, auf den die Rolle angewendet wird

      Unterstützte Werte sind: TABLE, VIEW, MATERIALIZED VIEW und EXTERNAL TABLE.

    • RESOURCE_NAME: der Name der Ressource, für die Sie die Berechtigung gewähren möchten

    • USER_LIST: eine durch Kommas getrennte Liste von Nutzern, denen die Rolle zugewiesen wird

      Eine Liste der gültigen Formate finden Sie unter user_list.

  3. Klicken Sie auf Ausführen.

Informationen zum Ausführen von Abfragen finden Sie unter Interaktive Abfrage ausführen.

Im folgenden Beispiel wird die Rolle „BigQuery Data Viewer“ für myTable zugewiesen:

GRANT `roles/bigquery.dataViewer`
ON TABLE `myProject`.myDataset.myTable
TO "user:user@example.com", "user:user2@example.com"

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Verwenden Sie den Befehl bq add-iam-policy-binding, um Zugriff auf eine Tabelle oder Ansicht zu gewähren:

    bq add-iam-policy-binding --member=MEMBER_TYPE:MEMBER --role=ROLE
  --table=true RESOURCE

    Ersetzen Sie Folgendes:

    • MEMBER_TYPE: der Mitgliedstyp, z. B. user, group, serviceAccount oder domain.
    • MEMBER: Die E-Mail-Adresse oder der Domainname des Mitglieds.
    • ROLE: Die Rolle, die Sie dem Mitglied zuweisen möchten.
    • RESOURCE: Der Name der Tabelle oder Ansicht, deren Richtlinie Sie aktualisieren möchten.

    3. Terraform

    Mit den google_bigquery_table_iam-Ressourcen können Sie den Zugriff auf eine Tabelle aktualisieren.

    Zugriffsrichtlinie für ein Dataset festlegen

    Im folgenden Beispiel wird gezeigt, wie Sie mit der google_bigquery_table_iam_policy-Ressource die IAM-Richtlinie für die Tabelle mytable festlegen. Dadurch wird jede vorhandene Richtlinie ersetzt, die bereits an die Tabelle angehängt ist:

    # This file sets the IAM policy for the table created by
# https://github.com/terraform-google-modules/terraform-docs-samples/blob/main/bigquery/bigquery_create_table/main.tf.
# You must place it in the same local directory as that main.tf file,
# and you must have already applied that main.tf file to create
# the "default" table resource with a table_id of "mytable".

data "google_iam_policy" "iam_policy" {
  binding {
    role = "roles/bigquery.dataOwner"
    members = [
      "user:user@example.com",
    ]
  }
}

resource "google_bigquery_table_iam_policy" "table_iam_policy" {
  dataset_id  = google_bigquery_table.default.dataset_id
  table_id    = google_bigquery_table.default.table_id
  policy_data = data.google_iam_policy.iam_policy.policy_data
}

    Rollenmitgliedschaft für eine Tabelle festlegen

    Im folgenden Beispiel wird gezeigt, wie Sie mit der google_bigquery_table_iam_binding-Ressource die Mitgliedschaft in einer bestimmten Rolle für die Tabelle mytable festlegen. Dadurch wird jede vorhandene Mitgliedschaft in dieser Rolle ersetzt. Andere Rollen in der IAM-Richtlinie für die Tabelle werden beibehalten.

    # This file sets membership in an IAM role for the table created by
# https://github.com/terraform-google-modules/terraform-docs-samples/blob/main/bigquery/bigquery_create_table/main.tf.
# You must place it in the same local directory as that main.tf file,
# and you must have already applied that main.tf file to create
# the "default" table resource with a table_id of "mytable".

resource "google_bigquery_table_iam_binding" "table_iam_binding" {
  dataset_id = google_bigquery_table.default.dataset_id
  table_id   = google_bigquery_table.default.table_id
  role       = "roles/bigquery.dataOwner"

  members = [
    "group:group@example.com",
  ]
}

    Rollenmitgliedschaft für ein einzelnes Hauptkonto festlegen

    Im folgenden Beispiel wird gezeigt, wie Sie die google_bigquery_table_iam_member-Ressource verwenden, um die IAM-Richtlinie für die Tabelle mytable zu aktualisieren und einem Hauptkonto eine Rolle zuzuweisen. Das Aktualisieren dieser IAM-Richtlinie hat keine Auswirkungen auf den Zugriff anderer Principals, denen diese Rolle für das Dataset zugewiesen wurde.

    # This file adds a member to an IAM role for the table created by
# https://github.com/terraform-google-modules/terraform-docs-samples/blob/main/bigquery/bigquery_create_table/main.tf.
# You must place it in the same local directory as that main.tf file,
# and you must have already applied that main.tf file to create
# the "default" table resource with a table_id of "mytable".

resource "google_bigquery_table_iam_member" "table_iam_member" {
  dataset_id = google_bigquery_table.default.dataset_id
  table_id   = google_bigquery_table.default.table_id
  role       = "roles/bigquery.dataEditor"
  member     = "serviceAccount:bqcx-1234567891011-12a3@gcp-sa-bigquery-condel.iam.gserviceaccount.com"
}

    Führen Sie die Schritte in den folgenden Abschnitten aus, um Ihre Terraform-Konfiguration auf ein Google Cloud -Projekt anzuwenden.

    Cloud Shell vorbereiten

    1. Rufen Sie Cloud Shell auf.

    2. Legen Sie das Standardprojekt Google Cloud fest, auf das Sie Ihre Terraform-Konfigurationen anwenden möchten.

      Sie müssen diesen Befehl nur einmal pro Projekt und in jedem beliebigen Verzeichnis ausführen.

      export GOOGLE_CLOUD_PROJECT=PROJECT_ID

      Umgebungsvariablen werden überschrieben, wenn Sie in der Terraform-Konfigurationsdatei explizite Werte festlegen.

    Verzeichnis vorbereiten

    Jede Terraform-Konfigurationsdatei muss ein eigenes Verzeichnis haben (auch als Stammmodul bezeichnet).

    1. Erstellen Sie in Cloud Shell ein Verzeichnis und eine neue Datei in diesem Verzeichnis. Der Dateiname muss die Erweiterung .tf haben, z. B. main.tf. In dieser Anleitung wird die Datei als main.tf bezeichnet. 
      mkdir DIRECTORY && cd DIRECTORY && touch main.tf

    2. Wenn Sie einer Anleitung folgen, können Sie den Beispielcode in jedem Abschnitt oder Schritt kopieren.

      Kopieren Sie den Beispielcode in das neu erstellte main.tf.

      Kopieren Sie optional den Code aus GitHub. Dies wird empfohlen, wenn das Terraform-Snippet Teil einer End-to-End-Lösung ist.

    3. Prüfen und ändern Sie die Beispielparameter, die auf Ihre Umgebung angewendet werden sollen.
    4. Speichern Sie die Änderungen.
    5. Initialisieren Sie Terraform. Dies ist nur einmal für jedes Verzeichnis erforderlich. 
      terraform init

      Fügen Sie optional die Option -upgrade ein, um die neueste Google-Anbieterversion zu verwenden: 

      terraform init -upgrade

    Änderungen anwenden

    1. Prüfen Sie die Konfiguration und prüfen Sie, ob die Ressourcen, die Terraform erstellen oder aktualisieren wird, Ihren Erwartungen entsprechen: 
      terraform plan

      Korrigieren Sie die Konfiguration nach Bedarf.

    2. Wenden Sie die Terraform-Konfiguration an. Führen Sie dazu den folgenden Befehl aus und geben Sie yes an der Eingabeaufforderung ein: 
      terraform apply

      Warten Sie, bis Terraform die Meldung „Apply complete“ anzeigt.

    3. Öffnen Sie Ihr Google Cloud Projekt, um die Ergebnisse aufzurufen. Rufen Sie in der Google Cloud Console Ihre Ressourcen in der Benutzeroberfläche auf, um sicherzustellen, dass Terraform sie erstellt oder aktualisiert hat.

    API

    1. Rufen Sie die Methode tables.getIamPolicy auf, um die aktuelle Richtlinie abzurufen.

    2. Bearbeiten Sie die Richtlinie, um Mitglieder oder Zugriffssteuerungen oder beides hinzuzufügen. Das für die Richtlinie erforderliche Format finden Sie im Referenzthema Richtlinien.

    3. Rufen Sie tables.setIamPolicy auf, um die aktualisierte Richtlinie zu erstellen.

    Go

    Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Go in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Go API.

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

    Rufen Sie die IAM().SetPolicy()-Funktion der Ressource auf, um Änderungen an der Zugriffsrichtlinie für eine Tabelle oder Ansicht zu speichern. 
    import (
	"context"
	"fmt"
	"io"

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

// grantAccessToResource creates a new ACL conceding the VIEWER role to the group "example-analyst-group@google.com"
// For more information on the types of ACLs available see:
// https://cloud.google.com/storage/docs/access-control/lists
func grantAccessToResource(w io.Writer, projectID, datasetID, resourceID string) error {
	// Resource can be a table or a view
	//
	// TODO(developer): uncomment and update the following lines:
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// resourceID := "myresource"

	ctx := context.Background()

	// Create new client
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	// Get resource policy.
	policy, err := client.Dataset(datasetID).Table(resourceID).IAM().Policy(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	// Find more details about IAM Roles here:
	// https://pkg.go.dev/cloud.google.com/go/iam#RoleName
	entityID := "example-analyst-group@google.com"
	roleType := iam.Viewer

	// Add new policy.
	policy.Add(fmt.Sprintf("group:%s", entityID), roleType)

	// Update resource's policy.
	err = client.Dataset(datasetID).Table(resourceID).IAM().SetPolicy(ctx, policy)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	// Get resource policy again expecting the update.
	policy, err = client.Dataset(datasetID).Table(resourceID).IAM().Policy(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	fmt.Fprintf(w, "Details for Access entries in table or view %v.\n", resourceID)

	for _, role := range policy.Roles() {
		fmt.Fprintln(w)
		fmt.Fprintf(w, "Role: %s\n", role)
		fmt.Fprintf(w, "Entities: %v\n", policy.Members(role))
	}

	return nil
}

    Java

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

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

    import com.google.cloud.Identity;
import com.google.cloud.Policy;
import com.google.cloud.Role;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.TableId;

public class GrantAccessToTableOrView {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    // Project, dataset and resource (table or view) from which to get the access policy.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    String resourceName = "MY_TABLE_NAME";
    // Role to add to the policy access
    Role role = Role.of("roles/bigquery.dataViewer");
    // Identity to add to the policy access
    Identity identity = Identity.user("user-add@example.com");
    grantAccessToTableOrView(projectId, datasetName, resourceName, role, identity);
  }

  public static void grantAccessToTableOrView(
      String projectId, String datasetName, String resourceName, Role role, Identity identity) {
    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();

      // Create table identity given the projectId, the datasetName and the resourceName.
      TableId tableId = TableId.of(projectId, datasetName, resourceName);

      // Add new user identity to current IAM policy.
      Policy policy = bigquery.getIamPolicy(tableId);
      policy = policy.toBuilder().addIdentity(role, identity).build();

      // Update the IAM policy by setting the new one.
      bigquery.setIamPolicy(tableId, policy);

      System.out.println("IAM policy of resource \"" + resourceName + "\" updated successfully");
    } catch (BigQueryException e) {
      System.out.println("IAM policy was not updated. \n" + e.toString());
    }
  }
}

    Node.js

    Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

    Rufen Sie die aktuelle IAM-Richtlinie für eine Tabelle oder Ansicht mit der Table#getIamPolicy()-Funktion ab, ändern Sie die Richtlinie, indem Sie neue Bindungen hinzufügen, und speichern Sie die Änderungen an der Zugriffsrichtlinie mit der Table#setIamPolicy()-Funktion. 
    
/**
 * TODO(developer): Update and un-comment below lines
 */
// const projectId = "YOUR_PROJECT_ID";
// const datasetId = "YOUR_DATASET_ID";
// const tableId = "YOUR_TABLE_ID";
// const principalId = "YOUR_PRINCIPAL_ID";
// const role = "YOUR_ROLE";

const {BigQuery} = require('@google-cloud/bigquery');

// Instantiate a client.
const client = new BigQuery();

async function grantAccessToTableOrView() {
  const dataset = client.dataset(datasetId);
  const table = dataset.table(tableId);

  // Get the IAM access policy for the table or view.
  const [policy] = await table.getIamPolicy();

  // Initialize bindings array.
  if (!policy.bindings) {
    policy.bindings = [];
  }

  // To grant access to a table or view
  // add bindings to the Table or View policy.
  //
  // Find more details about Policy and Binding objects here:
  // https://cloud.google.com/security-command-center/docs/reference/rest/Shared.Types/Policy
  // https://cloud.google.com/security-command-center/docs/reference/rest/Shared.Types/Binding
  const binding = {
    role,
    members: [principalId],
  };
  policy.bindings.push(binding);

  // Set the IAM access policy with updated bindings.
  await table.setIamPolicy(policy);

  // Show a success message.
  console.log(
    `Role '${role}' granted for principal '${principalId}' on resource '${datasetId}.${tableId}'.`
  );
}

await grantAccessToTableOrView();

    Python

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

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

    Rufen Sie die client.set_iam_policy()-Funktion auf, um Änderungen an der Zugriffsrichtlinie für eine Tabelle oder Ansicht zu speichern. 
    from google.cloud import bigquery

# TODO(developer): Update and uncomment the lines below.

# Google Cloud Platform project.
# project_id = "my_project_id"

# Dataset where the table or view is.
# dataset_id = "my_dataset"

# Table or view name to get the access policy.
# resource_name = "my_table"

# Principal to grant access to a table or view.
# For more information about principal identifiers see:
# https://cloud.google.com/iam/docs/principal-identifiers
# principal_id = "user:bob@example.com"

# Role to grant to the principal.
# For more information about BigQuery roles see:
# https://cloud.google.com/bigquery/docs/access-control
# role = "roles/bigquery.dataViewer"

# Instantiate a client.
client = bigquery.Client()

# Get the full table or view name.
full_resource_name = f"{project_id}.{dataset_id}.{resource_name}"

# Get the IAM access policy for the table or view.
policy = client.get_iam_policy(full_resource_name)

# To grant access to a table or view, add bindings to the IAM policy.
#
# Find more details about Policy and Binding objects here:
# https://cloud.google.com/security-command-center/docs/reference/rest/Shared.Types/Policy
# https://cloud.google.com/security-command-center/docs/reference/rest/Shared.Types/Binding
binding = {
    "role": role,
    "members": [principal_id, ],
}
policy.bindings.append(binding)

# Set the IAM access policy with updated bindings.
updated_policy = client.set_iam_policy(full_resource_name, policy)

# Show a success message.
print(
    f"Role '{role}' granted for principal '{principal_id}'"
    f" on resource '{full_resource_name}'."
)

Vordefinierte Rollen, die Zugriff auf Tabellen und Ansichten gewähren

Ansichten werden in BigQuery als Tabellenressourcen behandelt. Für eine detaillierte Zugriffssteuerung können Sie eine vordefinierte oder benutzerdefinierte IAM-Rolle für eine bestimmte Tabelle oder Ansicht zuweisen. Die Tabelle oder Ansicht erbt auch die Zugriffssteuerung, die auf Dataset- und höherer Ebene angegeben ist. Wenn Sie einem Hauptkonto beispielsweise die Rolle „BigQuery Data Owner“ für ein Dataset zuweisen, hat dieses Hauptkonto auch die Berechtigungen „Data Owner“ für die Tabellen und Ansichten im Dataset.

Die folgenden vordefinierten IAM-Rollen haben Berechtigungen für Tabellen oder Ansichten.

Rolle Beschreibung
BigQuery-Dateninhaber (roles/bigquery.dataOwner) Wenn diese Rolle für eine Tabelle oder Ansicht gewährt wird, werden die folgenden Berechtigungen erteilt:
  • Alle Berechtigungen für die Tabelle oder Ansicht.
  • Alle Berechtigungen für Zeilenzugriffsrichtlinien mit Ausnahme der Berechtigung zum Überschreiben von Zeitreisebeschränkungen.
  • Kategorien und Datenrichtlinien auf Spaltenebene festlegen
BigQuery-Dateneditor (roles/bigquery.dataEditor) Wenn diese Rolle für eine Tabelle oder Ansicht gewährt wird, werden die folgenden Berechtigungen erteilt:
  • Metadaten abrufen, Metadaten aktualisieren, Zugriffssteuerungen abrufen und die Tabelle oder Ansicht löschen.
  • Tabellendaten abrufen (abfragen), exportieren, replizieren und aktualisieren.
  • Indexe erstellen, aktualisieren und löschen.
  • Snapshots erstellen und wiederherstellen.
BigQuery Data Viewer (roles/bigquery.dataViewer) Wenn diese Rolle für eine Tabelle oder Ansicht gewährt wird, werden die folgenden Berechtigungen erteilt:
  • Metadaten und Zugriffssteuerungen für die Tabelle oder Ansicht abrufen.
  • Tabellendaten abrufen (abfragen), exportieren und replizieren.
  • Snapshots erstellen.
BigQuery Metadata Viewer (roles/bigquery.metadataViewer) Wenn diese Rolle für eine Tabelle oder Ansicht gewährt wird, werden die folgenden Berechtigungen erteilt:
  • Metadaten und Zugriffssteuerungen für die Tabelle oder Ansicht abrufen.

Berechtigungen für Tabellen und Ansichten

Ansichten werden in BigQuery als Tabellenressourcen behandelt. Alle Berechtigungen auf Tabellenebene gelten für Ansichten.

Die meisten Berechtigungen, die mit bigquery.tables beginnen, gelten auf Tabellenebene. bigquery.tables.create und bigquery.tables.list nicht. Zum Erstellen und Auflisten von Tabellen oder Ansichten müssen einer Rolle in einem übergeordneten Container (dem Dataset oder dem Projekt) die Berechtigungen bigquery.tables.create und bigquery.tables.list gewährt werden.

In der folgenden Tabelle sind alle Berechtigungen für Tabellen und Ansichten sowie die Ressource der niedrigsten Ebene aufgeführt, für die sie gewährt werden können.

Berechtigung Ressource Aktion
bigquery.tables.create Dataset Erstellen Sie neue Tabellen im Dataset.
bigquery.tables.createIndex Tabelle Erstellen Sie einen Suchindex für die Tabelle.
bigquery.tables.deleteIndex Tabelle Löschen Sie einen Suchindex für die Tabelle.
bigquery.tables.createSnapshot Tabelle Erstellen Sie einen Snapshot der Tabelle. Zum Erstellen eines Snapshots sind mehrere zusätzliche Berechtigungen auf Tabellen- und Dataset-Ebene erforderlich. Weitere Informationen finden Sie unter Berechtigungen und Rollen für das Erstellen von Tabellen-Snapshots.
bigquery.tables.deleteSnapshot Tabelle Löschen eines Snapshots der Tabelle
bigquery.tables.delete Tabelle Eine Tabelle löschen
bigquery.tables.createTagBinding Tabelle Ressourcen-Tag-Bindungen für eine Tabelle erstellen.
bigquery.tables.deleteTagBinding Tabelle Ressourcen-Tag-Bindungen für eine Tabelle löschen.
bigquery.tables.listTagBindings Tabelle Ressourcen-Tag-Bindungen für eine Tabelle auflisten
bigquery.tables.listEffectiveTags Tabelle Effektive Tags (angewendet und übernommen) für die Tabelle auflisten.
bigquery.tables.export Tabelle Exportieren Sie die Daten der Tabelle. Für die Ausführung eines Exportjobs sind außerdem Berechtigungen des Typs bigquery.jobs.create erforderlich.
bigquery.tables.get Tabelle Metadaten für eine Tabelle abrufen.
bigquery.tables.getData Tabelle Tabellendaten abfragen Zum Ausführen eines Abfragejobs sind außerdem bigquery.jobs.create-Berechtigungen erforderlich.
bigquery.tables.getIamPolicy Tabelle Zugriffssteuerungen für die Tabelle abrufen.
bigquery.tables.list Dataset Alle Tabellen und Tabellenmetadaten im Dataset auflisten.
bigquery.tables.replicateData Tabelle Tabellendaten replizieren. Diese Berechtigung ist zum Erstellen von Replikaten für materialisierte Ansichten erforderlich.
bigquery.tables.restoreSnapshot Tabelle Tabellen-Snapshot wiederherstellen
bigquery.tables.setCategory Tabelle Legen Sie Richtlinien-Tags im Schema der Tabelle fest.
bigquery.tables.setColumnDataPolicy Tabelle Zugriffsrichtlinien auf Spaltenebene für eine Tabelle festlegen.
bigquery.tables.setIamPolicy Tabelle Zugriffssteuerungen für eine Tabelle festlegen
bigquery.tables.update Tabelle Tabelle aktualisieren. metadata. bigquery.tables.get ist auch erforderlich, um Tabellenmetadaten in der Konsole zu aktualisieren.
bigquery.tables.updateData Tabelle Tabellendaten aktualisieren.
bigquery.tables.updateIndex Tabelle Aktualisieren Sie einen Suchindex für die Tabelle.

Zugriffssteuerung für eine Tabelle oder Ansicht ansehen

Wählen Sie eine der folgenden Optionen aus, um die Zugriffssteuerung für eine Tabelle oder Ansicht aufzurufen:

Console

  1. Rufen Sie die Seite BigQuery auf.

    BigQuery aufrufen

  2. Maximieren Sie im Bereich Explorer Ihr Projekt und ein Dataset und wählen Sie eine Tabelle oder Ansicht aus.

  3. Klicken Sie auf Freigeben.

    Die Zugriffssteuerung für eine Tabelle oder Ansicht wird im Bereich Freigeben angezeigt.

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Verwenden Sie in Cloud Shell den Befehl bq get-iam-policy, um eine vorhandene Zugriffsrichtlinie abzurufen und in eine lokale Datei in JSON auszugeben:

    bq get-iam-policy \
    --table=true \
    PROJECT_ID:DATASET.RESOURCE > PATH_TO_FILE

    Ersetzen Sie Folgendes:

    • PROJECT_ID: Ihre Projekt-ID
    • DATASET: der Name Ihres Datasets
    • RESOURCE: der Name der Tabelle oder Ansicht, deren Richtlinie Sie aufrufen möchten
    • PATH_TO_FILE: der Pfad zur JSON-Datei auf dem lokalen Computer

    3. SQL

    Fragen Sie die Ansicht INFORMATION_SCHEMA.OBJECT_PRIVILEGES ab. Bei Abfragen zum Abrufen von Zugriffssteuerungen für eine Tabelle oder Ansicht müssen der object_schema und das object_name angegeben werden.

    1. Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

      BigQuery aufrufen

    2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

      SELECT
COLUMN_LIST
FROM
  PROJECT_ID.`region-REGION`.INFORMATION_SCHEMA.OBJECT_PRIVILEGES
WHERE
object_schema = "DATASET" AND object_name = "TABLE";

      Ersetzen Sie Folgendes:

      • COLUMN_LIST: Eine durch Kommas getrennte Liste von Spalten aus der Ansicht INFORMATION_SCHEMA.OBJECT_PRIVILEGES.
      • PROJECT_ID: Ihre Projekt-ID.
      • REGION: Ein Regions-Qualifier.
      • DATASET: der Name eines Datasets, das die Tabelle oder Ansicht enthält
      • TABLE: der Name der Tabelle oder Ansicht

    3. Klicken Sie auf Ausführen.

    Informationen zum Ausführen von Abfragen finden Sie unter Interaktive Abfrage ausführen.

    Beispiel:

    SELECT
object_name, privilege_type, grantee
FROM
my_project.`region-us`.INFORMATION_SCHEMA.OBJECT_PRIVILEGES
WHERE
object_schema = "mydataset" AND object_name = "mytable";
     
    +------------------+-----------------------------+--------------------------+
|   object_name    |  privilege_type             | grantee                  |
+------------------+-----------------------------+--------------------------+
| mytable          | roles/bigquery.dataEditor   | group:group@example.com|
| mytable          | roles/bigquery.dataOwner    | user:user@example.com|
+------------------+-----------------------------+--------------------------+

    API

    Rufen Sie die Methode tables.getIamPolicy auf, um die aktuelle Richtlinie abzurufen.

    Go

    Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Go in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Go API.

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

    Rufen Sie die IAM().Policy()-Funktion der Ressource auf. Rufen Sie dann die Funktion Roles() auf, um die Zugriffsrichtlinie für eine Tabelle oder Ansicht abzurufen. 
    import (
	"context"
	"fmt"
	"io"

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

// viewTableOrViewAccessPolicies retrieves the ACL for the given resource
// For more information on the types of ACLs available see:
// https://cloud.google.com/storage/docs/access-control/lists
func viewTableOrViewAccessPolicies(w io.Writer, projectID, datasetID, resourceID string) error {
	// Resource can be a table or a view
	//
	// TODO(developer): uncomment and update the following lines:
	// projectID := "my-project-id"
	// datasetID := "my-dataset-id"
	// resourceID := "my-resource-id"

	ctx := context.Background()

	// Create new client.
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	// Get resource's policy access.
	policy, err := client.Dataset(datasetID).Table(resourceID).IAM().Policy(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	fmt.Fprintf(w, "Details for Access entries in table or view %v.\n", resourceID)

	for _, role := range policy.Roles() {
		fmt.Fprintln(w)
		fmt.Fprintf(w, "Role: %s\n", role)
		fmt.Fprintf(w, "Entities: %v\n", policy.Members(role))
	}

	return nil
}

    Java

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

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

    
import com.google.cloud.Policy;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.TableId;

public class GetTableOrViewAccessPolicy {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    // Project, dataset and resource (table or view) from which to get the access policy.
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    String resourceName = "MY_RESOURCE_NAME";
    getTableOrViewAccessPolicy(projectId, datasetName, resourceName);
  }

  public static void getTableOrViewAccessPolicy(
      String projectId, String datasetName, String resourceName) {
    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();

      // Create table identity given the projectId, the datasetName and the resourceName.
      TableId tableId = TableId.of(projectId, datasetName, resourceName);

      // Get the table IAM policy.
      Policy policy = bigquery.getIamPolicy(tableId);

      // Show policy details.
      // Find more information about the Policy Class here:
      // https://cloud.google.com/java/docs/reference/google-cloud-core/latest/com.google.cloud.Policy
      System.out.println(
          "IAM policy info of resource \"" + resourceName + "\" retrieved succesfully");
      System.out.println();
      System.out.println("IAM policy info: " + policy.toString());
    } catch (BigQueryException e) {
      System.out.println("IAM policy info not retrieved. \n" + e.toString());
    }
  }
}

    Node.js

    Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

    Rufen Sie die IAM-Richtlinie für eine Tabelle oder Ansicht mit der Table#getIamPolicy()-Funktion ab. Die Details der Zugriffsrichtlinie sind im zurückgegebenen Richtlinienobjekt verfügbar. 
    
/**
 * TODO(developer): Update and un-comment below lines
 */
// const projectId = "YOUR_PROJECT_ID"
// const datasetId = "YOUR_DATASET_ID"
// const resourceName = "YOUR_RESOURCE_NAME";

const {BigQuery} = require('@google-cloud/bigquery');

// Instantiate a client.
const client = new BigQuery();

async function viewTableOrViewAccessPolicy() {
  const dataset = client.dataset(datasetId);
  const table = dataset.table(resourceName);

  // Get the IAM access policy for the table or view.
  const [policy] = await table.getIamPolicy();

  // Initialize bindings if they don't exist
  if (!policy.bindings) {
    policy.bindings = [];
  }

  // Show policy details.
  // Find more details for the Policy object here:
  // https://cloud.google.com/bigquery/docs/reference/rest/v2/Policy
  console.log(`Access Policy details for table or view '${resourceName}'.`);
  console.log(`Bindings: ${JSON.stringify(policy.bindings, null, 2)}`);
  console.log(`etag: ${policy.etag}`);
  console.log(`Version: ${policy.version}`);
}

Zugriff auf eine Tabelle oder Ansicht aufheben

Wählen Sie eine der folgenden Optionen aus, um den Zugriff auf eine Tabelle oder Ansicht zu widerrufen:

Console

  1. Rufen Sie die Seite BigQuery auf.

    BigQuery aufrufen

  2. Maximieren Sie im Bereich Explorer Ihr Projekt und ein Dataset und wählen Sie eine Tabelle oder Ansicht aus.

  3. Klicken Sie im Detailbereich auf Freigeben.

  4. Erweitern Sie im Dialogfeld Freigeben das Hauptkonto, dessen Zugriff Sie widerrufen möchten.

  5. Klicken Sie auf Löschen.

  6. Klicken Sie im Dialogfeld Rolle aus Hauptkonto entfernen? auf Entfernen.

  7. Klicken Sie auf Schließen, um zu den Tabellen- oder Ansichtsdetails zurückzukehren.

SQL

Verwenden Sie die DCL-Anweisung REVOKE, um den Zugriff auf Tabellen oder Ansichten aus Hauptkonten zu entfernen:

  1. Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

    BigQuery aufrufen

  2. Geben Sie im Abfrageeditor die folgende Anweisung ein:

    REVOKE `ROLE_LIST`
ON RESOURCE_TYPE RESOURCE_NAME
FROM "USER_LIST"

    Ersetzen Sie Folgendes:

    • ROLE_LIST: eine Rolle oder Liste mit durch Kommas getrennten Rollen, die Sie widerrufen möchten

    • RESOURCE_TYPE: der Ressourcentyp, von dem die Rolle widerrufen wird

      Unterstützte Werte sind: TABLE, VIEW, MATERIALIZED VIEW und EXTERNAL TABLE.

    • RESOURCE_NAME: der Name der Ressource, für die Sie die Berechtigung widerrufen möchten

    • USER_LIST: eine durch Kommas getrennte Liste von Nutzern, deren Rollen widerrufen werden

      Eine Liste der gültigen Formate finden Sie unter user_list.

  3. Klicken Sie auf Ausführen.

Informationen zum Ausführen von Abfragen finden Sie unter Interaktive Abfrage ausführen.

Im folgenden Beispiel wird die Rolle „BigQuery-Dateninhaber“ für myTable widerrufen:

REVOKE `roles/bigquery.dataOwner`
ON TABLE `myProject`.myDataset.myTable
FROM "group:group@example.com", "serviceAccount:user@myproject.iam.gserviceaccount.com"

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Verwenden Sie den Befehl bq remove-iam-policy-binding, um den Zugriff auf eine Tabelle oder Ansicht aufzuheben:

    bq remove-iam-policy-binding --member=MEMBER_TYPE:MEMBER --role=ROLE
--table=true RESOURCE

    Ersetzen Sie Folgendes:

    • MEMBER_TYPE: der Mitgliedstyp, z. B. user, group, serviceAccount oder domain
    • MEMBER: Die E-Mail-Adresse oder der Domainname des Mitglieds.
    • ROLE: Die Rolle, die Sie dem Mitglied entziehen möchten.
    • RESOURCE: der Name der Tabelle oder Ansicht, deren Richtlinie Sie aktualisieren möchten

    3. API

    1. Rufen Sie die Methode tables.getIamPolicy auf, um die aktuelle Richtlinie abzurufen.

    2. Bearbeiten Sie die Richtlinie, um Mitglieder oder Bindungen oder beides zu entfernen. Das für die Richtlinie erforderliche Format finden Sie im Referenzthema Richtlinien.

    3. Rufen Sie tables.setIamPolicy auf, um die aktualisierte Richtlinie zu erstellen.

    Go

    Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Go in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Go API.

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

    Rufen Sie die policy.Remove()-Funktion auf, um den Zugriff zu entfernen. Rufen Sie dann die IAM().SetPolicy()-Funktion auf, um Änderungen an der Zugriffsrichtlinie für eine Tabelle oder Ansicht zu speichern. 
    import (
	"context"
	"fmt"
	"io"

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

// revokeTableOrViewAccessPolicies creates a new ACL removing the VIEWER role to group "example-analyst-group@google.com"
// For more information on the types of ACLs available see:
// https://cloud.google.com/storage/docs/access-control/lists
func revokeTableOrViewAccessPolicies(w io.Writer, projectID, datasetID, resourceID string) error {
	// Resource can be a table or a view
	//
	// TODO(developer): uncomment and update the following lines:
	// projectID := "my-project-id"
	// datasetID := "mydataset"
	// resourceID := "myresource"

	ctx := context.Background()

	// Create new client
	client, err := bigquery.NewClient(ctx, projectID)
	if err != nil {
		return fmt.Errorf("bigquery.NewClient: %w", err)
	}
	defer client.Close()

	// Get resource policy.
	policy, err := client.Dataset(datasetID).Table(resourceID).IAM().Policy(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	// Find more details about IAM Roles here:
	// https://pkg.go.dev/cloud.google.com/go/iam#RoleName
	entityID := "example-analyst-group@google.com"
	roleType := iam.Viewer

	// Revoke policy access.
	policy.Remove(fmt.Sprintf("group:%s", entityID), roleType)

	// Update resource's policy.
	err = client.Dataset(datasetID).Table(resourceID).IAM().SetPolicy(ctx, policy)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	// Get resource policy again expecting the update.
	policy, err = client.Dataset(datasetID).Table(resourceID).IAM().Policy(ctx)
	if err != nil {
		return fmt.Errorf("bigquery.Dataset.Table.IAM.Policy: %w", err)
	}

	fmt.Fprintf(w, "Details for Access entries in table or view %v.\n", resourceID)

	for _, role := range policy.Roles() {
		fmt.Fprintln(w)
		fmt.Fprintf(w, "Role: %s\n", role)
		fmt.Fprintf(w, "Entities: %v\n", policy.Members(role))
	}

	return nil
}

    Java

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

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 

    import com.google.cloud.Identity;
import com.google.cloud.Policy;
import com.google.cloud.Role;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.TableId;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class RevokeAccessToTableOrView {

  public static void main(String[] args) {
    // TODO(developer): Replace these variables before running the sample.
    // Project, dataset and resource (table or view) from which to get the access policy
    String projectId = "MY_PROJECT_ID";
    String datasetName = "MY_DATASET_NAME";
    String resourceName = "MY_RESOURCE_NAME";
    // Role to remove from the access policy
    Role role = Role.of("roles/bigquery.dataViewer");
    // Identity to remove from the access policy
    Identity user = Identity.user("user-add@example.com");
    revokeAccessToTableOrView(projectId, datasetName, resourceName, role, user);
  }

  public static void revokeAccessToTableOrView(
      String projectId, String datasetName, String resourceName, Role role, Identity identity) {
    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();

      // Create table identity given the projectId, the datasetName and the resourceName.
      TableId tableId = TableId.of(projectId, datasetName, resourceName);

      // Remove either identities or roles, or both from bindings and replace it in
      // the current IAM policy.
      Policy policy = bigquery.getIamPolicy(tableId);
      // Create a copy of an immutable map.
      Map<Role, Set<Identity>> bindings = new HashMap<>(policy.getBindings());

      // Remove all identities with a specific role.
      bindings.remove(role);
      // Update bindings.
      policy = policy.toBuilder().setBindings(bindings).build();

      // Remove one identity in all the existing roles.
      for (Role roleKey : bindings.keySet()) {
        if (bindings.get(roleKey).contains(identity)) {
          // Create a copy of an immutable set if the identity is present in the role.
          Set<Identity> identities = new HashSet<>(bindings.get(roleKey));
          // Remove identity.
          identities.remove(identity);
          bindings.put(roleKey, identities);
          if (bindings.get(roleKey).isEmpty()) {
            // Remove the role if it has no identities.
            bindings.remove(roleKey);
          }
        }
      }
      // Update bindings.
      policy = policy.toBuilder().setBindings(bindings).build();

      // Update the IAM policy by setting the new one.
      bigquery.setIamPolicy(tableId, policy);

      System.out.println("IAM policy of resource \"" + resourceName + "\" updated successfully");
    } catch (BigQueryException e) {
      System.out.println("IAM policy was not updated. \n" + e.toString());
    }
  }
}

    Node.js

    Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Node.js in der BigQuery-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Angaben finden Sie in der Referenzdokumentation zur BigQuery Node.js API.

    Richten Sie zur Authentifizierung bei BigQuery die Standardanmeldedaten für Anwendungen ein. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten.

    Rufen Sie die aktuelle IAM-Richtlinie für eine Tabelle oder Ansicht mit der Methode Table#getIamPolicy() ab. Ändern Sie die Richtlinie, um die gewünschte Rolle oder das gewünschte Hauptkonto zu entfernen, und wenden Sie dann die aktualisierte Richtlinie mit der Methode Table#setIamPolicy() an. 
    
/**
 * TODO(developer): Update and un-comment below lines
 */
// const projectId = "YOUR_PROJECT_ID"
// const datasetId = "YOUR_DATASET_ID"
// const tableId = "YOUR_TABLE_ID"
// const roleToRemove = "YOUR_ROLE"
// const principalToRemove = "YOUR_PRINCIPAL_ID"

const {BigQuery} = require('@google-cloud/bigquery');

// Instantiate a client.
const client = new BigQuery();

async function revokeAccessToTableOrView() {
  const dataset = client.dataset(datasetId);
  const table = dataset.table(tableId);

  // Get the IAM access policy for the table or view.
  const [policy] = await table.getIamPolicy();

  // Initialize bindings array.
  if (!policy.bindings) {
    policy.bindings = [];
  }

  // To revoke access to a table or view,
  // remove bindings from the Table or View policy.
  //
  // Find more details about Policy objects here:
  // https://cloud.google.com/security-command-center/docs/reference/rest/Shared.Types/Policy

  if (principalToRemove) {
    // Create a copy of bindings for modifications.
    const bindings = [...policy.bindings];

    // Filter out the principal from each binding.
    for (const binding of bindings) {
      if (binding.members) {
        binding.members = binding.members.filter(
          m => m !== principalToRemove
        );
      }
    }

    // Filter out bindings with empty members.
    policy.bindings = bindings.filter(
      binding => binding.members && binding.members.length > 0
    );
  }

  if (roleToRemove) {
    // Filter out all bindings with the roleToRemove
    // and assign a new list back to the policy bindings.
    policy.bindings = policy.bindings.filter(b => b.role !== roleToRemove);
  }

  // Set the IAM access policy with updated bindings.
  await table.setIamPolicy(policy);

  // Both role and principal are removed
  if (roleToRemove !== null && principalToRemove !== null) {
    console.log(
      `Role '${roleToRemove}' revoked for principal '${principalToRemove}' on resource '${datasetId}.${tableId}'.`
    );
  }

  // Only role is removed
  if (roleToRemove !== null && principalToRemove === null) {
    console.log(
      `Role '${roleToRemove}' revoked for all principals on resource '${datasetId}.${tableId}'.`
    );
  }

  // Only principal is removed
  if (roleToRemove === null && principalToRemove !== null) {
    console.log(
      `Access revoked for principal '${principalToRemove}' on resource '${datasetId}.${tableId}'.`
    );
  }

  // No changes were made
  if (roleToRemove === null && principalToRemove === null) {
    console.log(
      `No changes made to access policy for '${datasetId}.${tableId}'.`
    );
  }
}

Zugriffssteuerungen für Routinen verwenden

Wenn Sie Feedback geben oder Support für dieses Feature anfordern möchten, senden Sie eine E-Mail an bq-govsec-eng@google.com.

Sie können den Zugriff auf eine Routine gewähren, indem Sie einem IAM-Hauptkonto](/iam/docs/principal-identifiers#allow) eine vordefinierte oder benutzerdefinierte Rolle zuweisen, die festlegt, was das Hauptkonto mit der Routine tun kann. Dies wird auch als Anhängen einer Zulassungsrichtlinie an eine Ressource bezeichnet. Nachdem du Zugriff gewährt hast, kannst du die Zugriffssteuerung für den Ablauf aufrufen und den Zugriff auf den Ablauf widerrufen.

Zugriff auf eine Routine gewähren

Für eine detaillierte Zugriffssteuerung können Sie eine vordefinierte oder benutzerdefinierte IAM-Rolle für eine bestimmte Routine zuweisen. Die Routine übernimmt auch die auf Dataset-Ebene und höher angegebenen Zugriffssteuerungen. Wenn Sie einem Hauptkonto beispielsweise die Rolle „BigQuery Data Owner“ für ein Dataset zuweisen, hat dieses Hauptkonto auch die Berechtigungen „Data Owner“ für die Routinen im Dataset.

Wählen Sie eine der folgenden Optionen aus:

Console

  1. Rufen Sie die Seite BigQuery auf.

    BigQuery aufrufen

  2. Maximieren Sie im Bereich Explorer Ihr Projekt und Ihr Dataset, maximieren Sie Abläufe und wählen Sie dann einen Ablauf aus.

  3. Klicken Sie auf Freigeben.

  4. Klicken Sie auf  Mitglieder hinzufügen.

  5. Geben Sie im Feld Neue Mitglieder ein Hauptkonto ein.

  6. Wählen Sie in der Liste Rolle auswählen eine vordefinierte oder eine benutzerdefinierte Rolle aus.

  7. Klicken Sie auf Speichern.

  8. Klicke auf Fertig, um zu den Informationen zur Routine zurückzukehren.

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Verwenden Sie den Befehl bq get-iam-policy, um die vorhandenen Routineninformationen (einschließlich Zugriffssteuerungen) in eine JSON-Datei zu schreiben:

    bq get-iam-policy \
    PROJECT_ID:DATASET.ROUTINE \
    > PATH_TO_FILE

    Ersetzen Sie Folgendes:

    • PROJECT_ID: Ihre Projekt-ID.
    • DATASET: der Name des Datasets, das die Routine enthält, die Sie aktualisieren möchten.
    • ROUTINE: der Name der Ressource, die aktualisiert werden soll
    • PATH_TO_FILE: der Pfad zur JSON-Datei auf dem lokalen Computer

  3. Nehmen Sie die Änderungen im Abschnitt bindings der JSON-Datei vor. Eine Bindung bindet ein oder mehrere Hauptkonten an eine einzelne role. Hauptkonten können Nutzerkonten, Dienstkonten, Google-Gruppen und Domains sein. Der Abschnitt bindings der JSON-Datei einer Routine sieht beispielsweise so aus:

    {
  "bindings": [
    {
      "role": "roles/bigquery.dataViewer",
      "members": [
        "user:user@example.com",
        "group:group@example.com",
        "domain:example.com",
      ]
    },
  ],
  "etag": "BwWWja0YfJA=",
  "version": 1
}

  4. Aktualisieren Sie Ihre Zugriffsrichtlinie mit dem Befehl bq set-iam-policy.

    bq set-iam-policy PROJECT_ID:DATASET.ROUTINE PATH_TO_FILE

  5. Geben Sie den Befehl bq get-iam-policy noch einmal ein, ohne die Informationen in eine Datei zu schreiben, um die Änderungen der Zugriffssteuerung zu prüfen:

    bq get-iam-policy --format=prettyjson \\
    PROJECT_ID:DATASET.ROUTINE

    6. API

    1. Rufen Sie die Methode routines.getIamPolicy auf, um die aktuelle Richtlinie abzurufen.

    2. Bearbeiten Sie die Richtlinie, um Hauptkonten, Bindungen oder beides hinzuzufügen. Das für die Richtlinie erforderliche Format finden Sie im Referenzthema Richtlinien.

    3. Rufen Sie routines.setIamPolicy auf, um die aktualisierte Richtlinie zu erstellen.

Vordefinierte Rollen, die Zugriff auf Routinen gewähren

Für eine detaillierte Zugriffssteuerung können Sie eine vordefinierte oder benutzerdefinierte IAM-Rolle für eine bestimmte Routine zuweisen. Die Routine übernimmt auch die auf Dataset-Ebene und höher angegebenen Zugriffssteuerungen. Wenn Sie einem Hauptkonto beispielsweise die Rolle „Data Owner“ für ein Dataset zuweisen, hat dieses Hauptkonto durch Vererbung auch die Berechtigungen „Data Owner“ für die Routinen im Dataset.

Die folgenden vordefinierten IAM-Rollen haben Berechtigungen für Routinen.

Rolle Beschreibung
BigQuery-Dateninhaber (roles/bigquery.dataOwner) Wenn diese Rolle für eine Routine gewährt wird, werden die folgenden Berechtigungen erteilt:
  • Alle Berechtigungen für die Routine.

Sie sollten die Rolle „Dateneigentümer“ nicht auf Routineebene zuweisen. Mit der Rolle „Datenbearbeiter“ werden auch alle Berechtigungen für die Routine gewährt. Sie ist eine Rolle mit weniger Berechtigungen.
BigQuery-Dateneditor (roles/bigquery.dataEditor) Wenn diese Rolle für eine Routine gewährt wird, werden die folgenden Berechtigungen erteilt:
  • Alle Berechtigungen für die Routine.
BigQuery Data Viewer (roles/bigquery.dataViewer) Wenn diese Rolle für eine Routine gewährt wird, werden die folgenden Berechtigungen erteilt:
  • In einer Anfrage auf einen Ablauf verweisen, der von einer anderen Person erstellt wurde.
BigQuery Metadata Viewer (roles/bigquery.metadataViewer) Wenn diese Rolle für eine Routine gewährt wird, werden die folgenden Berechtigungen erteilt:
  • In einer Anfrage auf einen Ablauf verweisen, der von einer anderen Person erstellt wurde.

Berechtigungen für Routinen

Die meisten Berechtigungen, die mit bigquery.routines beginnen, gelten auf Routineebene. bigquery.routines.create und bigquery.routines.list nicht. Zum Erstellen und Auflisten von Routinen müssen einer Rolle im übergeordneten Container (dem Dataset) die Berechtigungen bigquery.routines.create und bigquery.routines.list gewährt werden.

In der folgenden Tabelle sind alle Berechtigungen für Routinen und die Ressource der niedrigsten Ebene aufgeführt, für die sie gewährt werden können.

Berechtigung Ressource Beschreibung
bigquery.routines.create Dataset Erstellen Sie eine Routine im Dataset. Für diese Berechtigung ist auch bigquery.jobs.create erforderlich, um einen Abfragejob auszuführen, der eine CREATE FUNCTION-Anweisung enthält.
bigquery.routines.delete Routine Einen Ablauf löschen
bigquery.routines.get Routine Auf einen von einer anderen Person erstellten Ablauf verweisen Für diese Berechtigung ist auch bigquery.jobs.create erforderlich, um einen Abfragejob auszuführen, der auf die Routine verweist. Außerdem benötigen Sie die Berechtigung für den Zugriff auf alle Ressourcen, auf die die Routine verweist, z. B. auf Tabellen oder Ansichten.
bigquery.routines.list Dataset Routinen im Dataset auflisten und Metadaten für Routinen anzeigen.
bigquery.routines.update Routine Routinendefinitionen und -metadaten aktualisieren.
bigquery.routines.getIamPolicy Routine Zugriffssteuerungen für die Routine abrufen.
bigquery.routines.setIamPolicy Routine Zugriffssteuerung für die Routine festlegen

Zugriffssteuerungen für einen Ablauf aufrufen

Wählen Sie eine der folgenden Optionen aus, um die Zugriffssteuerung für eine Routine aufzurufen:

Console

  1. Rufen Sie die Seite BigQuery auf.

    BigQuery aufrufen

  2. Maximieren Sie im Bereich Explorer Ihr Projekt, das Dataset und Abläufe und wählen Sie dann einen Ablauf aus.

  3. Klicken Sie auf Freigeben.

    Die Zugriffssteuerungen der Routine werden im Bereich Freigeben angezeigt.

bq

Der Befehl bq get-iam-policy bietet keine Unterstützung für das Aufrufen von Zugriffssteuerungen für Routinen.

SQL

In der INFORMATION_SCHEMA.OBJECT_PRIVILEGES-Ansicht werden keine Zugriffssteuerungen für Routinen angezeigt.

API

Rufen Sie die Methode routines.getIamPolicy auf, um die aktuelle Richtlinie abzurufen.

Zugriff auf eine Routine widerrufen

Wähle eine der folgenden Optionen aus, um den Zugriff auf eine Routine zu widerrufen:

Console

  1. Rufen Sie die Seite BigQuery auf.

    BigQuery aufrufen

  2. Maximieren Sie im Bereich Explorer Ihr Projekt, maximieren Sie ein Dataset, maximieren Sie Abläufe und wählen Sie dann einen Ablauf aus.

  3. Klicken Sie im Detailbereich auf Freigabe > Berechtigungen.

  4. Erweitern Sie im Dialogfeld Berechtigungen für Routinen das Hauptkonto, dessen Zugriff Sie widerrufen möchten.

  5. Klicken Sie auf Hauptkonto entfernen.

  6. Klicken Sie im Dialogfeld Rolle aus Hauptkonto entfernen? auf Entfernen.

  7. Klicken Sie auf Schließen.

bq

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Verwenden Sie den Befehl bq get-iam-policy, um die vorhandenen Routineninformationen (einschließlich Zugriffssteuerungen) in eine JSON-Datei zu schreiben:

    bq get-iam-policy --routine PROJECT_ID:DATASET.ROUTINE > PATH_TO_FILE

    Ersetzen Sie Folgendes:

    • PROJECT_ID: Ihre Projekt-ID.
    • DATASET: der Name des Datasets, das die Routine enthält, die Sie aktualisieren möchten.
    • ROUTINE: der Name der Ressource, die aktualisiert werden soll
    • PATH_TO_FILE: der Pfad zur JSON-Datei auf dem lokalen Computer

    In der Richtliniendatei bleibt der Wert für version 1. Diese Nummer bezieht sich auf die Schemaversion der IAM-Richtlinie, nicht auf die Version der Richtlinie. Der Wert für etag ist die Versionsnummer der Richtlinie.

  3. Nehmen Sie die Änderungen im Abschnitt access der JSON-Datei vor. Sie können beliebige specialGroup-Einträge entfernen: projectOwners, projectWriters, projectReaders und allAuthenticatedUsers. Sie können auch die folgenden Elemente entfernen: userByEmail, groupByEmail und domain.

    Der Abschnitt access der JSON-Datei einer Routine sieht beispielsweise so aus:

    {
 "bindings": [
   {
     "role": "roles/bigquery.dataViewer",
     "members": [
       "user:user@example.com",
       "group:group@example.com",
       "domain:google.com",
     ]
   },
 ],
 "etag": "BwWWja0YfJA=",
 "version": 1
}

  4. Aktualisieren Sie Ihre Zugriffsrichtlinie mit dem Befehl bq set-iam-policy.

    bq set-iam-policy --routine PROJECT_ID:DATASET.ROUTINE PATH_TO_FILE

  5. Geben Sie den Befehl get-iam-policy noch einmal ein, ohne die Informationen in eine Datei zu schreiben, um die Änderungen der Zugriffssteuerung zu prüfen:

    bq get-iam-policy --routine --format=prettyjson PROJECT_ID:DATASET.ROUTINE

    6. API

    1. Rufen Sie die Methode routines.getIamPolicy auf, um die aktuelle Richtlinie abzurufen.

    2. Bearbeiten Sie die Richtlinie, um Hauptkonten oder Bindungen oder beides hinzuzufügen. Das für die Richtlinie erforderliche Format finden Sie im Referenzthema Richtlinien.

Geerbte Zugriffssteuerungen für eine Ressource ansehen

Sie können die geerbten IAM-Rollen für eine Ressource über die BigQuery-Web-UI ansehen. Sie benötigen die entsprechenden Berechtigungen, um die Vererbung in der Console aufzurufen. So prüfen Sie die Übernahme für ein Dataset, eine Tabelle, eine Ansicht oder eine Routine:

  1. Rufen Sie in der Google Cloud Console die Seite BigQuery auf.

    BigQuery aufrufen

  2. Wählen Sie im Bereich Explorer das Dataset aus oder maximieren Sie es und wählen Sie eine Tabelle, Ansicht oder Routine aus.

  3. Klicken Sie für ein Dataset auf Freigabe. Klicken Sie bei einer Tabelle, Ansicht oder Routine auf Freigeben.

  4. Prüfen Sie, ob die Option Geerbte Rollen in Tabelle anzeigen aktiviert ist.

    Die Option „Übernommene Rollen in Tabelle anzeigen“ in der Console

  5. Maximieren Sie eine Rolle in der Tabelle.

  6. In der Spalte Übernahme gibt das sechseckige Symbol an, ob die Rolle von einer übergeordneten Ressource übernommen wurde.

    Das Symbol „Von einer übergeordneten Ressource übernommen“

Zugriff auf eine Ressource verweigern

Mit IAM-Ablehnungsrichtlinien können Sie Leitlinien für den Zugriff auf BigQuery-Ressourcen festlegen. Sie können Ablehnungsregeln definieren, die verhindern, dass ausgewählte Hauptkonten bestimmte Berechtigungen verwenden, unabhängig von den ihnen zugewiesenen Rollen.

Informationen zum Erstellen, Aktualisieren und Löschen von Ablehnungsrichtlinien finden Sie unter Zugriff auf Ressourcen verweigern.

Sonderfälle

Berücksichtigen Sie die folgenden Szenarien, wenn Sie IAM-Ablehnungsrichtlinien für einige BigQuery-Berechtigungen erstellen:

  • Mit dem Zugriff auf autorisierte Ressourcen (Ansichten, Routinen, Datasets oder gespeicherte Prozeduren) können Sie eine Tabelle erstellen, löschen} oder bearbeiten sowie Tabellendaten lesen und ändern, auch wenn Sie keine direkte Berechtigung für diese Vorgänge haben. Sie können außerdem Modelldaten oder Metadaten abrufen und andere gespeicherte Prozeduren für die zugrunde liegende Tabelle aufrufen. Das bedeutet, dass die autorisierten Ressourcen die folgenden Berechtigungen haben:

    • bigquery.tables.get
    • bigquery.tables.list
    • bigquery.tables.getData
    • bigquery.tables.updateData
    • bigquery.tables.create
    • bigquery.tables.delete
    • bigquery.routines.get
    • bigquery.routines.list
    • bigquery.datasets.get
    • bigquery.models.getData
    • bigquery.models.getMetadata

    Wenn Sie den Zugriff auf diese autorisierten Ressourcen verweigern möchten, fügen Sie beim Erstellen der Ablehnungsrichtlinie einen der folgenden Werte in das Feld deniedPrincipal ein:

    Wert Anwendungsfall
    principalSet://goog/public:all Blockiert alle Hauptkonten, einschließlich autorisierter Ressourcen.
    principalSet://bigquery.googleapis.com/projects/PROJECT_NUMBER/* Blockiert alle autorisierten BigQuery-Ressourcen im angegebenen Projekt. PROJECT_NUMBER ist eine automatisch generierte eindeutige Kennung für Ihr Projekt vom Typ INT64.

  • Wenn Sie bestimmte Hauptkonten von der Ablehnungsrichtlinie ausnehmen möchten, geben Sie diese Hauptkonten im Feld exceptionPrincipals Ihrer Ablehnungsrichtlinie an. Beispiel: exceptionPrincipals: "principalSet://bigquery.googleapis.com/projects/1234/*"

  • BigQuery speichert Abfrageergebnisse eines Jobinhabers 24 Stunden lang im Cache. Der Jobinhaber kann darauf zugreifen, ohne die Berechtigung bigquery.tables.getData für die Tabelle mit den Daten zu benötigen. Wenn Sie also der Berechtigung bigquery.tables.getData eine IAM-Ablehnungsrichtlinie hinzufügen, wird der Zugriff auf zwischengespeicherte Ergebnisse für den Jobinhaber erst blockiert, wenn der Cache abläuft. Wenn Sie den Zugriff des Jobinhabers auf zwischengespeicherte Ergebnisse blockieren möchten, erstellen Sie eine separate Ablehnungsrichtlinie für die Berechtigung bigquery.jobs.create.

  • Um unbeabsichtigten Datenzugriff zu verhindern, wenn Sie Richtlinien zum Verweigern verwenden, um Lesevorgänge für Daten zu blockieren, empfehlen wir, dass Sie auch alle vorhandenen Abonnements für das Dataset überprüfen und widerrufen.

  • Wenn Sie eine IAM-Ablehnungsrichtlinie zum Ansehen von Dataset-Zugriffssteuerungen erstellen möchten, lehnen Sie die folgenden Berechtigungen ab:

    • bigquery.datasets.get
    • bigquery.datasets.getIamPolicy

  • Wenn Sie eine IAM-Ablehnungsrichtlinie zum Aktualisieren der Zugriffssteuerung für Datasets erstellen möchten, lehnen Sie die folgenden Berechtigungen ab:

    • bigquery.datasets.update
    • bigquery.datasets.setIamPolicy

Nächste Schritte

projects.testIamPermissions-Methode zum Testen des Nutzerzugriffs auf eine Ressource