Detaillierte Zugriffssteuerung konfigurieren

Hinweis zur PostgreSQL-Oberfläche: Eine detaillierte Zugriffssteuerung wird für PostgreSQL-Datenbanken nicht unterstützt.

Auf dieser Seite wird erläutert, wie Sie eine detaillierte Zugriffssteuerung für Cloud Spanner-Datenbanken konfigurieren.

Weitere Informationen zur detaillierten Zugriffssteuerung finden Sie unter Detaillierte Zugriffssteuerung.

Die Konfiguration einer detaillierten Zugriffssteuerung umfasst die folgenden Schritte:

1. Datenbankrollen erstellen und Berechtigungen erteilen

2. Optional: Rollenhierarchie mit Übernahme erstellen

3. Cloud Identity and Access Management-Hauptkonten (IAM) Zugriff auf Datenbankrollen gewähren

Nutzer mit detaillierter Zugriffssteuerung müssen dann eine Datenbankrolle angeben, um Abfragen, DML- oder Zeilenvorgänge für die Datenbank auszuführen.

Datenbankrollen erstellen und Berechtigungen erteilen

Eine Datenbankrolle ist eine Sammlung von detaillierten Zugriffsberechtigungen. Sie können für jede Datenbank bis zu 100 Datenbankrollen erstellen.

Legen Sie Rollen und Rollenhierarchien in Ihrer Datenbank fest und codieren Sie sie in DDL. Wie bei anderen Schemaänderungen in Spanner empfehlen wir dringend, Schemaänderungen nicht im Batch, sondern in einem Batch vorzunehmen. Weitere Informationen finden Sie unter Häufigkeit der Schemaaktualisierungen beschränken.

Console

So erstellen Sie eine Datenbankrolle und gewähren detaillierte Berechtigungen dafür:

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

   Instanzen

2. Wählen Sie die Instanz mit der Datenbank aus, für die Sie die Rolle hinzufügen möchten.

3. Wählen Sie die Datenbank aus.

4. Klicken Sie auf der Seite Übersicht auf DDL schreiben.

5. Führen Sie auf der Seite DDL-Anweisungen schreiben für jede Datenbankrolle, die Sie erstellen und für die Sie Berechtigungen erteilen möchten, die folgenden Schritte aus:

   1. Geben Sie die folgende Anweisung ein, um die Rolle zu erstellen:

      CREATE ROLE ROLE_NAME;
      

      Klicken Sie noch nicht auf Senden.

   2. Wenn Sie Berechtigungen für die Rolle erteilen möchten, geben Sie in der nächsten Zeile nach der Anweisung CREATE ROLE die Anweisung GRANT ein.

      Informationen zur Syntax der Anweisung GRANT finden Sie unter Google SQL-Datendefinitionssprache. Weitere Informationen zu Berechtigungen finden Sie unter Detaillierte Zugriffssteuerung.

      Wenn Sie beispielsweise SELECT, INSERT und UPDATE in den Tabellen employees und contractors der Datenbankrolle hr_manager zuweisen möchten, geben Sie die folgende Anweisung ein:

      GRANT SELECT, INSERT, UPDATE ON TABLE employees, contractors TO ROLE hr_manager;
      

      Hinweis: Verwenden Sie denselben Namen für Schemaobjektnamen, die Sie beim Erstellen der Objekte verwendet haben. Wenn Sie beispielsweise eine Tabelle mit dem Namen Customers erstellt haben, müssen Sie den Namen Customers (mit Großbuchstaben C) in der GRANT-Anweisung verwenden.

      Sie können eine DDL-Vorlage für die GRANT-Anweisung verwenden. Wählen Sie im Drop-down-Menü DDL-VORLAGEN die Option Datenbankrollen und dann unter Rollenberechtigungen erteilen eine Vorlage aus.

6. Klicken Sie auf Senden.

   Wenn die DDL Fehler enthält, gibt die Google Cloud Console einen Fehler zurück.

gcloud

Verwenden Sie den Befehl gcloud spanner databases ddl update mit Anweisungen CREATE ROLE und GRANT, um eine Datenbankrolle zu erstellen und detaillierte Zugriffsberechtigungen zu erteilen.

Informationen zur Syntax der Anweisungen CREATE ROLE und GRANT finden Sie unter Google SQL-Datendefinitionssprache.

Verwenden Sie beispielsweise den folgenden Befehl, um eine Datenbankrolle zu erstellen und ihr Berechtigungen für eine oder mehrere Tabellen zu gewähren.

gcloud spanner databases ddl update DATABASE_NAME --instance=INSTANCE_NAME \
--ddl='CREATE ROLE ROLE_NAME; GRANT PRIVILEGES ON TABLE TABLES TO ROLE ROLE_NAME;'

• PRIVILEGES ist eine durch Kommas getrennte Liste detaillierter Berechtigungen für die Zugriffssteuerung. Informationen zu Berechtigungen finden Sie unter Detaillierte Zugriffssteuerungsberechtigungen.

• TABLES ist eine durch Kommas getrennte Liste von Tabellen.

Wenn Sie beispielsweise SELECT, INSERT und UPDATE in den Tabellen employees und contractors der Datenbankrolle hr_analyst in der Datenbank hrdb1 in der Instanz hr zuweisen möchten, geben Sie die folgende Anweisung ein:

gcloud spanner databases ddl update hrdb1 --instance=hr \
--ddl='CREATE ROLE hr_analyst; GRANT SELECT, INSERT, UPDATE ON TABLE employees, contractors TO ROLE hr_analyst;'

Hinweis: Verwenden Sie denselben Namen für Schemaobjektnamen, die Sie beim Erstellen der Objekte verwendet haben. Wenn Sie beispielsweise eine Tabelle mit dem Namen Customers erstellt haben, müssen Sie den Namen Customers (mit Großbuchstaben C) in der GRANT-Anweisung verwenden.

Clientbibliotheken

In diesen Codebeispielen wird eine Datenbankrolle erstellt und gelöscht.

C++

Auf GitHub ansehen Feedback

void AddAndDropDatabaseRole(
    google::cloud::spanner_admin::DatabaseAdminClient client,
    std::string const& project_id, std::string const& instance_id,
    std::string const& database_id, std::string const& role_parent,
    std::string const& role_child) {
  google::cloud::spanner::Database database(project_id, instance_id,
                                            database_id);
  std::vector<std::string> grant_statements = {
      "CREATE ROLE " + role_parent,
      "GRANT SELECT ON TABLE Singers TO ROLE " + role_parent,
      "CREATE ROLE " + role_child,
      "GRANT ROLE " + role_parent + " TO ROLE " + role_child,
  };
  auto metadata =
      client.UpdateDatabaseDdl(database.FullName(), grant_statements).get();
  google::cloud::spanner_testing::LogUpdateDatabaseDdl(  //! TODO(#4758)
      client, database, metadata.status());              //! TODO(#4758)
  if (!metadata) throw std::move(metadata).status();
  std::cout << "Created roles " << role_parent << " and " << role_child
            << " and granted privileges\n";

  std::vector<std::string> revoke_statements = {
      "REVOKE ROLE " + role_parent + " FROM ROLE " + role_child,
      "DROP ROLE " + role_child,
  };
  metadata =
      client.UpdateDatabaseDdl(database.FullName(), revoke_statements).get();
  google::cloud::spanner_testing::LogUpdateDatabaseDdl(  //! TODO(#4758)
      client, database, metadata.status());              //! TODO(#4758)
  if (!metadata) throw std::move(metadata).status();
  std::cout << "Revoked privileges and dropped role " << role_child << "\n";
}

C#

Auf GitHub ansehen Feedback

using Google.Cloud.Spanner.Data;
using System.Threading.Tasks;

public class AddAndDropDatabaseRoleAsyncSample
{
    public async Task AddDatabaseRoleAsync(string projectId, string instanceId, string databaseId, string databaseRole)
    {
        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";
        string createRoleStatement = $"CREATE ROLE {databaseRole}";

        // Creates the given database role.
        using var connection = new SpannerConnection(connectionString);
        using var updateCmd = connection.CreateDdlCommand(createRoleStatement);
        await updateCmd.ExecuteNonQueryAsync();
    }

    public async Task DropDatabaseRoleAsync(string projectId, string instanceId, string databaseId, string databaseRole)
    {
        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";
        string deleteRoleStatement = $"DROP ROLE {databaseRole}";

        // Drops the given database role.
        using var connection = new SpannerConnection(connectionString);
        using var updateCmd = connection.CreateDdlCommand(deleteRoleStatement);
        await updateCmd.ExecuteNonQueryAsync();
    }
}

Einfach loslegen (Go)

Auf GitHub ansehen Feedback

