Berechtigungen verwalten

Auf dieser Seite wird beschrieben, wann und wie Sie Azure Databricks Benutzern und Identitäten Berechtigungen für eine Datenbankinstanz erteilen.

Um anderen Benutzern zu ermöglichen, mit PostgreSQL auf die Datenbankinstanz zuzugreifen, muss der databricks_superuser entsprechende Postgres-Rollen für sie erstellen. Ausführliche Informationen zum Erstellen von Postgres-Rollen finden Sie unter Verwalten von Postgres-Rollen.

Wann und wie Berechtigungen überprüft werden

Wenn Sie eine Postgres-Syntax verwenden oder eine Verbindung über eine PostgreSQL-Schnittstelle herstellen, erzwingt Lakebase PostgreSQL-spezifische Zugriffssteuerungen mithilfe der folgenden:

• Postgres-Rollen
• Rollenmitgliedschaften
• Postgres-gewährte Berechtigungen

In allen anderen Szenarien erzwingt Lakebase Databricks-spezifische Zugriffssteuerungen:

• Azure Databricks-Identitäten (Benutzer, Gruppen und Dienstprinzipale)
• Azure Databricks-Gruppenmitgliedschaften
• Listen zur Zugriffssteuerung für Arbeitsbereiche (Access Control Lists, ACLs)
• Unity-Katalogberechtigungen

Datenbankinstanzberechtigungen

Ein Benutzer muss über bestimmte Berechtigungen für die Datenbankinstanz verfügen, um die Instanz zu verwalten und Tabellenvorgänge aus der Azure Databricks-Benutzeroberfläche, API oder SDK auszuführen. Arbeitsbereichsadministratoren und der Instanzersteller können allen gewünschten Benutzern, Gruppen oder Dienstprinzipalen auf der Übersichtsseite der Datenbankinstanzen zusätzliche Berechtigungen zuweisen.

1. Klicken Sie auf " Berechnen" in der Arbeitsbereich-Randleiste.
2. Klicken Sie auf OLTP-Datenbank.
3. Klicken Sie auf die Registerkarte Berechtigungen.
4. Klicken Sie oben rechts auf "Instanzberechtigungen verwalten ".
5. Geben Sie einen Benutzer, eine Gruppe oder einen Dienstprinzipal ein, um zusätzliche Berechtigungen zu erteilen.
6. Wählen Sie die Berechtigung aus, die der Identität gewährt werden soll. Siehe Datenbankinstanz-ACLs.
7. Klicken Sie auf +Hinzufügen.
8. Jeder Arbeitsbereichsbenutzer kann Datenbankinstanzen anzeigen oder auflisten. Datenbankkatalog- und synchronisierte Tabellenberechtigungen werden zusätzlich durch die Berechtigungen des Unity Catalog Metastores, des Katalogs, des Schemas und der Tabellen geregelt. Weitere Informationen finden Sie unter Verwalten von Berechtigungen im Unity-Katalog.
9. Klicken Sie auf "Speichern".

Postgres-Berechtigungen

Um aus einer Tabelle in Postgres zu lesen oder in eine Tabelle zu schreiben, benötigen Benutzer die folgenden Berechtigungen in Postgres:

• CONNECT in der Datenbank
• USAGE auf dem Schema (oder CREATE zum Erstellen neuer Tabellen)
• SELECT, INSERT, UPDATEoder DELETE auf der Tabelle

Eine vollständige Liste der Postgres-Berechtigungen finden Sie in der Dokumentation zu PostgreSQL.

Überprüfen von Benutzerberechtigungen für eine bestimmte Tabelle in Postgres

Führen Sie die folgende SQL-Anweisung aus, um eine Funktion pg_temp.check_permissions zu erstellen, die die Berechtigungen eines Benutzers überprüft, einschließlich geerbter Berechtigungen.

CREATE OR REPLACE FUNCTION pg_temp.check_permissions(TEXT, TEXT, TEXT, TEXT)
RETURNS TABLE(database_connect BOOLEAN, schema_usage BOOLEAN, table_select BOOLEAN,
              table_insert BOOLEAN, table_update BOOLEAN, table_delete BOOLEAN) AS $$
SELECT
  has_database_privilege($1, $2, 'CONNECT'),
  has_schema_privilege($1, $3, 'USAGE'),
  has_table_privilege($1, $4, 'SELECT'),
  has_table_privilege($1, $4, 'INSERT'),
  has_table_privilege($1, $4, 'UPDATE'),
  has_table_privilege($1, $4, 'DELETE')
$$ LANGUAGE sql
;

Verwenden Sie die folgende Abfrage, um die Funktion zu verwenden:

SELECT * FROM pg_temp.check_permissions('<your_user>', '<your_database>', '<your_schema>', '<your_table>');

-- Example:
SELECT * FROM pg_temp.check_permissions('joe@acme.org', 'databricks_postgres', 'public', 'table1');

Alle Berechtigungen für Datenbank, Schema und Tabelle in Postgres anzeigen

