Erstellen von Postgres-Rollen

Wenn Sie ein Projekt erstellen, erstellt Lakebase mehrere Postgres-Rollen im Projekt:

• Eine Postgres-Rolle für die Azure Databricks-Identität des Projektbesitzers (z. B user@databricks.com. ), die die Standarddatenbank databricks_postgres besitzt
• Eine databricks_superuser administrative Rolle

Beide Rollen sind auf der Registerkarte "Rollen und Datenbanken " sichtbar, wenn Sie ihr Projekt zum ersten Mal öffnen.

Die databricks_postgres Datenbank wird erstellt, damit Sie direkt nach der Projekterstellung eine Verbindung herstellen und Lakebase ausprobieren können.

Es werden auch mehrere vom System verwaltete Rollen erstellt. Hierbei handelt es sich um interne Rollen, die von Azure Databricks-Diensten für Verwaltung, Überwachung und Datenvorgänge verwendet werden.

Siehe vorab erstellte Rollen und Systemrollen.

Erstellen von Postgres-Rollen

Lakebase unterstützt zwei Typen von Postgres-Rollen für den Datenbankzugriff:

• OAuth-Rollen für Azure Databricks-Identitäten: Erstellen Sie diese mithilfe der Lakebase-UI, der databricks_auth Erweiterung mit SQL oder der Python SDK und REST-API. Ermöglicht Azure Databricks-Identitäten (Benutzer, Dienstprinzipale und Gruppen) die Verbindung mit OAuth-Token.
• Native Postgres-Kennwortrollen: Erstellen Sie diese mithilfe der Lakebase-UI, SQL oder der Python SDK- und REST-API. Verwenden Sie einen beliebigen gültigen Rollennamen mit Kennwortauthentifizierung.

Anleitungen zum Auswählen des zu verwendenden Rollentyps finden Sie unter Authentifizierungsübersicht. Jedes ist für unterschiedliche Anwendungsfälle ausgelegt.

Erstellen einer OAuth-Rolle für Azure Databricks-Identitäten

Um Azure Databricks-Identitäten (Benutzer, Dienstprinzipale oder Gruppen) die Verbindung mit OAuth-Token zu ermöglichen, erstellen Sie eine OAuth-Rolle mithilfe der Lakebase-Benutzeroberfläche, der databricks_auth Erweiterung mit SQL oder der REST-API.

Ausführliche Anweisungen zum Abrufen von OAuth-Token finden Sie unter Abrufen eines OAuth-Tokens in einem Benutzer-zu-Computer-Fluss und Abrufen eines OAuth-Tokens in einem Computer-zu-Computer-Fluss.

Benutzeroberfläche

1. Wählen Sie auf der Registerkarte "Rollen und Datenbanken">Rolle hinzufügen>"OAuth" den Benutzer, den Dienstprinzipal oder die Gruppe aus, denen Datenbankzugriff gewährt werden soll.
2. Gewähren Sie nach dem Erstellen der Rolle geeignete Datenbankberechtigungen. Erfahren Sie, wie: Verwalten von Berechtigungen

SQL

Voraussetzungen:

• Sie müssen über CREATE- und CREATE ROLE-Berechtigungen für die Datenbank verfügen.
• Sie müssen als Azure Databricks-Identität mit einem gültigen OAuth-Token authentifiziert werden.
• Authentifizierte Native Postgres-Sitzungen können keine OAuth-Rollen erstellen.

1. Erstellen Sie die databricks_auth Erweiterung. Jede Postgres-Datenbank muss über eine eigene Erweiterung verfügen.

   CREATE EXTENSION IF NOT EXISTS databricks_auth;
   

2. Verwenden Sie die databricks_create_role Funktion, um eine Postgres-Rolle für die Azure Databricks-Identität zu erstellen:

   SELECT databricks_create_role('identity_name', 'identity_type');
   

   Für einen Azure Databricks-Benutzer:

   SELECT databricks_create_role('myuser@databricks.com', 'USER');
   

   Für einen Azure Databricks-Dienstprinzipal:

   SELECT databricks_create_role('8c01cfb1-62c9-4a09-88a8-e195f4b01b08', 'SERVICE_PRINCIPAL');
   

   Für eine Azure Databricks-Gruppe:

   SELECT databricks_create_role('My Group Name', 'GROUP');
   

   Bei dem Gruppennamen wird die Groß-/Kleinschreibung beachtet und muss genau so übereinstimmen, wie er in Ihrem Azure Databricks-Arbeitsbereich angezeigt wird. Wenn Sie eine Postgres-Rolle für eine Gruppe erstellen, kann jedes direkte oder indirekte Mitglied (Benutzer oder Dienstprinzipal) dieser Databricks-Gruppe sich bei Postgres als Gruppenrolle mit ihrem individuellen OAuth-Token authentifizieren. Auf diese Weise können Sie Berechtigungen auf Gruppenebene in Postgres verwalten, anstatt Berechtigungen für einzelne Benutzer zu verwalten.