import (
	"context"
	"io"

	database "cloud.google.com/go/spanner/admin/database/apiv1"
	adminpb "google.golang.org/genproto/googleapis/spanner/admin/database/v1"
)

func addAndDropDatabaseRole(w io.Writer, db string) error {
	ctx := context.Background()
	adminClient, err := database.NewDatabaseAdminClient(ctx)
	if err != nil {
		return err
	}
	defer adminClient.Close()

	// Set up database roles and membership. After database roles are created,
	// users can be granted roles by setting IAM policies.
	op, err := adminClient.UpdateDatabaseDdl(ctx, &adminpb.UpdateDatabaseDdlRequest{
		Database: db,
		Statements: []string{
			"CREATE ROLE parent",
			"GRANT SELECT ON TABLE Albums TO ROLE parent",
			"CREATE ROLE child",
			"GRANT ROLE parent TO ROLE child",
		},
	})
	if err != nil {
		return err
	}
	if err := op.Wait(ctx); err != nil {
		return err
	}

	// Delete role and membership.
	op, err = adminClient.UpdateDatabaseDdl(ctx, &adminpb.UpdateDatabaseDdlRequest{
		Database: db,
		Statements: []string{
			"REVOKE ROLE parent FROM ROLE child",
			"DROP ROLE child",
		},
	})
	if err != nil {
		return err
	}
	if err := op.Wait(ctx); err != nil {
		return err
	}
	return nil
}

Java

Auf GitHub ansehen Feedback

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.spanner.DatabaseAdminClient;
import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.common.collect.ImmutableList;
import com.google.spanner.admin.database.v1.UpdateDatabaseDdlMetadata;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class AddAndDropDatabaseRole {

  static void addAndDropDatabaseRole() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    String databaseId = "my-database";
    String parentRole = "my-new-parent-role";
    String childRole = "my-new-child-role";
    addAndDropDatabaseRole(projectId, instanceId, databaseId, parentRole, childRole);
  }

  static void addAndDropDatabaseRole(
      String projectId, String instanceId, String databaseId, String parentRole, String childRole) {
    try (Spanner spanner =
                 SpannerOptions.newBuilder()
                         .setProjectId(projectId)
                         .build()
                         .getService())  {
      final DatabaseAdminClient adminClient = spanner.getDatabaseAdminClient();
      OperationFuture<Void, UpdateDatabaseDdlMetadata> operation =
          adminClient.updateDatabaseDdl(
              instanceId,
              databaseId,
              ImmutableList.of(
                  "CREATE ROLE " + parentRole,
                  "GRANT SELECT ON TABLE Albums TO ROLE " + parentRole,
                  "CREATE ROLE " + childRole,
                  "GRANT ROLE " + parentRole + " TO ROLE " + childRole),
              null);
      try {
        System.out.println("Waiting for role create operation to complete...");
        operation.get(5, TimeUnit.MINUTES);
        System.out.printf(
            "Created roles %s and %s and granted privileges%n", parentRole, childRole);
        // Delete role and membership.
        operation =
            adminClient.updateDatabaseDdl(
                instanceId,
                databaseId,
                ImmutableList.of(
                    "REVOKE ROLE " + parentRole + " FROM ROLE " + childRole,
                    "DROP ROLE " + childRole),
                null);
        System.out.println("Waiting for role revoke & drop operation to complete...");
        operation.get(5, TimeUnit.MINUTES);
        System.out.printf("Revoked privileges and dropped role %s%n", childRole);
      } catch (ExecutionException | TimeoutException e) {
        System.out.printf(
            "Error: AddAndDropDatabaseRole failed with error message %s\n", e.getMessage());
        e.printStackTrace();
      } catch (InterruptedException e) {
        System.out.println(
            "Error: Waiting for AddAndDropDatabaseRole operation to finish was interrupted");
      }
    }
  }
}

Node.js

Auf GitHub ansehen Feedback

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const instanceId = 'my-instance';
// const databaseId = 'my-database';
// const projectId = 'my-project-id';
// Imports the Google Cloud Spanner client library
const {Spanner} = require('@google-cloud/spanner');

// Instantiates a client
const spanner = new Spanner({
  projectId: projectId,
});

async function addAndDropNewDatabaseRole() {
  // Gets a reference to a Cloud Spanner instance and database.
  const instance = spanner.instance(instanceId);
  const database = instance.database(databaseId);

  // Creates a new user defined role and grant permissions
  try {
    const request = [
      'CREATE ROLE parent',
      'GRANT SELECT ON TABLE Singers TO ROLE parent',
      'CREATE ROLE child',
      'GRANT ROLE parent TO ROLE child',
    ];
    const [operation] = await database.updateSchema(request);

    console.log('Waiting for operation to complete...');
    await operation.promise();

    console.log('Created roles child and parent and granted privileges');
  } catch (err) {
    console.error('ERROR:', err);
  }

  // Revoke permissions and drop child role.
  // A role can't be dropped until all its permissions are revoked.
  try {
    const request = ['REVOKE ROLE parent FROM ROLE child', 'DROP ROLE child'];
    const [operation] = await database.updateSchema(request);

    console.log('Waiting for operation to complete...');
    await operation.promise();

    console.log('Revoked privileges and dropped role child');
  } catch (err) {
    console.error('ERROR:', err);
  } finally {
    // Close the database when finished.
    await database.close();
  }
}
addAndDropNewDatabaseRole();

PHP

Auf GitHub ansehen Feedback

use Google\Cloud\Spanner\SpannerClient;

