Obtenir manuellement des jetons d’ID Microsoft Entra

Cette page explique comment générer manuellement des jetons d’accès d’ID Microsoft Entra pour les utilisateurs et les principaux de service pour s’authentifier auprès des API REST Azure Databricks. La génération manuelle de jetons est une technique avancée.

Quand utiliser la génération de jetons manuels

Utilisez la génération manuelle de jetons uniquement quand :

• Vous devez intégrer des systèmes qui ne peuvent pas utiliser Azure CLI ou l’authentification unifiée
• Vous avez besoin d’un contrôle explicite sur le cycle de vie des jetons et l’actualisation
• Vous déboguez des problèmes d’authentification

Pour tous les autres cas d’usage, utilisez les méthodes d’authentification recommandées qui gèrent automatiquement la gestion des jetons.

Obtenir des jetons pour les utilisateurs

Utilisez Azure CLI ou la bibliothèque d’authentification Microsoft (MSAL) pour obtenir des jetons d’accès Microsoft Entra ID pour les utilisateurs.

Méthode Azure CLI

1. Obtenez l’ID d’abonnement Azure pour votre compte d’utilisateur :

   • À partir de l’espace de travail Azure Databricks : Cliquez sur votre nom d’utilisateur >Azure Portal>Vue d’ensemble, et recherchez l’ID d’abonnement.

   • Avec Azure CLI : Exécutez la commande suivante (remplacez par l’URL de votre espace de travail) :

     az databricks workspace list --query "[?workspaceUrl==\`adb-0000000000000000.0.azuredatabricks.net\`].{id:id}" -o tsv
     
     # /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/my-rg/providers/Microsoft.Databricks/workspaces/my-ws
     

     L'00000000-0000-0000-0000-000000000000 après /subscriptions/ est votre ID d’abonnement.

     Si vous recevez une erreur liée au compte, connectez-vous au compte approprié :

     az login -t <tenant-id>
     

     Consultez Obtenir des ID d’abonnement et de locataire dans le portail Azure.

2. Connectez-vous à Azure :

   az login
   

3. Définissez l’abonnement approprié :

   az account set -s <subscription-id>
   

4. Générez le jeton d’accès :

   az account get-access-token \
   --resource 2ff814a6-3304-4ab8-85cb-cd0e6f879c1d \
   --query "accessToken" \
   -o tsv
   

   L’ID 2ff814a6-3304-4ab8-85cb-cd0e6f879c1d de ressource est l’identificateur standard d’Azure Databricks dans tous les environnements Azure.

Méthode MSAL

Utilisez la bibliothèque d’authentification Microsoft (MSAL) pour obtenir des jetons d’accès Microsoft Entra ID par programmation. MSAL prend en charge deux flux :

• Flux de code d’autorisation (interactif) : Lance un navigateur pour la connexion de l’utilisateur. Utilisez cette option lorsque l’authentification à deux facteurs ou fédérées est activée, ou lorsque le consentement administrateur est requis.
• Flux nom d’utilisateur-mot de passe (programmatique) : S’authentifie avec un nom d’utilisateur et un mot de passe. Utilisez cette option uniquement lorsque vous avez l’autorité de vous connecter par programmation.

Avant d’utiliser MSAL, vous devez inscrire une application dans l’ID Microsoft Entra. Consultez Inscrire une application à l’aide du portail Azure. Lors de l’inscription :

1. Définissez les types de comptes pris en charge sur les comptes dans cet annuaire organisationnel uniquement (locataire unique).
2. Définissez l’URI de redirection vers le client public/natif (mobile &desktop) avec la valeur http://localhost.
3. Notez l’ID de l'application (client) et l’ID de l'annuaire (locataire) dans la section Vue d’ensemble de l'application.
4. Ajoutez l’autorisation d’API AzureDatabricks :
   1. Accédez aux autorisations> d’APIAjouter une autorisation.
   2. Recherchez et sélectionnez AzureDatabricks.
   3. Activez user_impersonation , puis cliquez sur Ajouter des autorisations.
   4. Cliquez sur Accorder le consentement administrateur (nécessite des privilèges d’administrateur).

Flux du code d’autorisation

Installez le Kit de développement logiciel (SDK) MSAL Python :

pip install msal

Enregistrez le code suivant en tant que get-tokens.py:

from msal import PublicClientApplication
import sys

# Provide client ID and tenant ID as command-line arguments
client_id = sys.argv[1] if len(sys.argv) > 1 else '<client-id>'
tenant_id = sys.argv[2] if len(sys.argv) > 1 else '<tenant-id>'

scopes = ['2ff814a6-3304-4ab8-85cb-cd0e6f879c1d/.default']

app = PublicClientApplication(
  client_id=client_id,
  authority=f"https://login.microsoftonline.com/{tenant_id}"
)

result = app.acquire_token_interactive(scopes=scopes)

if 'error' in result:
  print(f"Error: {result['error']}")
  print(f"Description: {result['error_description']}")
else:
  print(f"Access token:\n{result['access_token']}")
  print(f"\nRefresh token:\n{result['refresh_token']}")

Exécutez le script :

python get-tokens.py <client-id> <tenant-id>

