Creare ruoli Postgres

Quando si crea un progetto, Lakebase crea diversi ruoli Postgres nel progetto:

• Ruolo Postgres per l'identità di Azure Databricks del proprietario del progetto ,ad esempio user@databricks.com, proprietario del database predefinito databricks_postgres
• Un databricks_superuser ruolo amministrativo

Entrambi questi ruoli sono visibili nella scheda Ruoli e database quando si apre il progetto per la prima volta.

Il databricks_postgres database viene creato in modo da potersi connettere e provare Lakebase immediatamente dopo la creazione del progetto.

Vengono creati anche diversi ruoli gestiti dal sistema. Questi sono ruoli interni usati dai servizi di Azure Databricks per operazioni di gestione, monitoraggio e dati.

Vedere Ruoli pre-creati e Ruoli di sistema.

Creare ruoli Postgres

Lakebase supporta due tipi di ruoli Postgres per l'accesso al database:

• Ruoli OAuth per le identità di Azure Databricks: Crearli usando l'interfaccia utente di Lakebase, l'estensione databricks_auth con SQL o Python SDK e l'API REST. Consente alle identità di Azure Databricks (utenti, entità servizio e gruppi) di connettersi usando token OAuth.
• Ruoli password Postgres nativi: Crearli usando l'interfaccia utente di Lakebase, SQL o Python SDK e l'API REST. Usare qualsiasi nome di ruolo valido con l'autenticazione della password.

Per indicazioni sulla scelta del tipo di ruolo da usare, vedere Panoramica dell'autenticazione. Ognuno di essi è progettato per casi d'uso diversi.

Creare un ruolo OAuth per le identità di Azure Databricks

Per consentire alle identità di Azure Databricks (utenti, entità servizio o gruppi) di connettersi usando token OAuth, creare un ruolo OAuth usando l'interfaccia utente di Lakebase, l'estensione databricks_auth con SQL o l'API REST.

Per istruzioni dettagliate su come ottenere token OAuth, vedere Ottenere un token OAuth in un flusso da utente a computer e Ottenere un token OAuth in un flusso da computer a computer.

INTERFACCIA UTENTE

1. Nella scheda Ruoli e database>Aggiungi ruolo>OAuth selezionare l'utente, l'entità servizio o il gruppo a cui concedere l'accesso al database.
2. Dopo aver creato il ruolo, concedere privilegi di database appropriati. Informazioni su come: Gestire le autorizzazioni

SQL

Prerequisiti:

• Devi disporre delle autorizzazioni CREATE e CREATE ROLE sul database.
• È necessario essere autenticati come identità di Azure Databricks con un token OAuth valido
• Le sessioni autenticate native di Postgres non possono creare ruoli OAuth

1. Creare l'estensione databricks_auth . Ogni database Postgres deve avere una propria estensione.

   CREATE EXTENSION IF NOT EXISTS databricks_auth;
   

2. Usare la databricks_create_role funzione per creare un ruolo Postgres per l'identità di Azure Databricks:

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

   Per un utente di Azure Databricks:

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

   Per un principale del servizio di Azure Databricks:

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

   Per un gruppo di Azure Databricks:

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

   Il nome del gruppo fa distinzione tra maiuscole e minuscole e deve corrispondere esattamente come appare nell'area di lavoro di Azure Databricks. Quando si crea un ruolo Postgres per un gruppo, qualsiasi membro diretto o indiretto (utente o entità servizio) di tale gruppo di Databricks può eseguire l'autenticazione in Postgres come ruolo del gruppo usando il proprio token OAuth individuale. In questo modo è possibile gestire le autorizzazioni a livello di gruppo in Postgres anziché mantenere le autorizzazioni per i singoli utenti.

3. Concedere le autorizzazioni del database al ruolo appena creato.

La databricks_create_role() funzione crea un ruolo Postgres con solo l'autorizzazione LOGIN. Dopo aver creato il ruolo, è necessario concedere i privilegi e le autorizzazioni del database appropriati per database, schemi o tabelle specifici a cui l'utente deve accedere. Informazioni su come: Gestire le autorizzazioni

PYTHON SDK