/**
 * Adds and drops roles to the Singers table in the example database.
 * Example:
 * ```
 * add_drop_database_role($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function add_drop_database_role(string $instanceId, string $databaseId): void
{
    $spanner = new SpannerClient();
    $instance = $spanner->instance($instanceId);
    $database = $instance->database($databaseId);

    $roleParent = 'new_parent';
    $roleChild = 'new_child';

    $operation = $database->updateDdlBatch([
        sprintf('CREATE ROLE %s', $roleParent),
        sprintf('GRANT SELECT ON TABLE Singers TO ROLE %s', $roleParent),
        sprintf('CREATE ROLE %s', $roleChild),
        sprintf('GRANT ROLE %s TO ROLE %s', $roleParent, $roleChild)
    ]);

    printf('Waiting for create role and grant operation to complete...%s', PHP_EOL);
    $operation->pollUntilComplete();

    printf('Created roles %s and %s and granted privileges%s', $roleParent, $roleChild, PHP_EOL);

    $operation = $database->updateDdlBatch([
        sprintf('REVOKE ROLE %s FROM ROLE %s', $roleParent, $roleChild),
        sprintf('DROP ROLE %s', $roleChild)
    ]);

    printf('Waiting for revoke role and drop role operation to complete...%s', PHP_EOL);
    $operation->pollUntilComplete();

    printf('Revoked privileges and dropped role %s%s', $roleChild, PHP_EOL);
}

Python

Auf GitHub ansehen Feedback

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"
spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)
role_parent = "new_parent"
role_child = "new_child"

operation = database.update_ddl(
    [
        "CREATE ROLE {}".format(role_parent),
        "GRANT SELECT ON TABLE Singers TO ROLE {}".format(role_parent),
        "CREATE ROLE {}".format(role_child),
        "GRANT ROLE {} TO ROLE {}".format(role_parent, role_child),
    ]
)
operation.result(OPERATION_TIMEOUT_SECONDS)
print(
    "Created roles {} and {} and granted privileges".format(role_parent, role_child)
)

operation = database.update_ddl(
    [
        "REVOKE ROLE {} FROM ROLE {}".format(role_parent, role_child),
        "DROP ROLE {}".format(role_child),
    ]
)
operation.result(OPERATION_TIMEOUT_SECONDS)
print("Revoked privileges and dropped role {}".format(role_child))

Ruby

Auf GitHub ansehen Feedback

require "google/cloud/spanner"

def spanner_add_and_drop_database_role project_id:, instance_id:, database_id:
  # project_id  = "Your Google Cloud project ID"
  # instance_id = "Your Spanner instance ID"
  # database_id = "Your Spanner database ID"

  admin_client = Google::Cloud::Spanner::Admin::Database::V1::DatabaseAdmin::Client.new
  role_parent = "new_parent"
  role_child = "new_child"

  db_path = admin_client.database_path project: project_id, instance: instance_id, database: database_id

  job = admin_client.update_database_ddl database: db_path, statements: [
    "CREATE ROLE #{role_parent}",
    "GRANT SELECT ON TABLE Singers TO ROLE #{role_parent}",
    "CREATE ROLE #{role_child}",
    "GRANT ROLE #{role_parent} TO ROLE #{role_child}"
  ]

  job.wait_until_done!
  puts "Created roles #{role_parent} and #{role_child} and granted privileges"

  job = admin_client.update_database_ddl database: db_path, statements: [
    "REVOKE ROLE #{role_parent} FROM ROLE #{role_child}",
    "DROP ROLE #{role_child}"
  ]

  job.wait_until_done!
  puts "Revoked privileges and dropped role #{role_child}"
end

Hierarchie von Rollen mit Übernahme erstellen

Sie können eine Hierarchie von Datenbankrollen erstellen, indem Sie einer anderen eine Rollen zuweisen. Untergeordnete Rollen (Mitgliederrollen) übernehmen die Berechtigungen des übergeordneten Elements.

Verwenden Sie die folgende Anweisung, um einer anderen Datenbankrolle eine Datenbankrolle zuzuweisen:

GRANT ROLE role1 TO ROLE role2;

Weitere Informationen finden Sie unter Hierarchierollen und Vererbung von Datenbanken.

IAM-Hauptkonten Zugriff auf Datenbankrollen gewähren

Mit IAM gewähren Sie Zugriff auf Datenbankrollen.

Console

So gewähren Sie einem IAM-Hauptkonto Zugriff auf Datenbankrollen:

1. Klicken Sie auf der Seite Übersicht der Datenbank auf Infofeld ansehen, wenn das Infofeld noch nicht geöffnet ist.

2. Klicken Sie auf PRINZIPAL HINZUFÜGEN.

3. Geben Sie im Bereich Zugriff auf database_name gewähren unter Hauptkonten hinzufügen ein oder mehrere IAM-Hauptkonten an.

4. Wählen Sie unter Rollen zuweisen im Menü Rolle auswählen die Option Cloud Spanner > Nutzer mit fein abgestimmtem Zugriff aus.

   Sie müssen diese Rolle jedem Hauptkonto nur einmal zuweisen. Sie macht das Hauptkonto zu einem Nutzer mit detaillierter Zugriffssteuerung.

5. Klicken Sie auf WEITERE ROLLE HINZUFÜGEN.

6. Wählen Sie im Menü Rolle auswählen die Option Cloud Spanner > Nutzer der Cloud Spanner-Datenbankrolle aus.

   Achtung: Wählen Sie nicht Cloud Spanner-Datenbanknutzer aus.

7. Führen Sie die folgenden Schritte aus, um die IAM-Bedingung zu erstellen, die die zuzuweisenden Rollen angibt.

   Achtung: Wenn Sie keine Bedingung hinzufügen, hat das Hauptkonto Zugriff auf alle Datenbankrollen.

   1. Klicken Sie neben der Rolle „Nutzer von Cloud Spanner-Datenbankrollen“ auf IAM-BEDINGUNG HINZUFÜGEN.

   2. Geben Sie im Bereich Bedingung hinzufügen einen Titel und optional eine Beschreibung für die Bedingung ein.

      Wenn Sie eine einzelne Datenbankrolle zuweisen, fügen Sie in der Regel den Rollennamen in den Bedingungstitel ein. Wenn Sie mehrere Rollen gewähren, können Sie etwas über die Gruppe von Rollen angeben.

   3. Klicken Sie auf BEDINGUNGSEDITOR.

   4. Geben Sie im Feld Ausdruck den folgenden Code ein:

      resource.type == "spanner.googleapis.com/DatabaseRole" &&
      resource.name.endsWith("/ROLE")
      

      Ersetzen Sie ROLE durch Ihren Rollennamen.

      Wenn Sie mehr als einer Rolle Zugriff auf das Hauptkonto gewähren möchten, fügen Sie weitere Bedingungen mit dem Operator or (||) hinzu, wie im folgenden Beispiel gezeigt:

      resource.type == "spanner.googleapis.com/DatabaseRole" &&
      (resource.name.endsWith("/ROLE1") || resource.name.endsWith("/ROLE2"))
      

      Mit diesem Code werden zwei Rollen zugewiesen. Ersetzen Sie ROLE1 und ROLE2 durch Ihre Rollennamen. Wenn Sie mehr als zwei Rollen zuweisen möchten, fügen Sie weitere oder Bedingungen hinzu.

      Sie können einen beliebigen Bedingungsausdruck verwenden, der von IAM unterstützt wird. Weitere Informationen finden Sie unter Übersicht über IAM-Bedingungen.

   5. Klicken Sie auf Speichern.

   6. Überprüfen Sie im vorherigen Bereich, ob die Bedingung in der Spalte IAM-Bedingung neben dem Feld Rolle angezeigt wird.

   7. Klicken Sie auf Speichern.

      Beachten Sie im Infofeld unter Rolle/Hauptkonto, dass für jede definierte Bedingung Cloud Spanner-Datenbankrollennutzer angezeigt wird.

      Die Zahl in Klammern neben der Bedingung gibt die Anzahl der Hauptkonten an, denen die Datenbankrolle durch diese Bedingung zugewiesen wurde. Sie können auf den Erweiterungspfeil klicken, um die Liste der Hauptkonten aufzurufen.

   8. So korrigieren Sie Fehler in Namen oder Bedingungen von Datenbankrollen oder fügen zusätzliche Datenbankrollen für ein Hauptkonto hinzu:

      1. Maximieren Sie den Eintrag Cloud Spanner-Datenbankrollennutzer, in dem die gewünschte Bedingung aufgeführt ist.

      2. Klicken Sie neben einem Hauptkonto auf das Stiftsymbol Bearbeiten.

      3. Führen Sie im Bereich Bearbeitungszugriff auf database_name einen der folgenden Schritte aus:

         • Klicken Sie auf WEITERE ROLLE HINZUFÜGEN.

         • Klicken Sie zum Bearbeiten der Bedingung auf das Stiftsymbol Bearbeiten neben dem Namen der Bedingung. Klicken Sie dann auf der Seite Bedingung bearbeiten auf Bedingungseditor bearbeiten, nehmen Sie Korrekturen vor und klicken Sie zweimal auf Speichern.

gcloud

So gewähren Sie einem IAM-Hauptkonto Zugriff auf Datenbankrollen:

1. Mit dem Befehl gcloud spanner databases add-iam-policy-binding können Sie eine detaillierte Zugriffssteuerung für das Hauptkonto aktivieren:

   gcloud spanner databases add-iam-policy-binding DATABASE_NAME \
   --instance=INSTANCE_NAME \
   --role=roles/spanner.fineGrainedAccessUser \
   --member=MEMBER_NAME \
   --condition=None
   

   • MEMBER_NAME ist die Kennung für das Hauptkonto. Er muss das Format user|group|serviceAccount:email oder domain:domain haben.

   • Mit diesem Befehl wird das Hauptkonto zu einem Nutzer mit detaillierter Zugriffssteuerung. Senden Sie diesen Befehl nur einmal pro Hauptkonto.

   • Bei Erfolg gibt der Befehl die gesamte Richtlinie für die Datenbank aus.

2. Mit dem Befehl gcloud spanner databases add-iam-policy-binding erteilen Sie die Berechtigung zur Verwendung einer oder mehrerer Datenbankrollen:

   gcloud spanner databases add-iam-policy-binding DATABASE_NAME \
   --instance=INSTANCE_NAME \
   --role=roles/spanner.databaseRoleUser \
   --member=MEMBER_NAME \
   --condition=CONDITION
   

   • MEMBER_NAME ist die Kennung für das Hauptkonto. Er muss das Format user|group|serviceAccount:email oder domain:domain haben.

   • CONDITION ist ein IAM-Bedingungsausdruck, der die Rollen angibt, die dem Hauptkonto gewährt werden sollen.

     CONDITION hat das folgende Format:

     --condition='expression=(resource.type == "spanner.googleapis.com/DatabaseRole" && resource.name.endsWith("/ROLE1")),title=TITLE,description=DESCRIPTION'
     

     Wenn Sie mehr als einer Rolle Zugriff auf das Hauptkonto gewähren möchten, fügen Sie weitere Bedingungen mit dem Operator or (||) hinzu, wie im folgenden Beispiel gezeigt:

     --condition='expression=(resource.type == "spanner.googleapis.com/DatabaseRole" && (resource.name.endsWith("/ROLE1") || resource.name.endsWith("/ROLE2"))),title=TITLE,description=DESCRIPTION'
     

     Mit diesem Code werden zwei Rollen zugewiesen. Ersetzen Sie ROLE1 und ROLE2 durch Ihre Rollennamen. Wenn Sie mehr als zwei Rollen zuweisen möchten, fügen Sie mit dem Operator || weitere oder Bedingungen hinzu.

     Sie können einen beliebigen Bedingungsausdruck verwenden, der von IAM unterstützt wird. Weitere Informationen finden Sie unter Übersicht über IAM-Bedingungen.

   Achtung: Wenn Sie keine Bedingung angeben, hat das Hauptkonto Zugriff auf alle Datenbankrollen.

   Bei Erfolg gibt der Befehl die gesamte Richtlinie für die Datenbank aus.

   Im folgenden Beispiel werden dem Hauptkonto [e-mail] die Datenbankrollen hr_rep und hr_manager zugewiesen.

   gcloud spanner databases add-iam-policy-binding myDatabase \
     --instance=myInstance \
     --role=roles/spanner.databaseRoleUser \
     --member=user:[e-mail] \
     --condition='expression=(resource.type == "spanner.googleapis.com/DatabaseRole" && (resource.name.endsWith("/hr_rep") || resource.name.endsWith("/hr_manager"))),title=HR roles,description=Grant permissions on HR roles'
   

Clientbibliotheken

C++

Auf GitHub ansehen Feedback

void EnableFineGrainedAccess(
    google::cloud::spanner_admin::DatabaseAdminClient client,
    std::string const& project_id, std::string const& instance_id,
    std::string const& database_id, std::string const& iam_member,
    std::string const& database_role, std::string const& title) {
  google::cloud::spanner::Database database(project_id, instance_id,
                                            database_id);

  google::iam::v1::GetIamPolicyRequest request;
  request.set_resource(database.FullName());
  request.mutable_options()->set_requested_policy_version(3);
  auto policy = client.GetIamPolicy(request);
  if (!policy) throw std::move(policy).status();
  if (policy->version() < 3) policy->set_version(3);

  auto& binding = *policy->add_bindings();
  binding.set_role("roles/spanner.fineGrainedAccessUser");
  binding.add_members(iam_member);
  auto& condition = *binding.mutable_condition();
  condition.set_expression("resource.name.endsWith(\"/databaseRoles/" +
                           database_role + "\")");
  condition.set_title(title);

  auto new_policy =
      client.SetIamPolicy(database.FullName(), *std::move(policy));
  if (!new_policy) throw std::move(new_policy).status();
  std::cout << "Enabled fine-grained access in IAM. New policy has version "
            << new_policy->version() << "\n";
}

C#

Auf GitHub ansehen Feedback

using Google.Api.Gax;
using Google.Cloud.Iam.V1;
using Google.Cloud.Spanner.Admin.Database.V1;

public class EnableFineGrainedAccessSample
{
    public Policy EnableFineGrainedAccess(
        string projectId, string instanceId, string databaseId,
        string databaseRole, string iamMember)
    {
        var resourceName = new UnparsedResourceName($"projects/{projectId}/instances/{instanceId}/databases/{databaseId}");

        var client = new DatabaseAdminClientBuilder().Build();

        // Request policy version 3 as earlier versions do not support condition field in role binding.
        // For more information see https://cloud.google.com/iam/docs/policies#versions.

        GetIamPolicyRequest getIamPolicyRequest = new GetIamPolicyRequest
        {
            ResourceAsResourceName = resourceName,
            Options = new GetPolicyOptions
            {
                RequestedPolicyVersion = 3
            }
        };

        var policy = client.GetIamPolicy(getIamPolicyRequest);

        // Gives the given IAM member access to the all the database roles
        // with resource name ending in ../databaseRoles/{databaseRole}.
        // For more information see https://cloud.google.com/iam/docs/conditions-overview.
        Binding newBinding = new Binding
        {
            Role = "roles/spanner.fineGrainedAccessUser",
            Members = { iamMember },
            Condition = new Google.Type.Expr
            {
                Title = "DatabaseRoleBindingTitle",
                Expression = $"resource.name.endsWith('/databaseRoles/{databaseRole}')"
            }
        };

        policy.Bindings.Add(newBinding);
        if (policy.Version < 3)
        {
            policy.Version = 3;
        }
        SetIamPolicyRequest setIamPolicyRequest = new SetIamPolicyRequest
        {
            Policy = policy,
            ResourceAsResourceName = resourceName,
        };
        var updatedPolicy = client.SetIamPolicy(setIamPolicyRequest);
        return updatedPolicy;
    }
}

Einfach loslegen (Go)

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"

	database "cloud.google.com/go/spanner/admin/database/apiv1"
	iampb "google.golang.org/genproto/googleapis/iam/v1"
	expr "google.golang.org/genproto/googleapis/type/expr"
)

func enableFineGrainedAccess(w io.Writer, db string, iamMember string, databaseRole string, title string) error {
	// iamMember = "user:[e-mail]"
	// databaseRole = "parent"
	// title = "condition title"
	ctx := context.Background()
	adminClient, err := database.NewDatabaseAdminClient(ctx)
	if err != nil {
		return err
	}
	defer adminClient.Close()

	policy, err := adminClient.GetIamPolicy(ctx, &iampb.GetIamPolicyRequest{
		Resource: db,
		Options: &iampb.GetPolicyOptions{
			// IAM conditions need at least version 3
			RequestedPolicyVersion: 3,
		},
	})
	if err != nil {
		return err
	}

	// IAM conditions need at least version 3
	if policy.Version < 3 {
		policy.Version = 3
	}
	policy.Bindings = append(policy.Bindings, []*iampb.Binding{
		{
			Role:    "roles/spanner.fineGrainedAccessUser",
			Members: []string{iamMember},
		},
		{
			Role:    "roles/spanner.databaseRoleUser",
			Members: []string{iamMember},
			Condition: &expr.Expr{
				Expression: fmt.Sprintf(`resource.name.endsWith("/databaseRoles/%s")`, databaseRole),
				Title:      title,
			},
		},
	}...)
	_, err = adminClient.SetIamPolicy(ctx, &iampb.SetIamPolicyRequest{
		Resource: db,
		Policy:   policy,
	})
	if err != nil {
		return err
	}

	fmt.Fprintf(w, "Enabled fine-grained access in IAM.\n")
	return nil
}

Java

Auf GitHub ansehen Feedback

import com.google.cloud.Binding;
import com.google.cloud.Condition;
import com.google.cloud.Policy;
import com.google.cloud.spanner.DatabaseAdminClient;
import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.common.collect.ImmutableList;

public class EnableFineGrainedAccess {

  static void enableFineGrainedAccess() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    String databaseId = "my-database";
    String iamMember = "user:[e-mail]";
    String role = "my-role";
    String title = "my-condition-title";
    enableFineGrainedAccess(projectId, instanceId, databaseId, iamMember, title, role);
  }

  static void enableFineGrainedAccess(
      String projectId,
      String instanceId,
      String databaseId,
      String iamMember,
      String title,
      String role) {
    try (Spanner spanner =
                 SpannerOptions.newBuilder()
                         .setProjectId(projectId)
                         .build()
                         .getService()) {
      final DatabaseAdminClient adminClient = spanner.getDatabaseAdminClient();
      Policy policy = adminClient.getDatabaseIAMPolicy(instanceId, databaseId, 3);
      int policyVersion = policy.getVersion();
      // The policy in the response from getDatabaseIAMPolicy might use the policy version
      // that you specified, or it might use a lower policy version. For example, if you
      // specify version 3, but the policy has no conditional role bindings, the response
      // uses version 1. Valid values are 0, 1, and 3.
      if (policy.getVersion() < 3) {
        // conditional role bindings work with policy version 3
        policyVersion = 3;
      }

      Binding binding1 =
          Binding.newBuilder()
              .setRole("roles/spanner.fineGrainedAccessUser")
              .setMembers(ImmutableList.of(iamMember))
              .build();

      Binding binding2 =
          Binding.newBuilder()
              .setRole("roles/spanner.databaseRoleUser")
              .setCondition(
                  Condition.newBuilder()
                      .setDescription(title)
                      .setExpression(
                          String.format("resource.name.endsWith(\"/databaseRoles/%s\")", role))
                      .setTitle(title)
                      .build())
              .setMembers(ImmutableList.of(iamMember))
              .build();
      ImmutableList<Binding> bindings =
          ImmutableList.<Binding>builder()
              .addAll(policy.getBindingsList())
              .add(binding1)
              .add(binding2)
              .build();
      Policy policyWithConditions =
          Policy.newBuilder()
              .setVersion(policyVersion)
              .setEtag(policy.getEtag())
              .setBindings(bindings)
              .build();
      Policy response =
          adminClient.setDatabaseIAMPolicy(instanceId, databaseId, policyWithConditions);
      System.out.printf(
          "Enabled fine-grained access in IAM with version %d%n", response.getVersion());
    }
  }
}

Node.js

Auf GitHub ansehen Feedback

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const instanceId = 'my-instance';
// const databaseId = 'my-database';
// const projectId = 'my-project-id';
// iamMember = 'user:[e-mail]';
// databaseRole = 'parent';
// title = 'condition title';
// Imports the Google Cloud Spanner client library
const {Spanner} = require('@google-cloud/spanner');

// Instantiates a client
const spanner = new Spanner({
  projectId: projectId,
});

async function enableFineGrainedAccess() {
  // Gets a reference to a Cloud Spanner instance and database.
  const instance = spanner.instance(instanceId);
  const database = instance.database(databaseId);

  const [policy] = await database.getIamPolicy({requestedPolicyVersion: 3});
  if (policy.version < 3) {
    policy.version = 3;
  }

  const newBinding = {
    role: 'roles/spanner.fineGrainedAccessUser',
    members: [`user:${iamMember}`],
    condition: {
      title: title,
      expression: `resource.name.endsWith("/databaseRoles/${databaseRole}")`,
    },
  };
  policy.bindings.push(newBinding);
  await database.setIamPolicy({policy: policy});
  // Requested Policy Version is Optional. The maximum policy version that will be used to format the policy.
  // Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected.
  const newPolicy = await database.getIamPolicy({requestedPolicyVersion: 3});
  console.log(newPolicy);
}
enableFineGrainedAccess();

PHP

Auf GitHub ansehen Feedback

use Google\Cloud\Spanner\Admin\Database\V1\DatabaseAdminClient;
use \Google\Cloud\Iam\V1\Binding;
use \Google\Type\Expr;

/**
 * Enable Fine Grained Access.
 * Example:
 * ```
 * enable_fine_grained_access($projectId, $instanceId, $databaseId, $iamMember, $databaseRole, $title);
 * ```
 *
 * @param string $projectId The Google cloud project ID
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 * @param string $iamMember The IAM member. Eg: `user:{emailid}`,
 *        `serviceAccount:{emailid}`, `group:{emailid}`, `domain:{domain}`
 * @param string $databaseRole The database role bound to
 *        the IAM member.
 * @param string $title Condition title.
 */
