À propos de l'authentification
Découvrez comment authentifier les connexions à la base de données Lakebase Postgres. Pour des instructions de connexion pas à pas, consultez Démarrage rapide.
Présentation
Lakebase prend en charge deux méthodes d'authentification, chacune conçue pour des cas d'utilisation différents :
Authentification par jeton OAuth : utilise les identités Databricks avec des jetons OAuth à durée limitée. Idéal pour :
- Sessions interactives où vous pouvez refresh les jetons.
- Workflows intégrés au Workspace
- Applications pouvant implémenter la rotation des jetons
- Lorsque vous souhaitez une authentification gérée par Databricks
Authentification native par mot de passe Postgres : utilise des rôles Postgres traditionnels avec des mots de passe. Idéal pour :
- Applications qui ne peuvent pas refresh les identifiants toutes les heures
- Processus de longue durée
- Outils qui ne prennent pas en charge la rotation des jetons
**Gestion de la plateforme vs accès à la base de données** : Cette page se concentre sur l'authentification de la base de données (jetons OAuth et mots de passe Postgres pour la connexion à votre base de données). Pour l'authentification de la gestion de la plateforme (création de projets, de Branch, de computes), consultez les autorisations de projet.
Dépassements de délai de connexion
Toutes les connexions de base de données sont soumises aux limites suivantes, quelle que soit la méthode d'authentification :
- **Délai d'inactivité de 24 heures :** Les connexions sans activité pendant 24 heures sont automatiquement fermées.
- Durée de vie maximale de la connexion de 3 jours : Les connexions actives pendant plus de 3 jours peuvent être fermées, quelle que soit leur activité.
Concevez vos applications pour gérer les délais d'expiration de connexion avec élégance en implémentant une logique de nouvelle tentative de connexion avec des paramètres de délai d'expiration appropriés.
Authentification par jeton OAuth
L'authentification par jeton OAuth vous permet de vous connecter en utilisant votre identité Databricks. Vous générez un jeton OAuth limité dans le temps et l'utilisez comme mot de passe lors de la connexion à Postgres.
Le rôle OAuth du propriétaire du projet est créé automatiquement. Pour activer l'authentification OAuth pour d'autres identités Databricks, vous devez créer leurs rôles Postgres à l'aide de l'extension databricks_auth et de SQL. Voir Créer un rôle OAuth pour une identité DB à l'aide de SQL.
Fonctionnement des jetons OAuth
- Durée de vie du jeton : les jetons OAuth expirent après une heure.
- Application de l'expiration : l'expiration des jetons n'est appliquée qu'à la connexion. Les connexions ouvertes restent actives même après l'expiration du jeton.
- refresh: Pour les sessions interactives, générez un nouveau jeton lorsque nécessaire. Pour les applications avec des connexions de longue durée, implémentez la rotation de jetons pour refresh automatiquement les identifiants.
Exigences et limites
- Rôle Postgres correspondant requis : Votre identité Databricks doit avoir un rôle Postgres correspondant. Le rôle du propriétaire du projet est créé automatiquement. Pour les autres identités Databricks, créez leurs rôles à l'aide de l'extension
databricks_auth. - Délimitation du périmètre des Workspace : les jetons OAuth sont spécifiques au Workspace et doivent appartenir au même Workspace que celui qui détient le projet. L'authentification par jeton Inter-workspace n'est pas prise en charge.
- SSL requis : L'authentification basée sur des jetons nécessite des connexions SSL. Tous les clients doivent être configurés pour utiliser SSL (généralement
sslmode=require). - **La mise en commun des connexions n'est pas prise en charge** : le pooler de connexions PgBouncer intégré ne prend pas en charge l'authentification OAuth. Utilisez les rôles de mot de passe Postgres natifs pour les connexions de Pool. Consultez Utiliser la mise en commun des connexions.
Obtenez un jeton OAuth dans un flux utilisateur-machine
Si vous êtes propriétaire ou administrateur de base de données, ou si votre identité Databricks a un rôle Postgres correspondant pour la base de données, vous pouvez obtenir un jeton OAuth à partir de l'interface utilisateur, de l'API Databricks, de la CLI ou de l'un des SDK Databricks.
Pour les autres utilisateurs d'identité Databricks, consultez Autoriser l'accès des utilisateurs à Databricks avec OAuth pour obtenir les instructions d'autorisation au niveau du Workspace afin d'obtenir des jetons OAuth.
- UI
- CLI
- Python SDK
- Java SDK
Lorsque vous utilisez des clients SQL comme psql ou DBeaver, utilisez l'interface utilisateur Lakebase pour générer des jetons :
- Accédez à votre projet dans l'application Lakebase.
- Sélectionnez la branch et le compute auxquels vous souhaitez vous connecter.
- Cliquez sur **Connecter** et suivez les instructions pour générer un jeton OAuth.
Consultez Se connecter avec un rôle OAuth pour des instructions complètes.
# Generate OAuth token for database connection (1-hour expiration)
databricks postgres generate-database-credential projects/my-project/branches/production/endpoints/my-compute --output json
Réponse :
{
"token": "eyJraWQiOiI1NDdkNjFjNzQ2YTk3M2Q3M2ViNjM2YWRiMWY2Nz...",
"expire_time": "2026-01-22T17:07:00Z"
}
Utilisez la valeur token comme mot de passe lors de la connexion à votre base de données.
Vous pouvez générer un jeton OAuth en utilisant le SDK Databricks pour Python.
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 psycopg
conn = psycopg.connect(
host="ep-example.database.region.databricks.com",
port=5432,
dbname="databricks_postgres",
user="your.email@company.com",
password=credential.token,
sslmode="require"
)
Vous pouvez générer un jeton OAuth à l'aide du SDK Databricks pour Java.
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());
Obtenez un jeton OAuth dans un flux machine à machine
Pour activer l'accès sécurisé et automatisé (de machine à machine) à la base de données, vous devez obtenir un jeton OAuth en utilisant un Service Principal Databricks. Ce processus implique la configuration du Service Principal, la génération des identifiants et la création de jetons OAuth pour l'authentification.
- Configurez un service principal avec des identifiants à durée de vie illimitée. Pour obtenir des instructions, consultez Autoriser l'accès du Service Principal à Databricks avec OAuth.
- Créez de nouveaux jetons OAuth en tant que Service Principal.
- CLI
- Python SDK
- Java SDK
# Generate OAuth token for database connection (1-hour expiration)
databricks postgres generate-database-credential projects/my-project/branches/production/endpoints/my-compute --output json
Réponse :
{
"token": "eyJraWQiOiI1NDdkNjFjNzQ2YTk3M2Q3M2ViNjM2YWRiMWY2Nz...",
"expire_time": "2026-01-22T17:07:00Z"
}
Utilisez la valeur token comme mot de passe lors de la connexion à votre base de données.
Vous pouvez générer un jeton OAuth en utilisant le SDK Databricks pour Python.
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}")
Vous pouvez générer un jeton OAuth à l'aide du SDK Databricks pour Java.
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());
Renouveler les jetons OAuth avant l'expiration horaire :
- Vérifiez la date d'expiration du jeton OAuth à chaque utilisation et refresh si nécessaire.
- Vous pouvez également configurer un thread d’arrière-plan pour refresh périodiquement le jeton OAuth actuel.
Exemples de rotation de jetons
Étant donné que les jetons OAuth expirent après une heure, les applications qui maintiennent des connexions de base de données de longue durée doivent implémenter une rotation de jetons pour refresh les informations d'identification périodiquement. Les exemples suivants montrent comment faire pivoter automatiquement les jetons dans votre code d'application.
Exigences pour ces exemples :
- Vous devez être authentifié au Workspace qui possède le projet. Le
WorkspaceClient()utilise vos informations d'identification OAuth du Workspace pour générer des jetons de base de données. - Votre identité Databricks doit être membre du Workspace où le projet a été créé.
- Récupérez vos paramètres de connexion (hôte, base de données, endpoint) à partir de la boîte de dialogue Connecter dans l'application Lakebase. Consultez le Démarrage rapide pour plus de détails.
- Le paramètre
endpointutilise le format :projects/{project-id}/branches/{branch-id}/endpoints/{endpoint-id}
Pour la configuration de l'authentification de l'Workspace, consultez Autoriser l'accès des utilisateurs à Databricks avec OAuth ou autoriser l'accès du Service Principal à Databricks avec OAuth.
- Python: psycopg3
- Python: SQLAlchemy
Cet exemple utilise le Pool de connexions psycopg3 avec une classe de connexion personnalisée qui génère un nouveau jeton OAuth à chaque fois qu'une nouvelle connexion est créée. Cette approche garantit que chaque connexion du pool dispose toujours d'un jeton valide et actuel.
%pip install "psycopg[binary,pool]"
from databricks.sdk import WorkspaceClient
import psycopg
from psycopg_pool import ConnectionPool
w = WorkspaceClient()
class CustomConnection(psycopg.Connection):
@classmethod
def connect(cls, conninfo='', **kwargs):
# Generate a fresh OAuth token for each new connection
endpoint = "projects/<project-id>/branches/<branch-id>/endpoints/<endpoint-id>"
credential = w.postgres.generate_database_credential(endpoint=endpoint)
kwargs['password'] = credential.token
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)
Cet exemple utilise le Pool de connexions de SQLAlchemy avec un écouteur d'événements qui refresh automatiquement le jeton OAuth avant qu'il n'expire. L'écouteur d'événements se déclenche avant chaque nouvelle connexion physique créée à partir du Pool et refresh le jeton s'il est à moins de 2 minutes de l'expiration, garantissant que votre application dispose toujours d'un jeton valide sans intervention manuelle.
%pip install sqlalchemy==2.0.36 "psycopg[binary]==3.2.3" databricks-sdk==0.79.0
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+psycopg://{username}:@{host}:{port}/{database}?sslmode=require")
# Global variables for token management
postgres_password = None
token_expiry = 0.0 # Unix timestamp when the current token expires
@event.listens_for(connection_pool, "do_connect")
def provide_token(dialect, conn_rec, cargs, cparams):
global postgres_password, token_expiry
# Refresh token if None or expiring within 2 minutes
if postgres_password is None or time.time() >= token_expiry - 120:
print("Refreshing PostgreSQL OAuth token")
credential = w.postgres.generate_database_credential(endpoint=endpoint)
postgres_password = credential.token
token_expiry = credential.expire_time.seconds
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}")
Authentification par mot de passe Postgres
Les connexions par mot de passe sont désactivées par default pour les nouveaux projets Lakebase Autoscaling. Pour les activer, consultez Gérer les connexions par mot de passe.
L’authentification par mot de passe Postgres native utilise les rôles Postgres traditionnels avec des mots de passe. Contrairement aux jetons OAuth, ces mots de passe n'expirent pas après une heure, ce qui les rend adaptés aux applications qui ne peuvent pas gérer une rotation fréquente des identifiants.
Quand utiliser les mots de passe Postgres
Utilisez l'authentification par mot de passe Postgres lorsque :
- Votre application ou votre outil ne peut pas refresh les informations d'identification toutes les heures.
- Vous avez des processus de longue durée qui nécessitent des informations d'identification stables.
- Votre bibliothèque cliente ne prend pas en charge la rotation des jetons OAuth.
- Vous avez besoin d'une authentification de base de données traditionnelle pour la compatibilité
Fonctionnement des mots de passe Postgres
- Durée de vie du mot de passe : les mots de passe n'expirent pas automatiquement
- Aucune intégration de workspace : l'authentification est gérée par Postgres, et non par l'authentification du workspace Databricks.
- Gestion manuelle : les mots de passe doivent être manuellement renouvelés et distribués aux utilisateurs
- Les délais d'expiration de connexion s'appliquent toujours : Même si les mots de passe n'expirent pas, les connexions sont toujours soumises à un délai d'inactivité de 24 heures et à une durée de vie maximale de connexion de 3 jours.
Considérations de sécurité
- **Stockage des mots de passe** : Stockez les mots de passe en toute sécurité à l'aide de variables d'environnement ou de systèmes de gestion des secrets.
- SSL requis : toutes les connexions doivent utiliser le SSL (
sslmode=require)
Pool de connexions
Les rôles de mot de passe natifs de Postgres prennent en charge le pooler de connexion PgBouncer intégré. Le pooler réduit la surcharge de connexion pour les applications à haut throughput. Consultez Utiliser le pooling de connexions.