Partager via

À propos de l’authentification

Important

La mise à l’échelle automatique Lakebase est en version bêta dans les régions suivantes : eastus2, westeurope, westus.

Lakebase Autoscaling est la dernière version de Lakebase avec calcul à mise à l’échelle automatique, mise à l’échelle jusqu'à zéro, création de branches, et restauration instantanée. Pour la comparaison des fonctionnalités avec Lakebase Provisioned, consultez le choix entre les versions.

Découvrez comment authentifier les connexions de base de données à Lakebase Postgres. Pour obtenir des instructions de connexion pas à pas, consultez démarrage rapide.

Aperçu

Lakebase prend en charge deux méthodes d’authentification, chacune conçue pour différents cas d’usage :

Authentification par jeton OAuth : Utilise des identités Azure Databricks avec des jetons OAuth limités dans le temps. Meilleur pour :

  • Sessions interactives dans lesquelles vous pouvez actualiser des jetons
  • Workflows intégrés à l’espace de travail
  • Applications qui peuvent implémenter la rotation des jetons
  • Quand vous souhaitez l’authentification gérée par Azure Databricks

Authentification par mot de passe Postgres native : Utilise des rôles Postgres traditionnels avec des mots de passe. Meilleur pour :

  • Applications qui ne peuvent pas actualiser les informations d’identification toutes les heures
  • Processus de longue durée
  • Outils qui ne prennent pas en charge la rotation des jetons

Note

Gestion de la plateforme et accès à la base de données : cette page se concentre sur l’authentification de base de données (jetons OAuth et mots de passe Postgres pour la connexion à votre base de données). Pour l'authentification de gestion de la plateforme (création de projets, branches, ressources informatiques), consultez Autorisations de projet.

Délai d'attente 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 3 jours de connexion : Les connexions qui ont été actives depuis plus de 3 jours peuvent être fermées indépendamment de l’activité.

Concevez vos applications pour gérer correctement les délais d’expiration de connexion en implémentant la logique de nouvelle tentative de connexion avec les paramètres de délai d’expiration appropriés.

Authentification par jeton OAuth

L’authentification par jeton OAuth vous permet de vous connecter à l’aide de votre identité Azure Databricks. Vous générez un jeton OAuth limité dans le temps à partir de l’interface utilisateur Lakebase 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 Azure Databricks, vous devez créer leurs rôles Postgres à l’aide de l’extension databricks_auth et de SQL. Consultez Créer un rôle OAuth pour une identité de base de données à 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 du jeton est appliquée uniquement lors de la connexion. Les connexions ouvertes restent actives même après l’expiration du jeton.
  • Authentification à nouveau : Toute requête ou commande Postgres échoue si le jeton a expiré.
  • Actualisation du jeton : Pour les sessions interactives, générez un nouveau jeton à partir de l’interface utilisateur si nécessaire. Pour les applications avec des connexions longues, implémentez la rotation des jetons pour actualiser automatiquement les informations d’identification.

Conditions requises et limitations :

  • Rôle Postgres correspondant requis : votre identité Azure Databricks doit avoir un rôle Postgres correspondant. Le rôle du propriétaire du projet est créé automatiquement. Pour les autres identités Azure Databricks, créez leurs rôles à l’aide de l’extension databricks_auth .
  • Délimitation de l'espace de travail : les jetons OAuth sont spécifiques à l'espace de travail et doivent appartenir au même espace de travail que le projet auquel ils appartiennent. L’authentification par jeton entre espaces de travail n’est pas prise en charge.
  • SSL requis : l’authentification basée sur un jeton nécessite des connexions SSL. Tous les clients doivent être configurés sslmode=requirepour utiliser SSL (généralement).

Obtenir un jeton OAuth dans un flux utilisateur à machine

Si vous êtes propriétaire, administrateur ou votre identité Azure 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 l’interface CLI ou de l’un des kits SDK Databricks.

Pour les autres utilisateurs d’identité Azure Databricks, consultez Autoriser l’accès utilisateur à Azure Databricks avec OAuth pour obtenir des jetons OAuth au niveau de l’espace de travail.

IU

Lorsque vous utilisez des clients SQL comme psql ou DBeaver, utilisez l’interface utilisateur Lakebase pour générer des jetons :

  1. Accédez à votre projet dans l’application Lakebase.
  2. Sélectionnez la branche et le calcul auquel vous souhaitez vous connecter.
  3. Cliquez sur Se connecter et suivez les instructions pour générer un jeton OAuth.

Pour obtenir des instructions complètes , consultez Se connecter avec un rôle OAuth .