function enable_fine_grained_access(
    string $projectId,
    string $instanceId,
    string $databaseId,
    string $iamMember,
    string $databaseRole,
    string $title
): void {
    $adminClient = new DatabaseAdminClient();
    $resource = sprintf('projects/%s/instances/%s/databases/%s', $projectId, $instanceId, $databaseId);
    $policy = $adminClient->getIamPolicy($resource);

    // IAM conditions need at least version 3
    if ($policy->getVersion() != 3) {
        $policy->setVersion(3);
    }

    $binding = new Binding([
        'role' => 'roles/spanner.fineGrainedAccessUser',
        'members' => [$iamMember],
        'condition' => new Expr([
            'title' => $title,
            'expression' => sprintf("resource.name.endsWith('/databaseRoles/%s')", $databaseRole)
        ])
    ]);
    $policy->setBindings([$binding]);
    $adminClient->setIamPolicy($resource, $policy);

    printf('Enabled fine-grained access in IAM' . PHP_EOL);
}

Python

Auf GitHub ansehen Feedback

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"
# iam_member = "user:[e-mail]"
# database_role = "new_parent"
# title = "condition title"
spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)

# The policy in the response from getDatabaseIAMPolicy might use the policy version
# that you specified, or it might use a lower policy version. For example, if you
# specify version 3, but the policy has no conditional role bindings, the response
# uses version 1. Valid values are 0, 1, and 3.
policy = database.get_iam_policy(3)
if policy.version < 3:
    policy.version = 3

