Tudnivalók a hitelesítésről

Fontos

A Lakebase automatikus skálázása bétaverzióban érhető el a következő régiókban: eastus2, , westeuropewestus.

A Lakebase Autoscaling a Lakebase legújabb verziója automatikus skálázási számítással, nullára skálázással, elágaztatással és azonnali visszaállítással. A Lakebase Provisioned szolgáltatással való összehasonlításához tekintse meg a verziók közötti választást.

Megtudhatja, hogyan hitelesítheti a Lakebase Postgres adatbázis-kapcsolatait. A részletes kapcsolati utasításokért tekintse meg a rövid útmutatót.

Áttekintés

A Lakebase két hitelesítési módszert támogat, amelyek mindegyike különböző használati esetekhez lett kialakítva:

OAuth-jogkivonat hitelesítése: Az Azure Databricks-identitásokat időkorlátos OAuth-jogkivonatokkal használja. A legjobb a következőhöz:

• Interaktív munkamenetek, ahol tokeneket frissíthet.
• Munkaterületbe integrált munkafolyamatok
• Token forgatást megvalósító alkalmazások
• Ha az Azure Databricks által felügyelt hitelesítést szeretné használni

Natív Postgres-jelszóhitelesítés: Hagyományos Postgres-szerepköröket használ jelszavakkal. A legjobb a következőhöz:

• Olyan alkalmazások, amelyek nem tudják óránként frissíteni a hitelesítő adatokat
• Hosszú ideig futó folyamatok
• Olyan eszközök, amelyek nem támogatják a tokenek forgatását

Megjegyzés:

Platformkezelés és adatbázis-hozzáférés: Ez a lap az adatbázis-hitelesítésre összpontosít (OAuth-jogkivonatok és Postgres-jelszavak az adatbázishoz való csatlakozáshoz). A platformfelügyeleti hitelesítéssel (projektek, ágak, számítások létrehozása) kapcsolatban lásd a Project engedélyeit.

Kapcsolatok időkorlátai

Minden adatbázis-kapcsolatra a hitelesítési módszertől függetlenül a következő korlátozások vonatkoznak:

• 24 órás tétlen időtúllépés: A 24 órán át nem tevékenységgel rendelkező kapcsolatok automatikusan bezáródnak.
• 3 napos maximális kapcsolati élettartam: A 3 napnál hosszabb ideig életben lévő kapcsolatok tevékenységtől függetlenül bezárhatók.

Tervezze meg úgy az alkalmazásait, hogy a kapcsolat időtúllépéseit kezeljék, bevezetve a kapcsolat újrapróbálkozási logikáját megfelelő időtúllépési beállításokkal.

OAuth-jogkivonat hitelesítése

Az OAuth-jogkivonat-hitelesítés lehetővé teszi az Azure Databricks-identitással való csatlakozást. Időkorlátos OAuth-jogkivonatot hoz létre a Lakebase felhasználói felületén, és jelszóként használja a Postgreshez való csatlakozáskor.

A projekttulajdonos OAuth szerepköre automatikusan létrejön. Az OAuth-hitelesítés engedélyezéséhez más Azure Databricks-identitások számára, létre kell hoznia a Postgres-szerepköreiket a databricks_auth bővítmény és az SQL használatával. Lásd: OAuth-szerepkör létrehozása ADATBÁZIS-identitáshoz SQL használatával.

Az OAuth-jogkivonatok működése

• Jogkivonat élettartama: Az OAuth-jogkivonatok egy óra elteltével lejárnak.
• Lejárat kényszerítése: A jogkivonat lejárata csak bejelentkezéskor érvényes. A nyitva maradt kapcsolatok a jogkivonat lejárata után is aktívak maradnak.
• Újrahitelesítés: A Postgres-lekérdezések vagy -parancsok meghiúsulnak, ha a jogkivonat lejárt.
• Jogkivonat frissítése: Interaktív munkamenetekhez szükség esetén hozzon létre egy új jogkivonatot a felhasználói felületről. A hosszú ideig futó kapcsolatokkal rendelkező alkalmazások esetében a hitelesítő adatok automatikus frissítéséhez implementáljon jogkivonat-rotációt .

Követelmények és korlátozások

• Megfelelő Postgres-szerepkör szükséges: Az Azure Databricks-identitásnak megfelelő Postgres-szerepkörrel kell rendelkeznie. A projekttulajdonos szerepköre automatikusan létrejön. Más Azure Databricks-identitásokhoz hozza létre a szerepköreit a databricks_auth bővítmény használatával.
• Munkaterület hatókörének meghatározása: Az OAuth-jogkivonatok munkaterület-hatókörűek, és ugyanahhoz a munkaterülethez kell tartozniük, amely a projektet birtokolja. A munkaterületek közötti jogkivonat-hitelesítés nem támogatott.
• SSL szükséges: A jogkivonatalapú hitelesítéshez SSL-kapcsolatok szükségesek. Minden ügyfelet SSL használatára kell konfigurálni (általában sslmode=require).

