Skapa Postgres-roller

När du skapar ett projekt skapar Lakebase flera Postgres-roller i projektet:

• En Postgres-roll för projektägarens Azure Databricks-identitet (till exempel user@databricks.com), som äger standarddatabasen databricks_postgres
• En databricks_superuser administrativ roll

Båda dessa roller visas på fliken Roller och databaser när du öppnar projektet.

Databasen databricks_postgres skapas så att du kan ansluta och prova Lakebase direkt efter att projektet har skapats.

Flera systemhanterade roller skapas också. Det här är interna roller som används av Azure Databricks-tjänster för hantering, övervakning och dataåtgärder.

Se Förskapade roller och Systemroller.

Skapa Postgres-roller

Lakebase stöder två typer av Postgres-roller för databasåtkomst:

• OAuth-roller för Azure Databricks-identiteter: Skapa dessa med Lakebase UI, tillägget med SQL, eller med Python SDK och REST API. Gör det möjligt för Azure Databricks-identiteter (användare, tjänstens huvudnamn och grupper) att ansluta med OAuth-token.
• Interna Postgres-lösenordsroller: Skapa dessa med lakebase-användargränssnittet, SQL eller Python SDK och REST API. Använd valfritt giltigt rollnamn med lösenordsautentisering.

Vägledning om hur du väljer vilken typ av roll som ska användas finns i Översikt över autentisering. Var och en är utformad för olika användningsfall.

Skapa en OAuth-roll för Azure Databricks-identiteter

Om du vill tillåta att Azure Databricks-identiteter (användare, tjänstens huvudnamn eller grupper) ansluter med OAuth-token skapar du en OAuth-roll med hjälp av Lakebase-användargränssnittet, databricks_auth tillägget med SQL eller REST-API:et.

Detaljerade anvisningar om hur du hämtar OAuth-token finns i Hämta en OAuth-token i ett användar-till-dator-flöde och Hämta en OAuth-token i ett flöde från dator till dator.

Användargränssnitt (UI)

1. I Fliken Roller och databaser>Lägg till roll>OAuth fliken väljer du användaren, tjänstehuvudnamn eller grupp som ska beviljas databasåtkomst.
2. När du har skapat rollen beviljar du lämpliga databasbehörigheter. Lär dig hur: Hantera behörigheter

SQL

Förutsättningar:

• Du måste ha CREATE och CREATE ROLE behörigheter för databasen
• Du måste autentiseras som en Azure Databricks-identitet med en giltig OAuth-token
• Interna Postgres-autentiserade sessioner kan inte skapa OAuth-roller

1. databricks_auth Skapa tillägget. Varje Postgres-databas måste ha ett eget tillägg.

   CREATE EXTENSION IF NOT EXISTS databricks_auth;
   

2. databricks_create_role Använd funktionen för att skapa en Postgres-roll för Azure Databricks-identiteten:

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

   För en Azure Databricks-användare:

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

   För tjänstens huvudnamn för Azure Databricks:

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

   För en Azure Databricks-grupp:

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

   Gruppnamnet är skiftlägeskänsligt och måste matcha exakt som det visas på din Azure Databricks-arbetsyta. När du skapar en Postgres-roll för en grupp kan alla direkta eller indirekta medlemmar (användare eller tjänstens huvudnamn) i den Databricks-gruppen autentisera till Postgres som grupproll med hjälp av deras enskilda OAuth-token. Med den här behörighetsmodellen på gruppnivå kan du hantera behörigheter i Postgres i stället för att behålla behörigheter för enskilda användare.

3. Bevilja databasbehörigheter till den nyligen skapade rollen.

Funktionen databricks_create_role() skapar en Postgres-roll med LOGIN endast behörighet. När du har skapat rollen måste du bevilja lämpliga databasbehörigheter och behörigheter för de specifika databaser, scheman eller tabeller som användaren behöver åtkomst till. Lär dig hur: Hantera behörigheter

Python SDK

Ange identity_type till USER, SERVICE_PRINCIPALeller GROUP. Ange postgres_role identitetens e-postadress, program-ID (UUID) eller gruppvisningsnamn. Det här värdet blir Postgres-rollnamnet och är det du använder i anslutningssträngar och GRANT -instruktioner.

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

w = WorkspaceClient()

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

När du har skapat rollen beviljar du lämpliga databasbehörigheter. Lär dig hur: Hantera behörigheter

CLI

Ange identity_type till USER, SERVICE_PRINCIPALeller GROUP. Ange postgres_role identitetens e-postadress, program-ID (UUID) eller gruppvisningsnamn. Det här värdet blir Postgres-rollnamnet och är det du använder i anslutningssträngar och GRANT -instruktioner.