new_binding = policy_pb2.Binding(
    role="roles/spanner.fineGrainedAccessUser",
    members=[iam_member],
    condition=expr_pb2.Expr(
        title=title,
        expression=f'resource.name.endsWith("/databaseRoles/{database_role}")',
    ),
)

policy.version = 3
policy.bindings.append(new_binding)
database.set_iam_policy(policy)

new_policy = database.get_iam_policy(3)
print(
    f"Enabled fine-grained access in IAM. New policy has version {new_policy.version}"
)

Ruby

Auf GitHub ansehen Feedback

require "google/cloud/spanner"

def spanner_enable_fine_grained_access project_id:, instance_id:, database_id:, iam_member:, database_role:, title:
  # project_id  = "Your Google Cloud project ID"
  # instance_id = "Your Spanner instance ID"
  # database_id = "Your Spanner database ID"
  # iam_member = "user:[e-mail]"
  # database_role = "new_parent"
  # title = "condition title"

  admin_client = Google::Cloud::Spanner::Admin::Database::V1::DatabaseAdmin::Client.new
  db_path = admin_client.database_path project: project_id, instance: instance_id, database: database_id

  policy = admin_client.get_iam_policy resource: db_path, options: { requested_policy_version: 3 }

  policy.version = 3 if policy.version < 3

  binding = Google::Iam::V1::Binding.new(
    role: "roles/spanner.fineGrainedAccessUser",
    members: [iam_member],
    condition: Google::Type::Expr.new(
      title: title,
      expression: "resource.name.endsWith('/databaseRoles/#{database_role}')"
    )
  )

  policy.bindings << binding
  result = admin_client.set_iam_policy resource: db_path, policy: policy

  puts "Enabled fine-grained access in IAM."
end

Hauptkonto auf detaillierte Zugriffssteuerung umstellen

So wechseln Sie ein IAM-Hauptkonto von der Zugriffssteuerung auf Datenbankebene zur detaillierten Zugriffssteuerung:

1. Aktivieren Sie eine detaillierte Zugriffssteuerung für das Hauptkonto und gewähren Sie Zugriff auf alle erforderlichen Datenbankrollen, wie unter IAM-Hauptkonten Zugriff auf Datenbankrollen gewähren beschrieben.

2. Aktualisieren Sie alle Anwendungen, die als dieses Hauptkonto ausgeführt werden. Geben Sie in Aufrufen von Clientbibliotheksmethoden die entsprechenden Datenbankrollen an.

3. Widerrufen Sie alle IAM-Rollen auf Datenbankebene für das Hauptkonto. Auf diese Weise wird der Zugriff für das Hauptkonto nur von einer Methode geregelt.

   Folgen Sie der Anleitung unter Berechtigungen auf Datenbankebene entfernen, um IAM-Rollen auf Datenbankebene zu widerrufen.

Datenbankrollen auflisten

Sie können die einer Rolle zugeordneten Datenbankrollen auflisten.

Console

Geben Sie zum Auflisten von Datenbankrollen die folgende Abfrage auf der Seite Abfrage für die Datenbank ein:

SELECT * FROM INFORMATION_SCHEMA.ROLES;

Die Antwort enthält die aktuelle Rolle und die Rollen, deren Berechtigungen die aktuelle Rolle durch Übernahme verwenden kann. Verwenden Sie den gcloud-Befehl, um alle Rollen abzurufen.

gcloud

Geben Sie den folgenden Befehl ein, um eine ungefilterte Liste der Datenbankrollen zu erhalten. Hierfür ist die Berechtigung spanner.databaseRoles.list erforderlich.

gcloud spanner databases roles list --database=DATABASE_NAME --instance=INSTANCE_NAME

Clientbibliotheken

C++

Auf GitHub ansehen Feedback

void ListDatabaseRoles(google::cloud::spanner_admin::DatabaseAdminClient client,
                       std::string const& project_id,
                       std::string const& instance_id,
                       std::string const& database_id) {
  google::cloud::spanner::Database database(project_id, instance_id,
                                            database_id);
  std::cout << "Database Roles are:\n";
  for (auto& role : client.ListDatabaseRoles(database.FullName())) {
    if (!role) throw std::move(role).status();
    std::cout << role->name() << "\n";
  }
}

C#

Auf GitHub ansehen Feedback

using Google.Api.Gax;
using Google.Cloud.Spanner.Admin.Database.V1;
using System;

public class ListDatabaseRolesSample
{
    public PagedEnumerable<ListDatabaseRolesResponse, DatabaseRole> ListDatabaseRoles(string projectId, string instanceId, string databaseId)
    {
        string parent = $"projects/{projectId}/instances/{instanceId}/databases/{databaseId}";
        var client = DatabaseAdminClient.Create();
        PagedEnumerable<ListDatabaseRolesResponse, DatabaseRole> databaseRoles = client.ListDatabaseRoles(parent);
        foreach (var dbRole in databaseRoles)
        {
            Console.WriteLine($"Database Role: {dbRole.DatabaseRoleName}");
        }
        return databaseRoles;
    }
}

Einfach loslegen (Go)

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"
	"strings"

	"google.golang.org/api/iterator"

	database "cloud.google.com/go/spanner/admin/database/apiv1"
	adminpb "google.golang.org/genproto/googleapis/spanner/admin/database/v1"
)

