Aller au contenu principal
Dernière mise à jour le

Authentifiez-vous à l’aide d’un jeton du fournisseur d’identité

Cette page explique comment s'authentifier auprès de Databricks à l'aide d'un jeton émis par le fournisseur d'identité de votre organisation.

Databricks prend en charge l'échange de jetons OAuth 2.0 pour vous permettre d'échanger un jeton d'identité fédérée contre un jeton OAuth Databricks. Avec la fédération de jetons, le CLI Databricks, les SDK et d'autres outils peuvent gérer automatiquement cet échange et gérer les jetons d'accès pour vous.

La durée de vie de chaque jeton d'accès est dérivée de la durée de vie du jeton fédéré que vous fournissez, qui est le plus souvent d'une heure mais peut varier. Les outils refresh les jetons automatiquement selon les besoins, vous n'avez donc pas besoin de demander ou de faire pivoter manuellement les identifiants.

Processus d'authentification​

Pour authentifier l’accès à l’API Databricks avec un jeton d’un fournisseur d’identité fédéré, définissez d’abord les variables d’environnement ou les champs de configuration requis. Votre outil préféré ou votre SDK récupère le jeton web JSON (JWT) fédéré à partir de l’emplacement que vous spécifiez, l’échange contre un jeton OAuth Databricks et utilise le jeton OAuth pour authentifier les appels de l’API REST Databricks.

Prérequis​

Avant de commencer, suivez les étapes suivantes :

  1. Créez une politique de fédération pour votre compte ou votre service principal.
  2. Obtenez un JWT valide auprès de votre fournisseur d'identité qui correspond à la politique. Les jetons doivent être signés à l'aide de RS256 ou ES256. Les étapes varient selon le fournisseur, donc consultez la documentation de votre fournisseur ou demandez à un administrateur.

Configurez votre environnement​

Configurez votre environnement en fonction de l'origine de votre jeton fédéré. Définissez les variables d'environnement, les champs .databrickscfg, les champs Terraform ou les champs Config suivants :

  • Hôte Databricks : https://accounts.cloud.databricks.com pour les opérations de compte ou l'URL du workspace cible, par exemple https://dbc-a1b2345c-d6e7.cloud.databricks.com pour les opérations de workspace.
  • ID de compte Databricks : requis uniquement si l'hôte est l'URL de la console de compte.
  • ID client du Service Principal : Requis uniquement pour la fédération d'identité de charge de travail. Ne doit pas être défini si l'authentification est effectuée à l'aide d'une politique de fédération de jetons à l'échelle du compte.
  • Type d'authentification Databricks : env-oidc si le jeton provient d'une variable d'environnement. file-oidc si le jeton provient d'un fichier.
  • Variable d'environnement du jeton OIDC : Le nom de la variable d'environnement qui contient le jeton. Requis uniquement si la méthode d'authentification est env-oidc. Par default, la valeur est DATABRICKS_OIDC_TOKEN.
  • **Chemin du fichier du jeton OIDC :** Chemin du fichier qui contient le jeton fédéré. Requis uniquement si la méthode d'authentification est file-oidc.

Pour une référence complète de toutes les variables d’environnement et de tous les champs de configuration d’authentification unifiée, consultez Variables d’environnement et champs pour l’authentification unifiée.

Choisissez votre méthode de configuration préférée pour configurer l'environnement d'authentification :

Définissez les variables d'environnement suivantes :

Bash
export DATABRICKS_HOST=<workspace-url-or-account-console-url>
export DATABRICKS_ACCOUNT_ID=<account-id>  # If DATABRICKS_HOST is the account console URL
export DATABRICKS_CLIENT_ID=<client-id>    # Only for workload identity federation
export DATABRICKS_AUTH_TYPE=<auth-method> # env-oidc or file-oidc
export DATABRICKS_OIDC_TOKEN_ENV=<token-env-name>  # If auth type is env-oidc
export DATABRICKS_OIDC_TOKEN_FILEPATH=<token-filepath-name> # If auth type is file-oidc

Accéder aux APIs Databricks​

Après avoir configuré votre environnement, vous pouvez utiliser la CLI Databricks et les SDK normalement. Ils gèrent automatiquement l'échange de jetons et utilisent le jeton OAuth résultant pour l'authentification de l'API.

Bash
databricks clusters list

Implémenter un fournisseur d'autorisation personnalisé​

Si votre jeton fédéré provient d'une source autre que des variables d'environnement ou un fichier, vous pouvez utiliser l'un des SDK Databricks pour écrire une implémentation personnalisée afin de récupérer votre jeton fédéré.

Charges de travail AWS IAM (Python)​

L'exemple suivant utilise le modèle IdTokenSource avec AWS STS GetWebIdentityToken pour authentifier les charges de travail AWS auprès de Databricks :

Python
import boto3
from databricks.sdk import WorkspaceClient
from databricks.sdk import oidc
from databricks.sdk.core import Config, credentials_strategy, oidc_credentials_provider


class AwsStsTokenSource(oidc.IdTokenSource):
    def __init__(self, audience="databricks", region="us-east-1"):
        self._audience = audience
        self._region = region

    def id_token(self) -> oidc.IdToken:
        sts = boto3.client("sts", region_name=self._region)
        resp = sts.get_web_identity_token(
            Audience=[self._audience],
            SigningAlgorithm="RS256",
            DurationSeconds=300,
        )
        return oidc.IdToken(jwt=resp["WebIdentityToken"])


@credentials_strategy("aws-sts-wif", [])
def aws_sts_wif_strategy(cfg: Config):
    return oidc_credentials_provider(cfg, AwsStsTokenSource())


w = WorkspaceClient(
    host="https://my-workspace.cloud.databricks.com",
    client_id="<service-principal-uuid>",
    credentials_strategy=aws_sts_wif_strategy
)
# No secrets needed
clusters = w.clusters.list()
remarque