För en Azure Databricks-användare:

databricks postgres create-role projects/my-project/branches/production \
  --role-id my-user-role \
  --json '{"spec": {"identity_type": "USER", "postgres_role": "user@example.com"}}'

För tjänstens huvudnamn för Azure Databricks:

databricks postgres create-role projects/my-project/branches/production \
  --role-id my-sp-role \
  --json '{"spec": {"identity_type": "SERVICE_PRINCIPAL", "postgres_role": "8c01cfb1-62c9-4a09-88a8-e195f4b01b08"}}'

För en Azure Databricks-grupp:

databricks postgres create-role projects/my-project/branches/production \
  --role-id my-group-role \
  --json '{"spec": {"identity_type": "GROUP", "postgres_role": "My Group Name"}}'

Kommandot väntar tills åtgärden har slutförts och returnerar den skapade rollen. Använd --no-wait för att returnera omedelbart och genomföra en separat pollning med databricks postgres get-operation.

När du har skapat rollen beviljar du lämpliga databasbehörigheter. Lär dig hur: Hantera behörigheter

lockig

Ange identity_type till USER, SERVICE_PRINCIPALeller GROUP. Ange postgres_role identitetens e-postadress, program-ID (UUID) eller gruppvisningsnamn. Det här värdet blir Postgres-rollnamnet och är det du använder i anslutningssträngar och GRANT -instruktioner.

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

Slutpunkten returnerar en tidskrävande åtgärd. Avsök tills done är true, och använd sedan rollens name-fält för efterföljande API-anrop. Se Tidskrävande åtgärder.

När du har skapat rollen beviljar du lämpliga databasbehörigheter. Lär dig hur: Hantera behörigheter

Gruppbaserad autentisering

När du skapar en Postgres-roll för en Azure Databricks-grupp aktiverar du gruppbaserad autentisering. På så sätt kan alla medlemmar i Azure Databricks-gruppen autentisera till Postgres med hjälp av gruppens roll, vilket förenklar behörighetshanteringen.

Så här fungerar det:

1. Skapa en Postgres-roll för en Azure Databricks grupp.
2. Bevilja databasbehörighet till grupprollen i Postgres. Se Hantera behörigheter.
3. Alla direkta eller indirekta medlemmar (användare eller tjänstens huvudnamn) i den Azure Databricks gruppen kan ansluta till Postgres med sin enskilda OAuth-token.
4. När du ansluter autentiserar medlemmen sig i grupprollen och ärver alla behörigheter du har beviljat till den rollen.

Autentiseringsflöde:

När en gruppmedlem ansluter anger de gruppens Postgres-rollnamn som användarnamn och egen OAuth-token som lösenord:

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

Viktiga överväganden:

• Verifiering av gruppmedlemskap: Gruppmedlemskap verifieras endast vid autentiseringstillfället. Om en medlem tas bort från Azure Databricks-gruppen efter att en anslutning har upprättats förblir anslutningen aktiv. Nya anslutningsförsök från borttagna medlemmar avvisas.
• Omfång för arbetsyta: Endast grupper som har tilldelats samma Azure Databricks-arbetsyta som projektet stöds för gruppbaserad autentisering. Information om hur du tilldelar grupper till en arbetsyta finns i Hantera grupper.
• Skiftlägeskänslighet: Gruppnamnet som används i databricks_create_role() måste matcha gruppnamnet exakt som det visas på din Azure Databricks-arbetsyta, inklusive ärende.
• Behörighetshantering: Det är effektivare att hantera behörigheter på gruppnivå i Postgres än att hantera enskilda användarbehörigheter. När du beviljar behörigheter till grupprollen ärver alla nuvarande och framtida gruppmedlemmar dessa behörigheter automatiskt.
• Identity renaming: Om en användares e-post- eller gruppvisningsnamn ändras i Azure Databricks, slutar autentisering och befintliga databasbehörigheter att fungera. Ta bort den gamla rollen, skapa en ny med det uppdaterade namnet och uppdatera anslutningssträngar och behörigheter.

Skapa en inbyggd Postgres-lösenordsroll

Lösenordsanslutningar kan inaktiveras på projekt- eller beräkningsnivå. Se Blockera lösenordsanslutningar.

Användargränssnitt (UI)

1. I Fliken Roller och databaser>Lägg till> anger du ett rollnamn och eventuellt beviljar databricks_superuser eller systemattribut (CREATEDB, CREATEROLE, BYPASSRLS).
2. Kopiera det genererade lösenordet och ange det på ett säkert sätt för användaren. Det visas inte igen.