func listDatabaseRoles(w io.Writer, db string) error {
	ctx := context.Background()
	adminClient, err := database.NewDatabaseAdminClient(ctx)
	if err != nil {
		return err
	}
	defer adminClient.Close()

	iter := adminClient.ListDatabaseRoles(ctx, &adminpb.ListDatabaseRolesRequest{
		Parent: db,
	})
	rolePrefix := db + "/databaseRoles/"
	for {
		role, err := iter.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		if !strings.HasPrefix(role.Name, rolePrefix) {
			return fmt.Errorf("Role %v does not have prefix %v", role.Name, rolePrefix)
		}
		fmt.Fprintf(w, "%s\n", strings.TrimPrefix(role.Name, rolePrefix))
	}
	return nil
}

Java

Auf GitHub ansehen Feedback

import com.google.cloud.spanner.DatabaseAdminClient;
import com.google.cloud.spanner.DatabaseId;
import com.google.cloud.spanner.DatabaseRole;
import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import java.util.concurrent.ExecutionException;

public class ListDatabaseRoles {

  static void listDatabaseRoles() throws InterruptedException, ExecutionException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    String databaseId = "my-database";
    listDatabaseRoles(projectId, instanceId, databaseId);
  }

  static void listDatabaseRoles(String projectId, String instanceId, String databaseId) {
    try (Spanner spanner =
                 SpannerOptions.newBuilder()
                         .setProjectId(projectId)
                         .build()
                         .getService()) {
      final DatabaseAdminClient adminClient = spanner.getDatabaseAdminClient();
      String databasePath = DatabaseId.of(projectId, instanceId, databaseId).getName();
      System.out.println("List of Database roles");
      for (DatabaseRole role : adminClient.listDatabaseRoles(instanceId, databaseId).iterateAll()) {
        System.out.printf("%s%n", role.getName());
      }
    }
  }
}

Node.js

Auf GitHub ansehen Feedback

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const instanceId = 'my-instance';
// const databaseId = 'my-database';
// const projectId = 'my-project-id';
// Imports the Google Cloud Spanner client library
const {Spanner} = require('@google-cloud/spanner');

// Instantiates a client
const spanner = new Spanner({
  projectId: projectId,
});

async function getDatabaseRoles() {
  // Gets a reference to a Cloud Spanner instance and database.
  const instance = spanner.instance(instanceId);
  const database = instance.database(databaseId);

  // Fetching database roles
  const [databaseRoles] = await database.getDatabaseRoles();
  console.log(`Roles for Database: ${database.formattedName_}`);
  databaseRoles.forEach(role => {
    console.log(`Role: ${role.name}`);
  });
}
getDatabaseRoles();

PHP

Auf GitHub ansehen Feedback

use Google\Cloud\Spanner\Admin\Database\V1\DatabaseAdminClient;