Die folgende SQL-Anweisung erstellt eine Funktion mit dem Namen pg_temp.make_owner_acl , die eine detaillierte Ansicht aller erteilten Berechtigungen zurückgibt, mit Ausnahme geerbter Berechtigungen für alle Benutzer:

CREATE OR REPLACE FUNCTION pg_temp.make_owner_acl(owner_oid OID)
RETURNS TABLE(grantor OID, grantee OID, privilege_type TEXT, is_grantable BOOLEAN) AS $$
SELECT owner_oid, owner_oid,'OWNER'::TEXT, True
$$ LANGUAGE SQL;

CREATE OR REPLACE FUNCTION pg_temp.get_all_permissions(TEXT, TEXT, TEXT)
RETURNS TABLE(type TEXT, name TEXT, role TEXT, acl TEXT, can_grant TEXT) AS $$
SELECT type, name,
  CASE WHEN grantee = 0 THEN 'PUBLIC' ELSE pg_get_userbyid(grantee) END AS role, privilege_type,
  CASE WHEN privilege_type = 'OWNER' THEN 'YES, ALL' WHEN is_grantable THEN 'YES' ELSE 'NO' END AS can_grant
FROM (
  SELECT 'DATABASE' type, datname as name, (pg_temp.make_owner_acl(datdba)).*
    FROM pg_database
    WHERE datname = $1
  UNION ALL
  SELECT 'DATABASE' type, datname as name, (aclexplode(datacl)).*
    FROM pg_database
    WHERE datname = $1
  UNION ALL
  SELECT 'SCHEMA' type, nspname as name, (pg_temp.make_owner_acl(nspowner)).*
    FROM pg_namespace
    WHERE nspname = $2
  UNION ALL
  SELECT 'SCHEMA' type, nspname as name, (aclexplode(nspacl)).*
    FROM pg_namespace
    WHERE nspname = $2
  UNION ALL
  SELECT 'TABLE' type, relname as name, (pg_temp.make_owner_acl(relowner)).*
    FROM pg_class
    WHERE relname = $3
  UNION ALL
  SELECT 'TABLE' type, relname as name, (aclexplode(relacl)).*
    FROM pg_class
    WHERE relname = $3
  )
$$ LANGUAGE SQL
;

Verwenden Sie die folgende Abfrage, um die Funktion zu verwenden:

SELECT * FROM pg_temp.get_all_permissions('<your_database>', '<your_schema>', '<your_table>');

-- Example:
SELECT * FROM pg_temp.get_all_permissions('databricks_postgres', 'public', 'table1');

Überprüfen der Rollenvererbungshierarchie in Postgres

In Postgres kann eine Rolle Mitglied einer anderen Rolle sein, und die Mitgliedschaft gibt an, ob die Berechtigungen von der übergeordneten Rolle geerbt werden. Um alle Rollen anzuzeigen, zu denen eine bestimmte Rolle gehört, verwenden Sie die folgende SQL-Anweisung, um die SQL-Funktion pg_temp.get_inherited_roleszu erstellen:

CREATE OR REPLACE FUNCTION pg_temp.get_inherited_roles(
  role_name TEXT
)
RETURNS TABLE(inherited_roles TEXT, member_via TEXT, inherits_permissions TEXT) AS $$
  WITH RECURSIVE role_tree AS (
    SELECT
        m.roleid,
        pg_get_userbyid(m.roleid) rolname,
         'DIRECT' COLLATE "C" as member_via,
        m.inherit_option as inherits_permissions
    FROM pg_auth_members m
    WHERE m.member = (SELECT oid FROM pg_roles WHERE rolname = $1)
    UNION ALL
    SELECT
        m.roleid,
        pg_get_userbyid(m.roleid) rolname,
        rt.rolname::text as member_via,
        (rt.inherits_permissions AND m.inherit_option) as inherits_permissions
    FROM pg_auth_members m
    JOIN role_tree rt ON m.member = rt.roleid
  )
  SELECT
      rolname AS inherited_roles,
      member_via,
      CASE WHEN inherits_permissions THEN 'YES' ELSE 'NO' END as inherits_permissions
  FROM role_tree
  GROUP BY inherited_roles, member_via, inherits_permissions
  ORDER BY inherits_permissions DESC
$$ LANGUAGE sql
;

Um die Funktion zu verwenden, ersetzen Sie einen Azure Databricks-Benutzernamen für <your_user>:

SELECT * FROM pg_temp.get_inherited_roles('<your role>');

Suchen von Rollenadministratoren in Postgres

Um den Administrator einer Rolle anzuzeigen, verwenden Sie die folgende SQL-Abfrage, und ersetzen Sie den Rollennamen durch <target_role>:

SELECT pg_get_userbyid(m.member) admin
FROM pg_auth_members m
WHERE m.roleid = (SELECT oid FROM pg_roles WHERE rolname = '<target_role>')
  AND m.admin_option = true;