SQL

CREATE ROLE role_name WITH LOGIN PASSWORD 'your_secure_password';

Lösenordet måste innehålla minst 12 tecken med en blandning av gemener, versaler, siffror och symboltecken. Användardefinierade lösenord verifieras vid skapandetillfället för att verifiera 60-bitars entropi.

Python SDK

Omit identity_type för att skapa en lösenordsroll. Operationen create_role returnerar ett Role objekt utan lösenordsfält. SDK:n returnerar inte det genererade lösenordet. För att få ett användbart lösenord, se Hur man får tag på ett lösenord.

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

CLI

Omit identity_type för att skapa en lösenordsroll. Kommandot returnerar ett Role objekt utan lösenordsfält. CLI:n returnerar inte det genererade lösenordet. För att få ett användbart lösenord, se Hur man får tag på ett lösenord.

databricks postgres create-role projects/my-project/branches/production \
  --role-id my-app-role \
  --json '{"spec": {"postgres_role": "my-app-role"}}'

Kommandot väntar tills åtgärden har slutförts och returnerar den skapade rollen.

lockig

Omit identity_type för att skapa en lösenordsroll. Slutpunkten returnerar en tidskrävande åtgärd. Kontrollera kontinuerligt tills done är true. Operationsresultatet är ett Role objekt utan lösenordsfält. API:et returnerar inte det genererade lösenordet. För att få ett användbart lösenord, se Hur man får tag på ett lösenord.

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

Hur man får tag på ett lösenord

Python SDK, REST API och CLI skapa-roll-operationerna returnerar inte det genererade lösenordet. Använd en av följande metoder för att få ett lösenord till en inbyggd Postgres-lösenordsroll:

• Sätt ditt eget lösenord vid skapandet med SQL: Kör CREATE ROLE role_name WITH LOGIN PASSWORD 'your_secure_password'; på en OAuth SQL-anslutning. Detta kräver privilegiet CREATEROLE . Se SQL-fliken under Skapa en inbyggd Postgres-lösenordsroll.
• Återställ lösenordet i användargränssnittet: För en roll skapad med Python SDK, REST API, CLI eller Terraform, använd flödet Återställ lösenord i Lakebase-appen för att generera ett nytt lösenord. Se Återställ ett lösenord.

Hur interna lösenordsroller lagras

Men du skapar en intern Postgres-lösenordsroll. Lösenordet lagras aldrig i klartext. Postgres-kärnan på beräkningsnoden lagrar ett SCRAM-SHA-256-verifieringsvärde som beräknas på serversidan (standardvärdet för beräkningsnoden är password_encryption = scram-sha-256). När Lakebase genererar lösenordet åt dig (UI, Python SDK, REST API och CLI-vägar), behåller kontrollplanet också en KMS-krypterad kopia av legitimationen, vilket är det som gör att UI:t kan visa eller återställa lösenordet senare. Lösenord du ställer in med SQL sparas inte på detta sätt: endast verifieraren lagras.

• UI: Azure Databricks genererar lösenordet på serversidan, beräknar verifieraren och visar det genererade lösenordet en gång. Kopiera det då, för det visas inte igen.
• Python SDK, REST API och CLI: Azure Databricks genererar lösenordet på serversidan och beräknar verifieraren, men returnerar inte lösenordet i svaret. För att få ett användbart lösenord, använd SQL vid skapandet eller UI Reset-lösenordsflödet . Se Hur man får tag på ett lösenord. De här sökvägarna accepterar inte ett lösenord som du anger.
• SQL: när du kör CREATE ROLE role_name WITH LOGIN PASSWORD 'your_secure_password'; (eller psqls \password) anger du klartexten, och servern hashar den till verifieraren.

Du behöver aldrig hash ett lösenord själv.

Visa Postgres-roller

Användargränssnitt (UI)

Om du vill visa alla Postgres-roller i projektet går du till grenens fliken Roller och databaser i Lakebase-appen. Alla roller som skapats i grenen, med undantag för Systemroller, visas. Kolumnen Autentiseringstyp anger om varje roll använder OAuth- eller Lösenordsautentisering.

PostgreSQL

Visa alla roller med \du kommandot:

Du kan visa alla Postgres-roller, inklusive systemroller, med metakommandot \du från valfri Postgres-klient (till exempel psql) eller Lakebase SQL-redigeraren:

\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

Visa en lista över alla roller:

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

Hämta en specifik roll:

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

CLI

Visa en lista över alla roller:

databricks postgres list-roles projects/my-project/branches/production

Hämta en specifik roll:

databricks postgres get-role projects/my-project/branches/production/roles/rol-xxxx-xxxxxxxxxx

Utdata innehåller det name fält (till exempel rol-xxxx-xxxxxxxxxx) som krävs för uppdaterings- och borttagningsanrop.

lockig

Visa en lista över alla roller:

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

Hämta en specifik roll:

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

Svaret innehåller det name fält (till exempel rol-xxxx-xxxxxxxxxx) som krävs för uppdaterings- och borttagningsanrop.

Uppdatera en roll

Om du vill uppdatera en rolls attribut i användargränssnittet väljer du Redigera roll på rollmenyn på fliken Roller och databaser .

Använd API:et eller CLI för att uppdatera en rolls systemroller eller attribut. Endast fälten som anges i uppdateringsmasken ändras.

CLI

Uppdatera en roll med hjälp av uppdateringsmaskmönstret. Uppdateringsmasken är det andra positionsargumentet efter resursnamnet.

När du uppdaterar spec.attributesmåste du ange alla tre attributfälten (createdb, createrole, bypassrls) – API:et ersätter hela attributobjektet:

databricks postgres update-role \
  projects/my-project/branches/production/roles/rol-xxxx-xxxxxxxxxx \
  "spec.attributes" \
  --json '{
    "spec": {
      "attributes": {"createdb": true, "createrole": false, "bypassrls": false}
    }
  }'

Om du också vill uppdatera medlemskapsroller lägger du till spec.membership_roles i uppdateringsmasken:

databricks postgres update-role \
  projects/my-project/branches/production/roles/rol-xxxx-xxxxxxxxxx \
  "spec.membership_roles" \
  --json '{"spec": {"membership_roles": ["DATABRICKS_SUPERUSER"]}}'

Om du vill ta bort databricks_superuserskickar du en tom matris: "membership_roles": [].

lockig

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

Om du vill ta bort databricks_superuserskickar du en tom matris: "membership_roles": [].

Ta bort en Postgres-roll

Du kan släppa både Azure Databricks identitetsbaserade roller och inbyggda Postgres-lösenordsroller.

Användargränssnitt (UI)

1. Gå till din grens flik Roller och databaser i Lakebase-applikationen.

2. Klicka på menyn för den roll som du vill släppa och välj Släpp.

3. Aktivera Omtilldela ägda objekt i bekräftelsedialogrutan.

   Det går inte att ta bort en Postgres-roll om den äger databasobjekt som tabeller, vyer eller scheman. När detta är aktiverat visas en rullgardinsmeny för Tilldela ägare på nytt till. Välj rollen för att ta emot ägarskapet för objekten före släppet. Objekt som inte kan omtilldelas, till exempel bidrag till rollen som tas bort, tas bort automatiskt när omtilldelningen har slutförts. När detta är inaktiverat misslyckas borttagningen om rollen äger några objekt.

4. Klicka på Bekräfta.

Att ta bort en roll är permanent och kan inte ångras.

PostgreSQL

Du kan släppa valfri Postgres-roll med postgres-standardkommandon. Mer information finns i PostgreSQL-dokumentationen om att släppa roller.

Ta bort en roll:

DROP ROLE role_name;

När en identitetsbaserad Azure Databricks-roll har tagits bort kan den identiteten inte längre autentisera till Postgres med OAuth-token förrän en ny roll har skapats.

CLI

databricks postgres delete-role \
  projects/my-project/branches/production/roles/rol-xxxx-xxxxxxxxxx

Om rollen äger databasobjekt kan du använda --reassign-owned-to för att överföra ägarskapet till en annan roll innan den tas bort:

databricks postgres delete-role \
  projects/my-project/branches/production/roles/rol-xxxx-xxxxxxxxxx \
  --reassign-owned-to projects/my-project/branches/production/roles/rol-yyyy-yyyyyyyyyy

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

lockig

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

Förskapade roller

När ett projekt har skapats skapar Azure Databricks automatiskt Postgres-roller för projektadministration och komma igång.

Läs mer om de här rollernas specifika funktioner och behörigheter: Förskapade rollfunktioner

Systemroller som skapats av Azure Databricks

Azure Databricks skapar följande systemroller som krävs för interna tjänster. Du kan visa dessa roller genom att utfärda ett \du kommando från psql eller Lakebase SQL-redigeraren.

Om du vill veta hur roller, privilegier och rollmedlemskap fungerar i Postgres använder du följande resurser i Postgres-dokumentationen:

• Databasroller
• Privilegier

Ytterligare resurser

• Hantera behörigheter
• Ansluta till projektet
• Läs mer om autentisering