/**
 * List Database roles in the given database.
 * Example:
 * ```
 * list_database_roles($projectId, $instanceId, $databaseId);
 * ```
 *
 * @param string $projectId The Google cloud project ID
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function list_database_roles(
    string $projectId,
    string $instanceId,
    string $databaseId
): void {
    $adminClient = new DatabaseAdminClient();
    $resource = sprintf('projects/%s/instances/%s/databases/%s', $projectId, $instanceId, $databaseId);

    $roles = $adminClient->listDatabaseRoles($resource);
    printf('List of Database roles:' . PHP_EOL);
    foreach ($roles as $role) {
        printf($role->getName() . PHP_EOL);
    }
}

Python

Auf GitHub ansehen Feedback

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"
spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)

# List database roles.
print("Database Roles are:")
for role in database.list_database_roles():
    print(role.name.split("/")[-1])

Ruby

Auf GitHub ansehen Feedback

require "google/cloud/spanner"

def spanner_list_database_roles project_id:, instance_id:, database_id:
  # project_id  = "Your Google Cloud project ID"
  # instance_id = "Your Spanner instance ID"
  # database_id = "Your Spanner database ID"

  admin_client = Google::Cloud::Spanner::Admin::Database::V1::DatabaseAdmin::Client.new

  db_path = admin_client.database_path project: project_id, instance: instance_id, database: database_id

  result = admin_client.list_database_roles parent: db_path

  puts "List of Database roles:"
  result.each do |role|
    puts role.name
  end
end

Berechtigungen ansehen, die einer Datenbankrolle gewährt wurden

Führen Sie die folgenden Abfragen aus, um die einer Rolle gewährten Berechtigungen anzuzeigen:

SELECT * FROM INFORMATION_SCHEMA.TABLE_PRIVILEGES WHERE grantee = 'ROLE_NAME';
SELECT * FROM INFORMATION_SCHEMA.COLUMN_PRIVILEGES WHERE grantee = 'ROLE_NAME';
SELECT * FROM INFORMATION_SCHEMA.CHANGE_STREAM_PRIVILEGES WHERE grantee = 'ROLE_NAME';

INFORMATION_SCHEMA.TABLE_PRIVILEGES gibt Berechtigungen für Tabellen und Ansichten zurück. Die Berechtigungen SELECT, INSERT und UPDATE in TABLE_PRIVILEGES werden auch in COLUMN_PRIVILEGES angezeigt.

Hinweis: Wenn alle Berechtigungen für eine Tabelle auf eine Teilmenge von Spalten beschränkt sind, ist die Tabelle nicht in der Ergebnismenge der TABLE_PRIVILEGES-Abfrage enthalten.

Nutzer der detaillierten Zugriffssteuerung ansehen

Führen Sie den folgenden Befehl aus, um eine Liste der Hauptkonten aufzurufen, die eine detaillierte Zugriffssteuerung ermöglichen. Zum Ausführen des Befehls müssen Sie die Cloud Asset API in Ihrem Projekt aktiviert und die IAM-Berechtigung cloudasset.assets.searchAllIamPolicies haben.

gcloud asset search-all-iam-policies \
--scope=projects/PROJECT_NAME \
--query='roles=roles/spanner.fineGrainedAccessUser AND resource=//spanner.googleapis.com/projects/PROJECT_NAME/instances/INSTANCE_NAME/databases/DATABASE_NAME' \
--flatten=policy.bindings[].members[] \
--format='table(policy.bindings.members)'

Die Ausgabe sieht etwa so aus:

MEMBERS
user:[e-mail]
user:[e-mail]
serviceAccount:[e-mail]
serviceAccount:[e-mail]

Weitere Informationen finden Sie unter API im Google Cloud-Projekt aktivieren.

IAM-Hauptkonten mit Zugriff auf eine Datenbankrolle ansehen

Führen Sie den folgenden Befehl aus, um eine Liste der Hauptkonten aufzurufen, denen Zugriff auf eine bestimmte Datenbankrolle gewährt wurde. Zum Ausführen des Befehls müssen Sie die Cloud Asset API in Ihrem Projekt aktiviert und die IAM-Berechtigung cloudasset.assets.searchAllIamPolicies haben.

gcloud asset search-all-iam-policies \
--scope=projects/PROJECT_NAME \
--query='roles=roles/spanner.databaseRoleUser AND policy:"resource.name" AND policy:/ROLE_NAME AND resource=//spanner.googleapis.com/projects/PROJECT_NAME/instances/INSTANCE_NAME/databases/DATABASE_NAME' \
--flatten=policy.bindings[].members[] \
--format='table(policy.bindings.members)'

Die Ausgabe sieht etwa so aus:

MEMBERS
[e-mail]

IAM-Bedingungen für ein Hauptkonto ansehen

Führen Sie den folgenden Befehl aus, um eine Liste der IAM-Bedingungen aufzurufen, die beim Zuweisen der Rolle Nutzer einer Cloud Spanner-Datenbankrolle angegeben wurden:

gcloud asset search-all-iam-policies \
--scope=projects/PROJECT_NAME \
--query='roles=roles/spanner.databaseRoleUser AND policy:resource.name AND policy:"PRINCIPAL_IDENTIFIER" AND resource=//spanner.googleapis.com/projects/PROJECT_NAME/instances/INSTANCE_NAME/databases/DATABASE_NAME' \
--flatten=policy.bindings[] \
--format='table(policy.bindings.condition.expression)'

Dabei ist PRINCIPAL_IDENTIFIER:

  { user:user-account-name | serviceAccount:service-account-name }

Beispiele für PRINCIPAL_IDENTIFIER:

user:[e-mail]
serviceAccount:[e-mail]

Die folgende Beispielausgabe zeigt zwei Bedingungsausdrücke.

EXPRESSION
resource.type == "spanner.googleapis.com/DatabaseRole" &&
resource.name.endsWith("/hr_analyst")
resource.type == "spanner.googleapis.com/DatabaseRole" &&
resource.name.endsWith("/hr_manager")

IAM-Richtlinien auf fehlende Bedingungen für Datenbankrollen prüfen

Nachdem Sie Hauptkonten Zugriff auf Datenbankrollen gewährt haben, sollten Sie dafür sorgen, dass für jede IAM-Bindung eine Bedingung angegeben ist.

Führen Sie dazu den folgenden Befehl aus:

gcloud asset search-all-iam-policies \
--scope=projects/PROJECT_NAME \
--query='roles:roles/spanner.databaseRoleUser AND resource=//spanner.googleapis.com/projects/PROJECT_NAME/instances/INSTANCE_NAME/databases/DATABASE_NAME'
--flatten=policy.bindings[].members[]

Die Ausgabe sieht in etwa so aus:

ROLE                              MEMBERS                         EXPRESSION
roles/spanner.databaseRoleUser    serviceAccount:cs-fgac-sa-1@...
roles/spanner.databaseRoleUser    serviceAccount:cs-fgac-sa-2@... resource.type == "spanner…"

Beachten Sie, dass im ersten Ergebnis eine Bedingung fehlt. Die Hauptkonten in dieser Bindung haben daher Zugriff auf alle Datenbankrollen.

Datenbankrolle löschen

Wenn Sie eine Datenbankrolle löschen, wird die Mitgliedschaft in anderen Rollen automatisch aufgehoben und die Rolle der Rolle in anderen Rollen widerrufen.

So löschen Sie eine Datenbankrolle:

1. Widerrufen Sie alle detaillierten Berechtigungen zur Zugriffssteuerung für die Rolle.
2. Entfernen Sie alle IAM-Richtlinienbindungen, die auf diese Rolle verweisen, sodass eine später erstellte Datenbankrolle mit demselben Namen diese Bindungen nicht übernimmt.

Console

So löschen Sie eine Datenbankrolle:

1. Klicken Sie auf der Seite Übersicht der Datenbank auf DDL schreiben.

2. Wenn Sie Berechtigungen aus der Rolle widerrufen möchten, geben Sie eine REVOKE-Anweisung ein.

   Informationen zur Syntax der Anweisung REVOKE finden Sie unter Google SQL-Datendefinitionssprache. Weitere Informationen zu Berechtigungen finden Sie unter Detaillierte Zugriffssteuerung.

   Wenn Sie beispielsweise SELECT, INSERT und UPDATE für die Tabellen employees und contractors aus der Datenbankrolle hr_manager widerrufen möchten, geben Sie die folgende Anweisung ein:

   REVOKE SELECT, INSERT, UPDATE ON TABLE employees, contractors FROM ROLE hr_manager;
   

   Sie können eine DDL-Vorlage für die REVOKE-Anweisung verwenden. Wählen Sie im Drop-down-Menü DDL-VORLAGEN die Option Datenbankrollen und dann unter Rollenberechtigungen widerrufen eine Vorlage aus.

3. Löschen Sie alle IAM-Bedingungen, die mit der Rolle verknüpft sind.

   1. Suchen Sie in der Liste der Rollen im Infofeld die Rolle Nutzer von Cloud Spanner-Datenbankrollen, neben der der Bedingungstitel angezeigt wird, und maximieren Sie dann die Rolle, um die Hauptkonten mit Zugriff auf die Rolle anzusehen.

   2. Klicken Sie für eines der Hauptkonten auf das Symbol Hauptkonto bearbeiten (Stift).

   3. Klicken Sie auf der Seite Bearbeitungszugriff neben der Cloud Spanner-Rolle für Datenbankrollen auf das Symbol Rolle löschen (Papierkorbsymbol).

   4. Klicken Sie auf Speichern.

   5. Wiederholen Sie die vorherigen drei Schritte für andere Hauptkonten, die unter der Bedingung aufgeführt sind.

4. Rufen Sie die Seite Write DDL auf und geben Sie die folgende Anweisung ein, um die Rolle zu löschen:

   DROP ROLE ROLE_NAME;
   

5. Klicken Sie auf Senden.

gcloud

1. Wenn Sie alle Berechtigungen für eine Rolle widerrufen und dann die Rolle löschen möchten, verwenden Sie den Befehl gcloud spanner databases ddl update:

   gcloud spanner databases ddl update DATABASE_NAME \
   --instance=INSTANCE_NAME \
   --ddl='REVOKE PERMISSIONS ON TABLE TABLE_NAME FROM ROLE ROLE_NAME; DROP ROLE ROLE_NAME;'
   

   Gültige Werte für PERMISSIONS sind SELECT, INSERT, UPDATE und DELETE.

2. Verwenden Sie den Befehl gcloud spanner databases remove-iam-policy-binding so, um zugehörige IAM-Bedingungen zu löschen:

   gcloud spanner databases remove-iam-policy-binding DATABASE_NAME \
   --instance=INSTANCE_NAME \
   --role=ROLE_NAME \
   --member=MEMBER_NAME \
   --condition=CONDITION
   

   • MEMBER_NAME ist die Kennung für das Hauptkonto. Er muss das Format user|group|serviceAccount:email oder domain:domain haben.

   • CONDITION ist ein IAM-Bedingungsausdruck, der die Rollen angibt, die dem Hauptkonto gewährt werden sollen.

     CONDITION hat das folgende Format:

     --condition='expression=(resource.type == "spanner.googleapis.com/DatabaseRole" && (resource.name.endsWith("/ROLE1") || resource.name.endsWith("/ROLE2"))),title=TITLE,description=DESCRIPTION'
     

     Die gesamte Bedingungsspezifikation muss genau mit der Bedingungsspezifikation übereinstimmen, die im Befehl verwendet wurde, der die Berechtigung erteilt hat, einschließlich Titel und Beschreibung.

Clientbibliotheken

In diesen Codebeispielen wird eine Datenbankrolle erstellt und gelöscht.

C++

Auf GitHub ansehen Feedback

void AddAndDropDatabaseRole(
    google::cloud::spanner_admin::DatabaseAdminClient client,
    std::string const& project_id, std::string const& instance_id,
    std::string const& database_id, std::string const& role_parent,
    std::string const& role_child) {
  google::cloud::spanner::Database database(project_id, instance_id,
                                            database_id);
  std::vector<std::string> grant_statements = {
      "CREATE ROLE " + role_parent,
      "GRANT SELECT ON TABLE Singers TO ROLE " + role_parent,
      "CREATE ROLE " + role_child,
      "GRANT ROLE " + role_parent + " TO ROLE " + role_child,
  };
  auto metadata =
      client.UpdateDatabaseDdl(database.FullName(), grant_statements).get();
  google::cloud::spanner_testing::LogUpdateDatabaseDdl(  //! TODO(#4758)
      client, database, metadata.status());              //! TODO(#4758)
  if (!metadata) throw std::move(metadata).status();
  std::cout << "Created roles " << role_parent << " and " << role_child
            << " and granted privileges\n";

  std::vector<std::string> revoke_statements = {
      "REVOKE ROLE " + role_parent + " FROM ROLE " + role_child,
      "DROP ROLE " + role_child,
  };
  metadata =
      client.UpdateDatabaseDdl(database.FullName(), revoke_statements).get();
  google::cloud::spanner_testing::LogUpdateDatabaseDdl(  //! TODO(#4758)
      client, database, metadata.status());              //! TODO(#4758)
  if (!metadata) throw std::move(metadata).status();
  std::cout << "Revoked privileges and dropped role " << role_child << "\n";
}

C#

Auf GitHub ansehen Feedback

using Google.Cloud.Spanner.Data;
using System.Threading.Tasks;

public class AddAndDropDatabaseRoleAsyncSample
{
    public async Task AddDatabaseRoleAsync(string projectId, string instanceId, string databaseId, string databaseRole)
    {
        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";
        string createRoleStatement = $"CREATE ROLE {databaseRole}";

        // Creates the given database role.
        using var connection = new SpannerConnection(connectionString);
        using var updateCmd = connection.CreateDdlCommand(createRoleStatement);
        await updateCmd.ExecuteNonQueryAsync();
    }

    public async Task DropDatabaseRoleAsync(string projectId, string instanceId, string databaseId, string databaseRole)
    {
        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";
        string deleteRoleStatement = $"DROP ROLE {databaseRole}";

        // Drops the given database role.
        using var connection = new SpannerConnection(connectionString);
        using var updateCmd = connection.CreateDdlCommand(deleteRoleStatement);
        await updateCmd.ExecuteNonQueryAsync();
    }
}

Einfach loslegen (Go)

Auf GitHub ansehen Feedback

import (
	"context"
	"io"

	database "cloud.google.com/go/spanner/admin/database/apiv1"
	adminpb "google.golang.org/genproto/googleapis/spanner/admin/database/v1"
)

func addAndDropDatabaseRole(w io.Writer, db string) error {
	ctx := context.Background()
	adminClient, err := database.NewDatabaseAdminClient(ctx)
	if err != nil {
		return err
	}
	defer adminClient.Close()

	// Set up database roles and membership. After database roles are created,
	// users can be granted roles by setting IAM policies.
	op, err := adminClient.UpdateDatabaseDdl(ctx, &adminpb.UpdateDatabaseDdlRequest{
		Database: db,
		Statements: []string{
			"CREATE ROLE parent",
			"GRANT SELECT ON TABLE Albums TO ROLE parent",
			"CREATE ROLE child",
			"GRANT ROLE parent TO ROLE child",
		},
	})
	if err != nil {
		return err
	}
	if err := op.Wait(ctx); err != nil {
		return err
	}

	// Delete role and membership.
	op, err = adminClient.UpdateDatabaseDdl(ctx, &adminpb.UpdateDatabaseDdlRequest{
		Database: db,
		Statements: []string{
			"REVOKE ROLE parent FROM ROLE child",
			"DROP ROLE child",
		},
	})
	if err != nil {
		return err
	}
	if err := op.Wait(ctx); err != nil {
		return err
	}
	return nil
}

Java

Auf GitHub ansehen Feedback

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.spanner.DatabaseAdminClient;
import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerOptions;
import com.google.common.collect.ImmutableList;
import com.google.spanner.admin.database.v1.UpdateDatabaseDdlMetadata;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class AddAndDropDatabaseRole {

  static void addAndDropDatabaseRole() {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    String databaseId = "my-database";
    String parentRole = "my-new-parent-role";
    String childRole = "my-new-child-role";
    addAndDropDatabaseRole(projectId, instanceId, databaseId, parentRole, childRole);
  }

  static void addAndDropDatabaseRole(
      String projectId, String instanceId, String databaseId, String parentRole, String childRole) {
    try (Spanner spanner =
                 SpannerOptions.newBuilder()
                         .setProjectId(projectId)
                         .build()
                         .getService())  {
      final DatabaseAdminClient adminClient = spanner.getDatabaseAdminClient();
      OperationFuture<Void, UpdateDatabaseDdlMetadata> operation =
          adminClient.updateDatabaseDdl(
              instanceId,
              databaseId,
              ImmutableList.of(
                  "CREATE ROLE " + parentRole,
                  "GRANT SELECT ON TABLE Albums TO ROLE " + parentRole,
                  "CREATE ROLE " + childRole,
                  "GRANT ROLE " + parentRole + " TO ROLE " + childRole),
              null);
      try {
        System.out.println("Waiting for role create operation to complete...");
        operation.get(5, TimeUnit.MINUTES);
        System.out.printf(
            "Created roles %s and %s and granted privileges%n", parentRole, childRole);
        // Delete role and membership.
        operation =
            adminClient.updateDatabaseDdl(
                instanceId,
                databaseId,
                ImmutableList.of(
                    "REVOKE ROLE " + parentRole + " FROM ROLE " + childRole,
                    "DROP ROLE " + childRole),
                null);
        System.out.println("Waiting for role revoke & drop operation to complete...");
        operation.get(5, TimeUnit.MINUTES);
        System.out.printf("Revoked privileges and dropped role %s%n", childRole);
      } catch (ExecutionException | TimeoutException e) {
        System.out.printf(
            "Error: AddAndDropDatabaseRole failed with error message %s\n", e.getMessage());
        e.printStackTrace();
      } catch (InterruptedException e) {
        System.out.println(
            "Error: Waiting for AddAndDropDatabaseRole operation to finish was interrupted");
      }
    }
  }
}

Node.js

Auf GitHub ansehen Feedback

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const instanceId = 'my-instance';
// const databaseId = 'my-database';
// const projectId = 'my-project-id';
// Imports the Google Cloud Spanner client library
const {Spanner} = require('@google-cloud/spanner');

// Instantiates a client
const spanner = new Spanner({
  projectId: projectId,
});

async function addAndDropNewDatabaseRole() {
  // Gets a reference to a Cloud Spanner instance and database.
  const instance = spanner.instance(instanceId);
  const database = instance.database(databaseId);

  // Creates a new user defined role and grant permissions
  try {
    const request = [
      'CREATE ROLE parent',
      'GRANT SELECT ON TABLE Singers TO ROLE parent',
      'CREATE ROLE child',
      'GRANT ROLE parent TO ROLE child',
    ];
    const [operation] = await database.updateSchema(request);

    console.log('Waiting for operation to complete...');
    await operation.promise();

    console.log('Created roles child and parent and granted privileges');
  } catch (err) {
    console.error('ERROR:', err);
  }

  // Revoke permissions and drop child role.
  // A role can't be dropped until all its permissions are revoked.
  try {
    const request = ['REVOKE ROLE parent FROM ROLE child', 'DROP ROLE child'];
    const [operation] = await database.updateSchema(request);

    console.log('Waiting for operation to complete...');
    await operation.promise();

    console.log('Revoked privileges and dropped role child');
  } catch (err) {
    console.error('ERROR:', err);
  } finally {
    // Close the database when finished.
    await database.close();
  }
}
addAndDropNewDatabaseRole();

PHP

Auf GitHub ansehen Feedback

use Google\Cloud\Spanner\SpannerClient;

/**
 * Adds and drops roles to the Singers table in the example database.
 * Example:
 * ```
 * add_drop_database_role($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function add_drop_database_role(string $instanceId, string $databaseId): void
{
    $spanner = new SpannerClient();
    $instance = $spanner->instance($instanceId);
    $database = $instance->database($databaseId);

    $roleParent = 'new_parent';
    $roleChild = 'new_child';

    $operation = $database->updateDdlBatch([
        sprintf('CREATE ROLE %s', $roleParent),
        sprintf('GRANT SELECT ON TABLE Singers TO ROLE %s', $roleParent),
        sprintf('CREATE ROLE %s', $roleChild),
        sprintf('GRANT ROLE %s TO ROLE %s', $roleParent, $roleChild)
    ]);

    printf('Waiting for create role and grant operation to complete...%s', PHP_EOL);
    $operation->pollUntilComplete();

    printf('Created roles %s and %s and granted privileges%s', $roleParent, $roleChild, PHP_EOL);

    $operation = $database->updateDdlBatch([
        sprintf('REVOKE ROLE %s FROM ROLE %s', $roleParent, $roleChild),
        sprintf('DROP ROLE %s', $roleChild)
    ]);

    printf('Waiting for revoke role and drop role operation to complete...%s', PHP_EOL);
    $operation->pollUntilComplete();

    printf('Revoked privileges and dropped role %s%s', $roleChild, PHP_EOL);
}

Python

Auf GitHub ansehen Feedback

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"
spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)
role_parent = "new_parent"
role_child = "new_child"

operation = database.update_ddl(
    [
        "CREATE ROLE {}".format(role_parent),
        "GRANT SELECT ON TABLE Singers TO ROLE {}".format(role_parent),
        "CREATE ROLE {}".format(role_child),
        "GRANT ROLE {} TO ROLE {}".format(role_parent, role_child),
    ]
)
operation.result(OPERATION_TIMEOUT_SECONDS)
print(
    "Created roles {} and {} and granted privileges".format(role_parent, role_child)
)

operation = database.update_ddl(
    [
        "REVOKE ROLE {} FROM ROLE {}".format(role_parent, role_child),
        "DROP ROLE {}".format(role_child),
    ]
)
operation.result(OPERATION_TIMEOUT_SECONDS)
print("Revoked privileges and dropped role {}".format(role_child))

Ruby

Auf GitHub ansehen Feedback

require "google/cloud/spanner"

def spanner_add_and_drop_database_role project_id:, instance_id:, database_id:
  # project_id  = "Your Google Cloud project ID"
  # instance_id = "Your Spanner instance ID"
  # database_id = "Your Spanner database ID"

  admin_client = Google::Cloud::Spanner::Admin::Database::V1::DatabaseAdmin::Client.new
  role_parent = "new_parent"
  role_child = "new_child"

  db_path = admin_client.database_path project: project_id, instance: instance_id, database: database_id

  job = admin_client.update_database_ddl database: db_path, statements: [
    "CREATE ROLE #{role_parent}",
    "GRANT SELECT ON TABLE Singers TO ROLE #{role_parent}",
    "CREATE ROLE #{role_child}",
    "GRANT ROLE #{role_parent} TO ROLE #{role_child}"
  ]

  job.wait_until_done!
  puts "Created roles #{role_parent} and #{role_child} and granted privileges"

  job = admin_client.update_database_ddl database: db_path, statements: [
    "REVOKE ROLE #{role_parent} FROM ROLE #{role_child}",
    "DROP ROLE #{role_child}"
  ]

  job.wait_until_done!
  puts "Revoked privileges and dropped role #{role_child}"
end

Weitere Informationen

• Detaillierte Zugriffssteuerung
• Detaillierte Zugriffssteuerung für Änderungsstreams
• Detaillierte Berechtigungen für die Zugriffssteuerung
• Google SQL-DDL-Referenz
• Schemaaktualisierungen vornehmen