La durée des jetons de 300 secondes est recommandée. Vous pouvez ajuster jusqu'à 3 600 secondes en fonction des besoins de la charge de travail.

L'exemple suivant montre l'échange de jetons bruts pour comprendre le protocole :

Python
import boto3
import requests

sts = boto3.client("sts", region_name="us-east-1")
resp = sts.get_web_identity_token(
    Audience=["databricks"],
    SigningAlgorithm="RS256",
    DurationSeconds=300,
)
aws_jwt = resp["WebIdentityToken"]

token_resp = requests.post(
    "https://<workspace>.cloud.databricks.com/oidc/v1/token",
    data={
        &quot;client_id&quot;: &quot;&lt;service-principal-uuid&gt;&quot;,
        &quot;grant_type&quot;: &quot;urn:ietf:params:oauth:grant-type:token-exchange&quot;,
        &quot;subject_token&quot;: aws_jwt,
        &quot;subject_token_type&quot;: &quot;urn:ietf:params:oauth:token-type:jwt&quot;,
        &quot;scope&quot;: &quot;all-apis&quot;,
    },
)
access_token = token_resp.json()["access_token"]

Pour la configuration complète incluant les prérequis AWS et la création de la politique de fédération, consultez Activer la fédération d'identité des charges de travail pour les charges de travail AWS IAM.

Implémentation personnalisée générique​

Python
from databricks.sdk import oidc
from databricks.sdk.core import (Config, CredentialsProvider, credentials_strategy, oidc_credentials_provider)


class MyCustomIdTokenSource(oidc.IdTokenSource):
    def id_token(self) -> oidc.IdToken:
        token = ...  # Implement logic to return the ID token here
        return oidc.IdToken(jwt=token)


@credentials_strategy("my-custom-oidc", [])
def my_custom_oidc_strategy(cfg: Config) -> CredentialsProvider:
    return oidc_credentials_provider(cfg, MyCustomIdTokenSource())


if __name__ == "__main__":
    cfg = Config(
        host="https://my-workspace.cloud.databricks.com",
        credentials_strategy=my_custom_oidc_strategy
    )
    from databricks.sdk import WorkspaceClient
    w = WorkspaceClient(config=cfg)
    # Use the client...

Échanger un jeton manuellement​

Si vous n'utilisez pas les SDK Databricks, l'interface CLI ou d'autres outils qui prennent en charge l'authentification unifiée, vous pouvez échanger manuellement un JWT de votre fournisseur d'identité contre un jeton OAuth Databricks. Pour ce faire, envoyez une requête au Databricks Endpoint en utilisant l'échange de jetons OAuth 2.0 (RFC 8693).

Commencez par obtenir un JWT fédéré auprès de votre fournisseur d'identité en suivant sa documentation. Ensuite, échangez le JWT contre un jeton OAuth Databricks et utilisez ce jeton pour accéder aux APIs REST Databricks :

Flux de fédération de jetons OAuth

Échanger un JWT fédéré contre un jeton OAuth Databricks​

Pour les politiques de fédération à l'échelle du compte, cette commande échange un JWT fédéré contre un jeton OAuth Databricks :

Bash
curl --request POST https://<databricks-workspace-host>/oidc/v1/token \
  --data "subject_token=${FEDERATED_JWT_TOKEN}" \
  --data 'subject_token_type=urn:ietf:params:oauth:token-type:jwt' \
  --data 'grant_type=urn:ietf:params:oauth:grant-type:token-exchange' \
  --data 'scope=all-apis'
astuce

Pour accéder aux Ressources du compte Databricks, utilisez l'URL https://<databricks-account-host>/oidc/accounts/<account-id>/v1/token.

Pour les politiques de fédération de Service Principal, incluez l'ID client dans la requête :

Bash
curl --request POST https://<databricks-workspace-host>/oidc/v1/token \
  --data "client_id=${CLIENT_ID}" \
  --data "subject_token=${FEDERATED_JWT_TOKEN}" \
  --data 'subject_token_type=urn:ietf:params:oauth:token-type:jwt' \
  --data 'grant_type=urn:ietf:params:oauth:grant-type:token-exchange' \
  --data 'scope=all-apis'

Remplacez CLIENT_ID par l'UUID du Service Principal (par exemple, 7cb2f8a4-49a7-4147-83db-35cb69e5cede).

Si le jeton de votre fournisseur d'identité est valide et correspond à votre politique de fédération, vous recevez une réponse JSON standard qui inclut un jeton OAuth Databricks dans le champ access_token. Ce jeton OAuth peut être utilisé pour accéder aux APIs Databricks. Le jeton OAuth Databricks obtenu a la même revendication d'expiration (exp) que le JWT fourni dans le parameter subject_token.

Exemple de réponse :

JSON
{
  "access_token": "eyJraWQ...odi0WFNqQw",
  "scope": "all-apis",
  "token_type": "Bearer",
  "expires_in": 3600
}

Utilisez le jeton OAuth pour appeler les API Databricks​

Vous pouvez ensuite utiliser le jeton OAuth Databricks résultant comme jeton de porteur pour accéder aux APIs Databricks. Par exemple, pour appeler l'API Databricks SCIM Me afin de récupérer votre utilisateur Databricks et votre nom d'affichage :

Bash
TOKEN='<your-databricks-oauth-token>'

curl --header "Authorization: Bearer $TOKEN" \
  --url https://${DATABRICKS_WORKSPACE_HOSTNAME}/api/2.0/preview/scim/v2/Me

La réponse doit ressembler à ce qui suit :

JSON
{
  "userName": "username@mycompany.com",
  "displayName": "Firstname Lastname"
}
Sur cette page