OAuth-jogkivonat beszerzése a felhasználó–gép folyamatában

Ha Ön adatbázistulajdonos, rendszergazda vagy az Azure Databricks-identitás megfelelő Postgres-szerepkörrel rendelkezik az adatbázishoz, OAuth-jogkivonatot szerezhet be a felhasználói felületről, a Databricks API-ból, a parancssori felületről vagy a Databricks SDK-k egyikéből.

Más Azure Databricks-identitásfelhasználók esetében lásd: Felhasználói hozzáférés engedélyezése az Azure Databrickshez OAuth-tal a munkaterületszintű engedélyezési utasításokhoz OAuth-jogkivonatok beszerzéséhez.

UI

Ha olyan SQL-klienseket használ, mint a psql vagy a DBeaver, a Lakebase felhasználói felületének használatával hozzon létre jogkivonatokat:

1. A projekthez navigáljon a Lakebase alkalmazásban.
2. Válassza ki azt az ágat és számítást, amelyhez csatlakozni szeretne.
3. Kattintson a Csatlakozás gombra , és kövesse az utasításokat egy OAuth-jogkivonat létrehozásához.

A teljes útmutatásért tekintse meg a Csatlakozás OAuth-szerepkörrel című témakört.

parancssori felület

# Generate OAuth token for database connection (1-hour expiration)
databricks postgres generate-database-credential projects/my-project/branches/production/endpoints/my-compute --output json

Válasz:

{
  "token": "eyJraWQiOiI1NDdkNjFjNzQ2YTk3M2Q3M2ViNjM2YWRiMWY2Nz...",
  "expire_time": "2026-01-22T17:07:00Z"
}

Az adatbázishoz való csatlakozáskor használja az token értéket jelszóként.

Python SDK

OAuth-jogkivonatot a Pythonhoz készült Databricks SDK használatával hozhat létre.

from databricks.sdk import WorkspaceClient

w = WorkspaceClient()

# Generate OAuth token for database connection (1-hour expiration)
credential = w.postgres.generate_database_credential(
    endpoint="projects/my-project/branches/production/endpoints/my-compute"
)

print(f"Token: {credential.token}")
print(f"Expires: {credential.expire_time}")

# Use the token to connect to Postgres
import psycopg2

conn = psycopg2.connect(
    host="ep-example.database.region.databricks.com",
    port=5432,
    database="postgres",
    user="your.email@company.com",
    password=credential.token,
    sslmode="require"
)

Java SDK

OAuth-jogkivonatot a Java Databricks SDK-val hozhat létre.

import com.databricks.sdk.WorkspaceClient;
import com.databricks.sdk.service.postgres.*;

WorkspaceClient w = new WorkspaceClient();

// Generate OAuth token for database connection (1-hour expiration)
DatabaseCredential credential = w.postgres().generateDatabaseCredential(
    new GenerateDatabaseCredentialRequest()
        .setEndpoint("projects/my-project/branches/production/endpoints/my-compute")
);

System.out.println("Token: " + credential.getToken());
System.out.println("Expires: " + credential.getExpireTime());

OAuth-jogkivonat beszerzése gépről gépre folyamatban

Az adatbázishoz való biztonságos, automatizált (gépről gépre) hozzáférés engedélyezéséhez egy OAuth-jogkivonatot kell beszereznie egy Azure Databricks szolgáltatási fiókkal. Ez a folyamat magában foglalja a szolgáltatásidentitás konfigurálását, a hitelesítő adatok generálását és az OAuth-jogkivonatok hitelesítés céljából történő kibocsátását.

1. Konfiguráljon egy szolgáltatásfőfelhasználót határozatlan élettartamú hitelesítő adatokkal. Útmutatásért lásd: Szolgáltatásnév hozzáférésének engedélyezése az Azure Databrickshez az OAuth használatával.