Impostare identity_type su USER, SERVICE_PRINCIPAL o GROUP. Impostare postgres_role rispettivamente sull'indirizzo email dell'identità, sull'ID dell'applicazione (UUID) o sul nome visualizzato del gruppo. Questo valore diventa il nome del ruolo Postgres ed è ciò che si usa nelle stringhe di connessione e GRANT nelle istruzioni.

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}")

Dopo aver creato il ruolo, concedere privilegi di database appropriati. Informazioni su come: Gestire le autorizzazioni

curva

Impostare identity_type su USER, SERVICE_PRINCIPAL, o GROUP. Impostare postgres_role sull'indirizzo di posta elettronica dell'identità, sull'ID dell'applicazione (UUID) o sul nome visualizzato del gruppo rispettivamente. Questo valore diventa il nome del ruolo Postgres ed è ciò che si usa nelle stringhe di connessione e GRANT nelle istruzioni.

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

L'endpoint restituisce un'operazione di lunga durata. Eseguire il polling finché done è true, quindi usare il campo name del ruolo per le chiamate API successive. Vedere Operazioni a esecuzione prolungata.

Dopo aver creato il ruolo, concedere privilegi di database appropriati. Informazioni su come: Gestire le autorizzazioni

Autenticazione basata su gruppo

Quando si crea un ruolo Postgres per un gruppo di Azure Databricks, si abilita l'autenticazione basata su gruppo. Ciò consente a qualsiasi membro del gruppo di Azure Databricks di eseguire l'autenticazione in Postgres usando il ruolo del gruppo, semplificando la gestione delle autorizzazioni.

Funzionamento:

1. Creare un ruolo Postgres per un gruppo databricks.
2. Concedi le autorizzazioni del database al ruolo di gruppo in Postgres. Vedere Gestire le autorizzazioni.
3. Qualsiasi membro diretto o indiretto (utente o entità servizio) del gruppo Databricks può connettersi a Postgres usando il proprio singolo token OAuth.
4. Durante la connessione, il membro esegue l'autenticazione come ruolo del gruppo ed eredita tutte le autorizzazioni concesse a tale ruolo.

Flusso di autenticazione:

Quando un membro del gruppo si connette, specifica il nome del ruolo Postgres del gruppo come nome utente e il proprio token OAuth come password:

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

Considerazioni importanti:

• Convalida dell'appartenenza al gruppo: L'appartenenza al gruppo viene convalidata solo in fase di autenticazione. Se un membro viene rimosso dal gruppo Azure Databricks dopo aver stabilito una connessione, la connessione rimane attiva. I nuovi tentativi di connessione dai membri rimossi vengono rifiutati.
• Ambito dell'area di lavoro: Solo i gruppi assegnati alla stessa area di lavoro di Azure Databricks del progetto sono supportati per l'autenticazione basata su gruppo. Per informazioni su come assegnare gruppi a un'area di lavoro, vedere Gestire i gruppi.
• Distinzione tra maiuscole e minuscole: Il nome del gruppo usato in databricks_create_role() deve corrispondere esattamente al nome del gruppo come appare nell'area di lavoro di Azure Databricks, incluso il caso.
• Gestione delle autorizzazioni: La gestione delle autorizzazioni a livello di gruppo in Postgres è più efficiente rispetto alla gestione delle singole autorizzazioni utente. Quando si concedono autorizzazioni al ruolo del gruppo, tutti i membri del gruppo corrente e futuro ereditano automaticamente tali autorizzazioni.
• Ridenominazione delle identità: Se l'indirizzo di posta elettronica o il nome visualizzato di un utente cambia in Azure Databricks, l'autenticazione e le concessioni di database esistenti verranno interrotte. Eliminare il ruolo precedente, crearne uno nuovo con il nome aggiornato e aggiornare le stringhe di connessione e le concessioni.

Creare un ruolo nativo con password di Postgres

Le connessioni con password possono essere disabilitate a livello di progetto o di calcolo. Vedere Bloccare le connessioni protette da password.

INTERFACCIA UTENTE

1. Nella scheda Ruoli e database>Aggiungi ruolo>Password, inserisci un nome per il ruolo e, facoltativamente, assegna databricks_superuser o attributi di sistema (CREATEDB, CREATEROLE, BYPASSRLS).
2. Copiare la password generata e specificarla in modo sicuro all'utente. Non viene visualizzato di nuovo.