Flux nom d’utilisateur-mot de passe

Enregistrez le code suivant en tant que get-tokens-user.py:

from msal import PublicClientApplication
import sys

client_id = sys.argv[1] if len(sys.argv) > 1 else '<client-id>'
tenant_id = sys.argv[2] if len(sys.argv) > 1 else '<tenant-id>'
username = sys.argv[3] if len(sys.argv) > 1 else '<username>'
password = sys.argv[4] if len(sys.argv) > 1 else '<password>'

scopes = ['2ff814a6-3304-4ab8-85cb-cd0e6f879c1d/.default']

app = PublicClientApplication(
  client_id=client_id,
  authority=f"https://login.microsoftonline.com/{tenant_id}"
)

result = app.acquire_token_by_username_password(
  username=username,
  password=password,
  scopes=scopes
)

if 'error' in result:
  print(f"Error: {result['error']}")
  print(f"Description: {result['error_description']}")
else:
  print(f"Access token:\n{result['access_token']}")
  print(f"\nRefresh token:\n{result['refresh_token']}")

Exécutez le script :

python get-tokens-user.py <client-id> <tenant-id> <username> <password>

Obtenir des jetons pour les principals de service

Les principaux de service utilisent le flux d’informations d’identification du client OAuth 2.0 et peuvent avoir un contrôle d’accès différent des utilisateurs réguliers.

Créer un principal de service

Si vous n’avez pas de principal de service, créez-en un à l’aide du portail Azure ou d’Azure CLI :

Portail Azure

1. Connectez-vous au portail Azure.
2. Basculez vers le tenant approprié en utilisant Répertoires + abonnements si nécessaire.
3. Recherchez et sélectionnez Microsoft Entra ID.
4. Cliquez sur + Ajouter une>inscription d’application.
5. Entrez un nom et sélectionnez Comptes dans cet annuaire organisationnel uniquement (locataire unique).
6. Cliquez sur S'inscrire.
7. Copiez ces valeurs à partir de la page Vue d’ensemble :
   • ID d’application (client)
   • ID de l’annuaire (locataire)
8. Accédez à Certificats et secrets>Secrets client>Nouveau secret client.
9. Ajoutez une description, définissez une période d’expiration, puis cliquez sur Ajouter.
10. Copiez et stockez en toute sécurité le secret client Valeur.

Azure CLI

Pour obtenir des instructions complètes, consultez Créer un principal de service Azure avec Azure CLI .

Générer un jeton

Générez un jeton à l’aide de l’API REST ou d’Azure CLI. Collectez d’abord les informations suivantes :

• ID de locataire :ID d’annuaire (locataire) de Microsoft Entra ID
• ID client :ID d’application (client) de Microsoft Entra ID
• Clé secrète client :Valeur de la clé secrète client à partir de l’ID Microsoft Entra

Méthode d’API REST

curl -X POST -H 'Content-Type: application/x-www-form-urlencoded' \
https://login.microsoftonline.com/<tenant-id>/oauth2/v2.0/token \
-d 'client_id=<client-id>' \
-d 'grant_type=client_credentials' \
-d 'scope=2ff814a6-3304-4ab8-85cb-cd0e6f879c1d%2F.default' \
-d 'client_secret=<client-secret>'

Le jeton d’accès se trouve dans le access_token champ de la réponse.

Méthode Azure CLI

1. Obtenez votre ID d’abonnement Azure. Consultez Obtenir des jetons pour les utilisateurs.

2. Connectez-vous avec votre principal de service :

   az login \
   --service-principal \
   -t <tenant-id> \
   -u <client-id> \
   -p <client-secret>
   

3. Définissez l’abonnement approprié :

   az account set -s <subscription-id>
   

4. Générez le jeton d’accès :

   az account get-access-token \
   --resource 2ff814a6-3304-4ab8-85cb-cd0e6f879c1d \
   --query "accessToken" \
   -o tsv
   

Utiliser des jetons avec des API Databricks

Après avoir généré un jeton, utilisez-le avec l’API REST Databricks.

Principaux de service dans l’espace de travail

Si votre service principal est déjà ajouté à l’espace de travail à l’aide de l’API Service Principals ou du Databricks CLI :

Interface CLI de Databricks

databricks clusters list -p <profile-name-with-token>

friser

curl -X GET \
-H 'Authorization: Bearer <access-token>' \
https://<databricks-instance>/api/2.0/clusters/list

Principaux de service avec rôle Azure

Si votre principal de service a le rôle Contributor ou Owner sur la ressource d’espace de travail dans Azure, mais n’est pas encore dans l’espace de travail Azure Databricks :

1. Obtenez un jeton de gestion pour Azure Resource Manager :

   curl -X POST -H 'Content-Type: application/x-www-form-urlencoded' \
   https://login.microsoftonline.com/<tenant-id>/oauth2/token \
   -d 'client_id=<client-id>' \
   -d 'grant_type=client_credentials' \
   -d 'resource=https%3A%2F%2Fmanagement.core.windows.net%2F' \
   -d 'client_secret=<client-secret>'
   