2. Hozzon létre új OAuth-jogkivonatokat szolgáltatási főkapcsolatként.

   parancssori felület

   # Generate OAuth token for database connection (1-hour expiration)
   databricks postgres generate-database-credential projects/my-project/branches/production/endpoints/my-compute --output json
   

   Válasz:

   {
     "token": "eyJraWQiOiI1NDdkNjFjNzQ2YTk3M2Q3M2ViNjM2YWRiMWY2Nz...",
     "expire_time": "2026-01-22T17:07:00Z"
   }
   

   Az adatbázishoz való csatlakozáskor használja az token értéket jelszóként.

   Python SDK

   OAuth-jogkivonatot a Pythonhoz készült Databricks SDK használatával hozhat létre.

   from databricks.sdk import WorkspaceClient
   
   w = WorkspaceClient(
       host="https://<YOUR WORKSPACE URL>/",
       client_id="<YOUR SERVICE PRINCIPAL ID>",
       client_secret="REDACTED"
   )
   
   # Generate OAuth token for database connection (1-hour expiration)
   credential = w.postgres.generate_database_credential(
       endpoint="projects/my-project/branches/production/endpoints/my-compute"
   )
   
   print(f"Token: {credential.token}")
   print(f"Expires: {credential.expire_time}")
   

   Java SDK

   OAuth-jogkivonatot a Java Databricks SDK-val hozhat létre.

   import com.databricks.sdk.WorkspaceClient;
   import com.databricks.sdk.core.DatabricksConfig;
   import com.databricks.sdk.service.postgres.*;
   
   // Initialize with service principal credentials
   DatabricksConfig config = new DatabricksConfig()
       .setHost("https://<YOUR WORKSPACE URL>/")
       .setClientId("<YOUR SERVICE PRINCIPAL ID>")
       .setClientSecret("REDACTED");
   
   WorkspaceClient w = new WorkspaceClient(config);
   
   // Generate OAuth token for database connection (1-hour expiration)
   DatabaseCredential credential = w.postgres().generateDatabaseCredential(
       new GenerateDatabaseCredentialRequest()
           .setEndpoint("projects/my-project/branches/production/endpoints/my-compute")
   );
   
   System.out.println("Token: " + credential.getToken());
   System.out.println("Expires: " + credential.getExpireTime());
   

Megjegyzés:

OAuth-jogkivonatok elforgatása óránkénti lejárat előtt:

• Ellenőrizze az OAuth-jogkivonat lejárati idejét minden használatkor, és szükség esetén frissítsen.
• Másik lehetőségként állítson be egy háttérszálat az aktuális OAuth-jogkivonat rendszeres frissítéséhez.

Token rotálási példák

Mivel az OAuth-jogkivonatok egy óra elteltével lejárnak, a hosszú ideig futó adatbázis-kapcsolatokat karbantartó alkalmazásoknak jogkivonat-rotációt kell implementálniuk a hitelesítő adatok rendszeres frissítéséhez. Az alábbi példák bemutatják, hogyan forgathatja automatikusan a tokeneket az alkalmazás kódjában.

Megjegyzés:

Az alábbi példák követelményei:

• A projekt tulajdonosának munkaterületén hitelesítve kell lennie. WorkspaceClient() az Ön munkaterületének OAuth-hitelesítő adatait használja adatbázis-jogkivonatok létrehozásához.
• Az Azure Databricks-identitásnak annak a munkaterületnek a tagja kell lennie, ahol a projektet létrehozták.
• Kérje le a kapcsolati paramétereket (gazdagép, adatbázis, végpont) a Lakebase-alkalmazás Csatlakozás párbeszédpaneljéről. Részletekért tekintse meg a rövid útmutatót .
• A endpoint paraméter a következő formátumot használja: projects/{project-id}/branches/{branch-id}/endpoints/{endpoint-id}

A munkaterület-hitelesítés beállításával kapcsolatban lásd: Felhasználói hozzáférés engedélyezése az Azure Databrickshez OAuth-tal vagy szolgáltatásnévhozzáférés engedélyezése az Azure Databrickshez az OAuth használatával.

Python: psycopg3

Ez a példa a psycopg3 kapcsolatkészletét használja egy egyéni kapcsolatosztálysal, amely minden új kapcsolat létrehozásakor létrehoz egy új OAuth-jogkivonatot. Ez a módszer biztosítja, hogy a kapcsolatkészlet minden kapcsolata mindig érvényes, aktuális tokennel rendelkezik.

%pip install "psycopg[binary,pool]"

from databricks.sdk import WorkspaceClient

import psycopg
from psycopg_pool import ConnectionPool

w = WorkspaceClient()

class CustomConnection(psycopg.Connection):
    global w
    def __init__(self, *args, **kwargs):
        # Call the parent class constructor
        super().__init__(*args, **kwargs)

    @classmethod
    def connect(cls, conninfo='', **kwargs):
        # Generate a fresh OAuth token for each connection
        endpoint = "projects/<project-id>/branches/<branch-id>/endpoints/<endpoint-id>"
        credential = w.postgres.generate_database_credential(endpoint=endpoint)
        kwargs['password'] = credential.token

        # Call the superclass's connect method with updated kwargs
        return super().connect(conninfo, **kwargs)