Interface de ligne de commande (CLI)

# 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 token valeur comme mot de passe lors de la connexion à votre base de données.

Kit de développement logiciel (SDK) Python

Vous pouvez générer un jeton OAuth à l’aide du Kit de développement logiciel (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 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"
)

Kit de développement logiciel (SDK) Java

Vous pouvez générer un jeton OAuth à l’aide du Kit de développement logiciel (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());

Obtenir un jeton OAuth dans un flux machine à machine

Pour activer l’accès sécurisé et automatisé (machine à ordinateur) à la base de données, vous devez obtenir un jeton OAuth à l’aide d’un principal de service Azure Databricks. Ce processus implique la configuration du principal de service, la génération d’informations d’identification et la frappe de jetons OAuth pour l’authentification.

  1. Configurez un principal de service avec des informations d’identification valides indéfiniment. Pour obtenir des instructions, consultez Autoriser l’accès du principal de service à Azure Databricks avec OAuth.
  2. Créez des jetons OAuth en tant que principal de service.

Note : Les jetons d'authentification de base de données sont limités à cet espace de travail. Pendant que le endpoint paramètre est requis, le jeton retourné peut accéder à n’importe quelle base de données ou projet dans l’espace de travail pour lequel le principal de service dispose des autorisations nécessaires.

Interface de ligne de commande (CLI)

# 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 token valeur comme mot de passe lors de la connexion à votre base de données.

Kit de développement logiciel (SDK) Python

Vous pouvez générer un jeton OAuth à l’aide du Kit de développement logiciel (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}")

Kit de développement logiciel (SDK) Java

Vous pouvez générer un jeton OAuth à l’aide du Kit de développement logiciel (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());

Note

Faire pivoter les jetons OAuth avant l’expiration horaire :

  • Vérifiez l’heure d’expiration du jeton OAuth sur chaque utilisation et actualisez si nécessaire.
  • Vous pouvez également configurer un thread d’arrière-plan pour actualiser régulièrement le jeton OAuth actuel.

Exemples de rotation de jetons

Étant donné que les jetons OAuth expirent après une heure, les applications qui conservent des connexions de base de données longues doivent implémenter la rotation des jetons pour actualiser régulièrement les informations d’identification. Les exemples suivants montrent comment faire pivoter automatiquement des jetons dans votre code d’application.

Note

Conditions requises pour ces exemples :

  • Vous devez être authentifié auprès de l’espace de travail propriétaire du projet. Le WorkspaceClient() utilise les informations d'identification OAuth de votre espace de travail pour générer des jetons de base de données.
  • Votre identité Azure Databricks doit être membre de l’espace de travail où le projet a été créé.
  • Obtenez vos paramètres de connexion (hôte, base de données, point de terminaison) à partir de la boîte de dialogue Se connecter dans l’application Lakebase. Pour plus d’informations, consultez le guide de démarrage rapide .
  • Le endpoint paramètre utilise le format : projects/{project-id}/branches/{branch-id}/endpoints/{endpoint-id}

Pour la configuration de l’authentification de l’espace de travail, consultez Autoriser l’accès utilisateur à Azure Databricks avec OAuth ou Autoriser l’accès au principal de service à Azure Databricks avec OAuth.

Python : psycopg3

Cet exemple utilise le pool de connexions de 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 a toujours 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):
    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

Cet exemple utilise le pool de connexions de SQLAlchemy avec un écouteur d’événements qui actualise automatiquement le jeton OAuth toutes les 15 minutes. L’écouteur d’événements vérifie l’âge du jeton avant la création de chaque nouvelle connexion à partir du pool, ce qui garantit que votre application dispose toujours d’un jeton valide sans intervention manuelle.

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

Authentification par mot de passe Postgres

L’authentification par mot de passe Postgres native utilise des 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 la rotation fréquente des informations d’identification.

Quand utiliser des mots de passe Postgres

Utilisez l’authentification par mot de passe Postgres lorsque :

  • Votre application ou outil ne peut pas actualiser les informations d’identification toutes les heures
  • Vous avez des processus de longue durée qui ont besoin d'identifiants 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 d’espace de travail : l’authentification est gérée par Postgres, et non par l’authentification de l’espace de travail Azure Databricks
  • Gestion manuelle : les mots de passe doivent être pivotés et distribués manuellement aux utilisateurs
  • Les délais d’expiration des connexions 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 7 jours

Considérations relatives à la sécurité

  • Stockage de mot de passe : stocker 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 SSL (sslmode=require)

Étapes suivantes

  • Last updated on