3. Gewähren von Datenbankberechtigungen für die neu erstellte Rolle.

Die databricks_create_role() Funktion erstellt nur eine Postgres-Rolle mit LOGIN Berechtigungen. Nachdem Sie die Rolle erstellt haben, müssen Sie den entsprechenden Datenbankrechte und Zugriffsberechtigungen für die spezifischen Datenbanken, Schemata oder Tabellen erteilen, auf die der Benutzer zugreifen muss. Erfahren Sie, wie: Verwalten von Berechtigungen

Python SDK

Setzen Sie identity_type auf USER, SERVICE_PRINCIPAL oder GROUP. Setzen Sie postgres_role jeweils als E-Mail-Adresse der Identität, Anwendungs-ID (UUID) oder Anzeigenamen der Gruppe fest. Dieser Wert wird zum Namen der Postgres-Rolle und ist das, was Sie in Verbindungszeichenfolgen und GRANT -anweisungen verwenden.

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Role, RoleRoleSpec

w = WorkspaceClient()

operation = w.postgres.create_role(
    parent="projects/my-project/branches/production",
    role=Role(
        spec=RoleRoleSpec(
            identity_type="USER",
            postgres_role="user@example.com"
        )
    )
)
role = operation.wait()
print(f"Created role: {role.name}")

Gewähren Sie nach dem Erstellen der Rolle geeignete Datenbankberechtigungen. Erfahren Sie, wie: Verwalten von Berechtigungen

cURL

Stellen Sie identity_type auf USER, SERVICE_PRINCIPAL oder GROUP. Setzen Sie postgres_role jeweils auf die E-Mail-Adresse des Kontos, die Anwendungs-ID (UUID) oder den Anzeigenamen der Gruppe. Dieser Wert wird zum Namen der Postgres-Rolle und ist das, was Sie in Verbindungszeichenfolgen und GRANT -anweisungen verwenden.

curl -X POST "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/roles" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "spec": {
      "identity_type": "USER",
      "postgres_role": "user@example.com"
    }
  }' | jq

Der Endpunkt liefert einen lang andauernden Vorgang zurück. Überprüfen Sie wiederholt, bis donetrue ist, und verwenden Sie dann das name-Feld der Rolle für nachfolgende API-Aufrufe. Siehe Lang andauernde Vorgänge.

Gewähren Sie nach dem Erstellen der Rolle geeignete Datenbankberechtigungen. Erfahren Sie, wie: Verwalten von Berechtigungen

Gruppenbasierte Authentifizierung

Wenn Sie eine Postgres-Rolle für eine Azure Databricks-Gruppe erstellen, aktivieren Sie die gruppenbasierte Authentifizierung. Auf diese Weise kann jedes Mitglied der Azure Databricks-Gruppe sich mithilfe der Rolle der Gruppe bei Postgres authentifizieren, wodurch die Berechtigungsverwaltung vereinfacht wird.

Funktionsweise:

1. Erstellen Sie eine Postgres-Rolle für eine Databricks-Gruppe.
2. Gewähren von Datenbankberechtigungen für die Gruppenrolle in Postgres. Siehe "Berechtigungen verwalten".
3. Jedes direkte oder indirekte Mitglied (Benutzer oder Dienstprinzipal) der Databricks-Gruppe kann eine Verbindung mit Postgres über sein einzelnes OAuth-Token herstellen.
4. Beim Herstellen einer Verbindung verifiziert sich das Mitglied als Gruppenrolle und übernimmt alle Berechtigungen, die dieser Rolle gewährt werden.

Authentifizierungsfluss:

Wenn ein Gruppenmitglied eine Verbindung herstellt, geben sie den Rollennamen der Gruppe als Benutzernamen und ihr eigenes OAuth-Token als Kennwort an:

export PGPASSWORD='<OAuth token of a group member>'
export GROUP_ROLE_NAME='<pg-case-sensitive-group-role-name>'

psql -h $HOSTNAME -p 5432 -d databricks_postgres -U $GROUP_ROLE_NAME

Wichtige Überlegungen:

• Überprüfung der Gruppenmitgliedschaft: Die Gruppenmitgliedschaft wird nur zur Authentifizierung überprüft. Wenn ein Mitglied nach dem Herstellen einer Verbindung aus der Azure Databricks-Gruppe entfernt wird, bleibt die Verbindung aktiv. Neue Verbindungsversuche von entfernten Mitgliedern werden abgelehnt.
• Arbeitsbereichsbereich: Nur Gruppen, die demselben Azure Databricks-Arbeitsbereich zugewiesen sind wie das Projekt, werden für die gruppenbasierte Authentifizierung unterstützt. Informationen zum Zuweisen von Gruppen zu einem Arbeitsbereich finden Sie unter "Verwalten von Gruppen".
• Groß-/Kleinschreibung: Der verwendete databricks_create_role() Gruppenname muss dem Gruppennamen genau entsprechen, wie er in Ihrem Azure Databricks-Arbeitsbereich angezeigt wird, einschließlich Groß-/Kleinschreibung.
• Berechtigungsverwaltung: Das Verwalten von Berechtigungen auf Gruppenebene in Postgres ist effizienter als das Verwalten einzelner Benutzerberechtigungen. Wenn Sie berechtigungen für die Gruppenrolle erteilen, erben alle aktuellen und zukünftigen Gruppenmitglieder diese Berechtigungen automatisch.
• Identitätsumbenennung: Wenn sich die E-Mail- oder Gruppenanzeigenamen eines Benutzers in Azure Databricks ändern, werden Authentifizierung und bestehende Datenbankberechtigungen beeinträchtigt. Entfernen Sie die alte Rolle, erstellen Sie eine neue mit dem aktualisierten Namen, und aktualisieren Sie die Verbindungszeichenfolgen und Berechtigungen.

Erstellen einer nativen Postgres-Kennwortrolle

Kennwortverbindungen können auf Projekt- oder Computeebene deaktiviert werden. Siehe "Kennwortverbindungen blockieren".

Benutzeroberfläche

1. Geben Sie auf der Registerkarte "Rollen und Datenbanken>Rolle hinzufügen>Passwort" einen Rollennamen ein und gewähren Sie optional databricks_superuser oder Systemattribute CREATEDB, CREATEROLE, BYPASSRLS.
2. Kopieren Sie das generierte Kennwort, und stellen Sie es sicher für den Benutzer bereit. Es wird nicht mehr angezeigt.

SQL

CREATE ROLE role_name WITH LOGIN PASSWORD 'your_secure_password';

Das Kennwort sollte mindestens 12 Zeichen mit einer Kombination aus Kleinbuchstaben, Großbuchstaben, Zahlen und Symbolzeichen enthalten. Benutzerdefinierte Kennwörter werden zur Erstellungszeit überprüft, um die 60-Bit-Entropie sicherzustellen.

Python SDK

identity_type weglassen, um eine Passwort-Rolle zu erstellen. Die API gibt ein generiertes Kennwort in der Antwort zurück.

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.postgres import Role, RoleRoleSpec

w = WorkspaceClient()

operation = w.postgres.create_role(
    parent="projects/my-project/branches/production",
    role=Role(
        spec=RoleRoleSpec(
            postgres_role="my-app-role"
        )
    )
)
role = operation.wait()
print(f"Created role: {role.name}")

cURL

identity_type weglassen, um eine Kennwortrolle zu erstellen. Der Endpunkt gibt eine lang andauernde Operation zurück. Prüfen, bis done zu true wird.

curl -X POST "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/roles" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "spec": {
      "postgres_role": "my-app-role"
    }
  }' | jq

Anzeigen von Postgres-Rollen

Benutzeroberfläche

Um alle Postgres-Rollen in Ihrem Projekt anzuzeigen, navigieren Sie in der Lakebase-App zur Registerkarte Ihrer Branch "Rollen und Datenbanken". Alle in der Zweigstelle erstellten Rollen mit Ausnahme von Systemrollen werden aufgelistet. Die Spalte " Authentifizierungstyp " gibt an, ob jede Rolle OAuth- oder Kennwortauthentifizierung verwendet.

PostgreSQL

Alle Rollen mit \du Befehl anzeigen:

Sie können alle Postgres-Rollen, einschließlich Systemrollen, mithilfe des \du Metabefehls von jedem Postgres-Client (z psql. B. ) oder dem Lakebase SQL-Editor anzeigen:

\du
                                      List of roles
          Role name          |                         Attributes
-----------------------------+------------------------------------------------------------
 cloud_admin                 | Superuser, Create role, Create DB, Replication, Bypass RLS
 my.user@databricks.com      | Create role, Create DB, Bypass RLS
 databricks_control_plane    | Superuser
 databricks_gateway          |
 databricks_monitor          |
 databricks_reader_12345     | Create role, Create DB, Replication, Bypass RLS
 databricks_replicator       | Replication
 databricks_superuser        | Create role, Create DB, Cannot login, Bypass RLS
 databricks_writer_12345     | Create role, Create DB, Replication, Bypass RLS

Python SDK

Alle Rollen auflisten:

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