# Configure connection parameters (get these from the Connect dialog in the LakeBase App)
username = "your.email@company.com"  # Your DB identity
host = "ep-example.database.region.databricks.com"  # Your compute endpoint hostname
port = 5432
database = "databricks_postgres"

# Create connection pool with custom connection class
pool = ConnectionPool(
    conninfo=f"dbname={database} user={username} host={host} sslmode=require",
    connection_class=CustomConnection,
    min_size=1,
    max_size=10,
    open=True
)

# Use the connection pool
with pool.connection() as conn:
    with conn.cursor() as cursor:
        cursor.execute("SELECT version()")
        for record in cursor:
            print(record)

Python: SQLAlchemy

Ez a példa az SQLAlchemy kapcsolatkészletét használja egy eseményfigyelővel, amely 15 percenként automatikusan frissíti az OAuth-jogkivonatot. Az eseményfigyelő ellenőrzi a jogkivonat korát, mielőtt minden új kapcsolat létrejön a készletből, biztosítva, hogy az alkalmazás mindig érvényes jogkivonattal rendelkezik manuális beavatkozás nélkül.

%pip install sqlalchemy==1.4 psycopg[binary]

from databricks.sdk import WorkspaceClient
import time

from sqlalchemy import create_engine, text, event

w = WorkspaceClient()

# Configure connection parameters (get these from the Connect dialog in the LakeBase App)
endpoint = "projects/<project-id>/branches/<branch-id>/endpoints/<endpoint-id>"
username = "your.email@company.com"  # Your DB identity
host = "ep-example.database.region.databricks.com"  # Your compute endpoint hostname
port = 5432
database = "databricks_postgres"

# Create SQLAlchemy engine
connection_pool = create_engine(f"postgresql+psycopg2://{username}:@{host}:{port}/{database}?sslmode=require")

# Global variables for token management
postgres_password = None
last_password_refresh = time.time()

@event.listens_for(connection_pool, "do_connect")
def provide_token(dialect, conn_rec, cargs, cparams):
    global postgres_password, last_password_refresh

    # Refresh token if it's None or older than 15 minutes (900 seconds)
    if postgres_password is None or time.time() - last_password_refresh > 900:
        print("Refreshing PostgreSQL OAuth token")
        credential = w.postgres.generate_database_credential(endpoint=endpoint)
        postgres_password = credential.token
        last_password_refresh = time.time()

    cparams["password"] = postgres_password

# Use the connection pool
with connection_pool.connect() as conn:
    result = conn.execute(text("SELECT version()"))
    for row in result:
        print(f"Connected to PostgreSQL database. Version: {row}")

Postgres jelszóhitelesítés

A natív Postgres-jelszó-hitelesítés hagyományos Postgres-szerepköröket használ jelszavakkal. Az OAuth-jogkivonatokkal ellentétben ezek a jelszavak nem járnak le egy óra elteltével, így alkalmasak olyan alkalmazásokhoz, amelyek nem tudják kezelni a hitelesítő adatok gyakori rotálását.

Mikor érdemes Postgres-jelszavakat használni?

A Postgres jelszóhitelesítésének használata a következő esetekben:

• Az alkalmazás vagy eszköz nem tudja óránként frissíteni a hitelesítő adatokat
• Hosszú ideig futó folyamatokkal rendelkezik, amelyekhez stabil hitelesítő adatokra van szükség
• Az ügyfélkódtár nem támogatja az OAuth-jogkivonatok rotálását
• A kompatibilitáshoz hagyományos adatbázis-hitelesítésre van szükség

A Postgres-jelszavak működése

• Jelszó élettartama: A jelszavak nem járnak le automatikusan
• Nincs munkaterület-integráció: A hitelesítést a Postgres kezeli, nem az Azure Databricks-munkaterület hitelesítése
• Manuális kezelés: A jelszavakat manuálisan kell elforgatni és elosztani a felhasználók között
• A kapcsolat időtúllépései továbbra is érvényesek: Annak ellenére, hogy a jelszavak nem járnak le, a kapcsolatokra továbbra is 24 órás tétlenségi időtúllépés és 7 napos maximális kapcsolati élettartam vonatkozik

Biztonsági szempontok

• Jelszótárolás: A jelszavak biztonságos tárolása környezeti változók vagy titkos kódok felügyeleti rendszerei használatával
• SSL szükséges: Minden kapcsolatnak SSL-t kell használnia (sslmode=require)

Következő lépések

• Rövid útmutató: Csatlakozás az adatbázishoz
• Postgres-szerepkörök kezelése
• Engedélyek kezelése
• Adatok lekérdezése