SQL

CREATE ROLE role_name WITH LOGIN PASSWORD 'your_secure_password';

La password deve contenere almeno 12 caratteri con una combinazione di caratteri minuscoli, maiuscoli, numeri e simboli. Le password definite dall'utente vengono convalidate in fase di creazione per garantire l'entropia a 60 bit.

PYTHON SDK

Ometti identity_type per creare un ruolo password. L'API restituisce una password generata nella risposta.

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}")

curva

Omesso identity_type per creare un ruolo di tipo password. L'endpoint restituisce un'operazione a esecuzione prolungata. Eseguire il polling finché done è true.

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

Visualizzare i ruoli di Postgres

INTERFACCIA UTENTE

Per visualizzare tutti i ruoli Postgres nel progetto, passare alla scheda Ruoli e database del ramo nell'app Lakebase. Tutti i ruoli creati nel ramo, ad eccezione dei ruoli di sistema, sono elencati. La colonna Tipo di autenticazione indica se ogni ruolo usa l'autenticazione OAuth o Password.

PostgreSQL

Visualizzare tutti i ruoli con \du il comando :

È possibile visualizzare tutti i ruoli postgres, inclusi i ruoli di sistema, usando il \du metacomcome da qualsiasi client Postgres (ad esempio psql) o dall'editor SQL di Lakebase:

\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

Elencare tutti i ruoli:

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}")

Ottenere un ruolo specifico:

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

curva

Elencare tutti i ruoli:

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

Ottenere un ruolo specifico:

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

La risposta include il name campo (ad esempio , rol-xxxx-xxxxxxxxxx) necessario per le chiamate di aggiornamento ed eliminazione.

Aggiornare un ruolo

Per aggiornare gli attributi di un ruolo nell'interfaccia utente, selezionare Modifica ruolo dal menu ruolo nella scheda Ruoli e database .

Usare l'API per aggiornare i ruoli o gli attributi di sistema di un ruolo. Utilizzare update_mask come parametro di query per specificare i campi da modificare. Vengono modificati solo i campi mascherati.

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

Per rimuovere databricks_superuser, passare una matrice vuota: "membership_roles": [].

Eliminare un ruolo Postgres

È possibile eliminare sia i ruoli basati sull'identità di Databricks che i ruoli password nativi di Postgres.

INTERFACCIA UTENTE

L'eliminazione di un ruolo è un'azione permanente che non può essere annullata. Per eliminare un ruolo proprietario di un database, è necessario specificare il ruolo a cui riassegnare gli oggetti di proprietà. In caso contrario, è necessario eliminare manualmente il database prima di eliminare il ruolo proprietario del database.

Per eliminare qualsiasi ruolo Postgres usando l'interfaccia utente:

1. Passare alla scheda Ruoli e database del ramo nell'app Lakebase.
2. Selezionare Elimina ruolo dal menu del ruolo e confermare l'eliminazione.

PostgreSQL

È possibile eliminare qualsiasi ruolo Postgres usando i comandi Postgres standard. Per informazioni dettagliate, vedere la documentazione di PostgreSQL sull'eliminazione dei ruoli.

Eliminare un ruolo:

DROP ROLE role_name;

Dopo l'eliminazione di un ruolo basato sull'identità di Azure Databricks, tale identità non può più eseguire l'autenticazione a Postgres usando token OAuth fino a quando non viene creato un nuovo ruolo.

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()

curva

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

Ruoli creati in modo preliminare

Dopo aver creato un progetto, Azure Databricks crea automaticamente i ruoli Postgres per l'amministrazione del progetto e per iniziare.

Scopri di più sulle funzionalità e i privilegi specifici di questi ruoli: funzionalità del ruolo predefinite

Ruoli di sistema creati da Azure Databricks

Azure Databricks crea i ruoli di sistema seguenti necessari per i servizi interni. È possibile visualizzare questi ruoli eseguendo un \du comando da psql o l'editor SQL di Lakebase.

Per informazioni sul funzionamento di ruoli, privilegi e appartenenze ai ruoli in Postgres, usare le risorse seguenti nella documentazione di Postgres:

• Ruoli del database
• Privilegi

Passaggi successivi

• Gestire autorizzazioni
• Connettersi al progetto
• Informazioni sull'autenticazione