roles = w.postgres.list_roles(parent="projects/my-project/branches/production")
for role in roles:
    print(f"{role.status.postgres_role} ({role.status.identity_type or 'PASSWORD'}): {role.name}")

Erhalten Sie eine bestimmte Rolle:

role = w.postgres.get_role(
    name="projects/my-project/branches/production/roles/rol-xxxx-xxxxxxxxxx"
)
print(role)

cURL

Alle Rollen auflisten:

curl -X GET "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/roles" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq

Erhalte eine bestimmte Rolle:

curl -X GET "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/roles/rol-xxxx-xxxxxxxxxx" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq

Die Antwort enthält das name-Feld (z. B. rol-xxxx-xxxxxxxxxx), das für Update- und Löschvorgänge erforderlich ist.

Aktualisieren einer Rolle

Um die Attribute einer Rolle auf der Benutzeroberfläche zu aktualisieren, wählen Sie im Rollenmenü auf der Registerkarte "Rollen & Datenbanken" die Option "Rolle bearbeiten" aus.

Verwenden Sie die API, um die Systemrollen oder Attribute einer Rolle zu aktualisieren. Verwenden Sie update_mask als Abfrageparameter, um anzugeben, welche Felder geändert werden sollen; nur die maskierten Felder werden geändert.

curl -X PATCH "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/roles/rol-xxxx-xxxxxxxxxx?update_mask=spec.membership_roles%2Cspec.attributes.createdb" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "projects/my-project/branches/production/roles/rol-xxxx-xxxxxxxxxx",
    "spec": {
      "membership_roles": ["DATABRICKS_SUPERUSER"],
      "attributes": { "createdb": true }
    }
  }' | jq

Um databricks_superuser zu entfernen, übergeben Sie ein leeres Array: "membership_roles": [].

Ablegen einer Postgres-Rolle

Sie können sowohl identitätsbasierte Databricks-Rollen als auch systemeigene Postgres-Kennwortrollen ablegen.

Benutzeroberfläche

Das Löschen einer Rolle ist eine dauerhafte Aktion, die nicht rückgängig gemacht werden kann. Zum Löschen einer Rolle, die eine Datenbank besitzt, müssen Sie die Rolle angeben, der die eigenen Objekte neu zugewiesen werden soll. Andernfalls muss die Datenbank manuell gelöscht werden, bevor die Rolle gelöscht wird, die die Datenbank besitzt.

So löschen Sie eine beliebige Postgres-Rolle mithilfe der Benutzeroberfläche:

1. Navigieren Sie in der Lakebase-App zur Registerkarte «Rollen und Datenbanken» Ihrer Branch.
2. Wählen Sie im Menü " Rolle löschen" aus, und bestätigen Sie den Löschvorgang.

PostgreSQL

Sie können jede Postgres-Rolle mit standardmäßigen Postgres-Befehlen ablegen. Ausführliche Informationen finden Sie in der PostgreSQL-Dokumentation zum Ablegen von Rollen.

Eine Rolle ablegen:

DROP ROLE role_name;

Nachdem eine identitätsbasierte Azure Databricks-Rolle gelöscht wurde, ist diese Identität nicht mehr in der Lage, sich unter Verwendung von OAuth-Tokens zu authentifizieren, bis eine neue Rolle erstellt wird.

Python SDK

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

operation = w.postgres.delete_role(
    name="projects/my-project/branches/production/roles/rol-xxxx-xxxxxxxxxx"
)
operation.wait()

cURL

curl -X DELETE "$WORKSPACE/api/2.0/postgres/projects/my-project/branches/production/roles/rol-xxxx-xxxxxxxxxx" \
  -H "Authorization: Bearer ${DATABRICKS_TOKEN}" | jq

Vorab erstellte Rollen

Nachdem ein Projekt erstellt wurde, erstellt Azure Databricks automatisch Postgres-Rollen für die Projektverwaltung und erste Schritte.

Erfahren Sie mehr über die spezifischen Funktionen und Berechtigungen dieser Rollen: Vordefinierte Rollenfunktionen

Von Azure Databricks erstellte Systemrollen

Azure Databricks erstellt die folgenden Systemrollen, die für interne Dienste erforderlich sind. Sie können diese Rollen anzeigen, indem Sie einen \du Befehl von psql oder vom Lakebase SQL-Editor ausgeben.

Um zu erfahren, wie Rollen, Berechtigungen und Rollenmitgliedschaften in Postgres funktionieren, verwenden Sie die folgenden Ressourcen in der Dokumentation zu Postgres:

• Datenbankrollen
• Privilegien

Nächste Schritte

• Berechtigungen verwalten
• Herstellen einer Verbindung mit Ihrem Projekt
• Informationen zur Authentifizierung