2. Appelez l’API Databricks avec les deux jetons :

   curl -X GET \
   -H 'Authorization: Bearer <databricks-access-token>' \
   -H 'X-Databricks-Azure-SP-Management-Token: <management-access-token>' \
   -H 'X-Databricks-Azure-Workspace-Resource-Id: /subscriptions/<subscription-id>/resourceGroups/<resource-group-name>/providers/Microsoft.Databricks/workspaces/<workspace-name>' \
   https://<databricks-instance>/api/2.0/clusters/list
   

Après la première authentification, le principal de service devient un administrateur d’espace de travail.

Jetons d’actualisation

Si vous avez obtenu un jeton d’actualisation avec votre jeton d’accès, utilisez-le pour obtenir un nouveau jeton. Les jetons d’accès d’ID Microsoft Entra expirent après 60 à 90 minutes par défaut.

Enregistrez le code suivant en tant que refresh-tokens.py:

from msal import PublicClientApplication
import sys

client_id = sys.argv[1] if len(sys.argv) > 1 else '<client-id>'
tenant_id = sys.argv[2] if len(sys.argv) > 1 else '<tenant-id>'
refresh_token = sys.argv[3] if len(sys.argv) > 1 else '<refresh-token>'

scopes = ['2ff814a6-3304-4ab8-85cb-cd0e6f879c1d/.default']

app = PublicClientApplication(
  client_id=client_id,
  authority=f"https://login.microsoftonline.com/{tenant_id}"
)

result = app.acquire_token_by_refresh_token(
  refresh_token=refresh_token,
  scopes=scopes
)

if 'error' in result:
  print(f"Error: {result['error']}")
  print(f"Description: {result['error_description']}")
else:
  print(f"\nNew access token:\n{result['access_token']}")
  print(f"\nNew refresh token:\n{result['refresh_token']}")

Exécutez le script :

python refresh-tokens.py <client-id> <tenant-id> <refresh-token>

Résoudre les problèmes de jeton

Cette section décrit les erreurs de jeton courantes et comment valider les jetons d’accès.

Échec de l’obtention du jeton avec nom d’utilisateur et mot de passe

The user or administrator has not consented to use the application with ID <client-id>.
Send an interactive authorization request for this user and resource.

Solution: Vérifiez que la ressource AzureDatabricks est ajoutée à votre application. Utilisez le flux de code d’autorisation (méthode interactive) pour consentir aux autorisations. Après avoir consenti, vous pouvez utiliser le flux nom d’utilisateur-mot de passe. Consultez Obtenir des jetons pour les utilisateurs.

Les URI de redirection ne correspondent pas

The reply URL specified in the request does not match the reply URLs configured for the application: '<application-id>'

Solution: Vérifiez que l’URI de redirection dans votre requête correspond à celui configuré dans l’application.

Valider un jeton d’accès

Assurez-vous que votre jeton d’accès Microsoft Entra ID inclut les informations appropriées. Consultez valider les jetons.

• aud : 2ff814a6-3304-4ab8-85cb-cd0e6f879c1d (ID de ressource Databricks)
• iss : https://sts.windows.net/<tenant-id>/
• tid : ID de locataire de l’espace de travail
• nbf/exp : l’heure actuelle se situe entre ces valeurs
• unique_name : l’utilisateur existe dans l’espace de travail

Validez la signature à l’aide de certificats publics à partir des points de terminaison OIDC.

Décoder sans vérification de signature :

Le code suivant montre la charge utile du jeton. Vous devez d'abord installer la bibliothèque PyJWT en utilisant pip install pyjwt et la bibliothèque de cryptographie en utilisant pip install cryptography.

import jwt

def decode_token(token):
  algorithm = jwt.get_unverified_header(token)['alg']
  decoded = jwt.decode(token, algorithms=[algorithm], options={"verify_signature": False})
  for key in decoded.keys():
    print(f"{key}: {str(decoded[key])}")

Décoder avec la vérification de signature :

import jwt
import requests
from cryptography.x509 import load_pem_x509_certificate
from cryptography.hazmat.backends import default_backend

PEMSTART = '-----BEGIN CERTIFICATE-----\n'
PEMEND = '\n-----END CERTIFICATE-----\n'

def get_public_key_for_token(kid):
  response = requests.get('https://login.microsoftonline.com/common/.well-known/openid-configuration').json()
  pubkeys = requests.get(response['jwks_uri']).json()['keys']

  for key in pubkeys:
    if key['kid'] == kid:
      cert_str = PEMSTART + str(key['x5c'][0]) + PEMEND
      cert_obj = load_pem_x509_certificate(bytes(cert_str, 'ascii'), default_backend())
      return cert_obj.public_key()

def aad_access_token_decoder(access_token):
  header = jwt.get_unverified_header(access_token)
  public_key = get_public_key_for_token(header['kid'])
  decoded = jwt.decode(access_token, key=public_key, algorithms='RS256',
                      audience='2ff814a6-3304-4ab8-85cb-cd0e6f879c1d')
  for key in decoded.keys():
    print(f"{key}: {str(decoded[key])}")

Utilisez des décodeurs JWT en ligne comme jwt.ms ou jwt.io pour les jetons non sensibles.