Intégrer OneLake à Azure Databricks

Cet article explique comment accéder aux données OneLake à partir de Azure Databricks. Les deux approches utilisent l’authentification du service principal et l'endpoint ABFS OneLake. Choisissez la section qui correspond à votre type de calcul Databricks :

• Cluster standard ou de travail : utilisez le pilote Spark ABFS avec la configuration OAuth pour lire et écrire des données directement via des DataFrames Spark.
• Calcul serverless : les runtimes serverless ne vous permettent pas de définir des propriétés de configuration Spark personnalisées. Utilisez plutôt la bibliothèque Microsoft Authentication Library (MSAL) et la bibliothèque Python deltalake pour authentifier et lire ou écrire des tables Delta.

Pour connaître les scénarios d’intégration Databricks associés, consultez les ressources suivantes :

Prerequisites

Avant de vous connecter, vérifiez que vous avez ce qui suit :

• Espace de travail Fabric et lakehouse.
• Un espace de travail Azure Databricks premium.
• Un principal de service avec au moins l’attribution du rôle de Contributeur sur l'espace de travail.
• Utilisez Databricks Secrets ou Azure Key Vault (AKV) pour stocker et récupérer des secrets. Les exemples de cet article utilisent des secrets Databricks.

Se connecter à OneLake avec un cluster standard

Utiliser le format de chemin d’accès OneLake ABFS correct

Utilisez l’un des formats d’URI suivants :

• abfss://<workspace_id_or_name>@onelake.dfs.fabric.microsoft.com/<lakehouse_id_or_name>.lakehouse/Files/<path>
• abfss://<workspace_id_or_name>@onelake.dfs.fabric.microsoft.com/<lakehouse_id_or_name>.lakehouse/Tables/<path>

Vous pouvez utiliser des ID ou des noms. Si vous utilisez des noms, évitez les caractères spéciaux et les espaces blancs dans les noms d’espace de travail et de lakehouse.

Utiliser une authentification de principal de service

Utilisez cette option pour les travaux automatisés et la rotation centralisée des secrets.

workspace_name = "<workspace_name>"
lakehouse_name = "<lakehouse_name>"
tenant_id = dbutils.secrets.get(scope="<scope-name>", key="<tenant-id-key>")
service_principal_id = dbutils.secrets.get(scope="<scope-name>", key="<client-id-key>")
service_principal_secret = dbutils.secrets.get(scope="<scope-name>", key="<client-secret-key>")

spark.conf.set("fs.azure.account.auth.type", "OAuth")
spark.conf.set(
   "fs.azure.account.oauth.provider.type",
   "org.apache.hadoop.fs.azurebfs.oauth2.ClientCredsTokenProvider",
)
spark.conf.set("fs.azure.account.oauth2.client.id", service_principal_id)
spark.conf.set("fs.azure.account.oauth2.client.secret", service_principal_secret)
spark.conf.set(
   "fs.azure.account.oauth2.client.endpoint",
   f"https://login.microsoftonline.com/{tenant_id}/oauth2/token",
)

# Read
df = spark.read.format("parquet").load(
   f"abfss://{workspace_name}@onelake.dfs.fabric.microsoft.com/{lakehouse_name}.lakehouse/Files/data"
)
df.show(10)

# Write
df.write.format("delta").mode("overwrite").save(
   f"abfss://{workspace_name}@onelake.dfs.fabric.microsoft.com/{lakehouse_name}.lakehouse/Tables/dbx_delta_spn"
)

Se connecter à OneLake avec le calcul sans serveur

Le calcul serverless Databricks vous permet d’exécuter des charges de travail sans provisionner un cluster, mais il autorise uniquement un sous-ensemble de propriétés Spark prises en charge. Vous ne pouvez pas définir la fs.azure.* configuration Spark utilisée sur les clusters standard.

Si vous tentez de définir une configuration Spark non prise en charge dans un notebook serverless, le système retourne une erreur CONFIG_NOT_AVAILABLE.

Utilisez plutôt MSAL pour acquérir un jeton OAuth et la bibliothèque Python deltalake pour lire ou écrire des tables Delta avec ce jeton.

Configurer un notebook serverless

1. Créez un notebook dans votre espace de travail Databricks et connectez-le au calcul sans serveur.

   

2. Importez des modules Python. Dans cet exemple, utilisez deux modules :

   • msal s’authentifie auprès du Plateforme d'identités Microsoft.
   • deltalake lit et écrit des tables Delta Lake avec Python.

   from msal import ConfidentialClientApplication
   from deltalake import DeltaTable, write_deltalake
   

3. Déclarez des variables pour le locataire Microsoft Entra, y compris l'ID d’application. Utilisez l’ID de locataire du locataire dans lequel Microsoft Fabric est déployé.

   # Fetch from Databricks secrets.
   tenant_id = dbutils.secrets.get(scope="<replace-scope-name>",key="<replace value with key value for tenant_id>")
   client_id = dbutils.secrets.get(scope="<replace-scope-name>",key="<replace value with key value for client_id>")
   client_secret = dbutils.secrets.get(scope="<replace-scope-name>",key="<replace value with key value for secret>")
   

4. Déclarez les variables d’espace de travail Fabric.

   workspace_id = "<replace with workspace name>"
   lakehouse_id = "<replace with lakehouse name>"
   table_to_read = "<name of lakehouse table to read>"
   onelake_uri = f"abfss://{workspace_id}@onelake.dfs.fabric.microsoft.com/{lakehouse_id}.lakehouse/Tables/{table_to_read}"
   

5. Initialisez le client logiciel pour acquérir un jeton.

   authority = f"https://login.microsoftonline.com/{tenant_id}"
   
   app = ConfidentialClientApplication(
       client_id,
       authority=authority,
       client_credential=client_secret
   )
   
   result = app.acquire_token_for_client(scopes=["https://onelake.fabric.microsoft.com/.default"])
   
   if "access_token" in result:
       print("Access token acquired.")
       token_val = result['access_token']
   else:
       raise Exception(f"Failed to acquire token: {result.get('error_description', result)}")
   

6. Lire une table Delta à partir de OneLake.

   dt = DeltaTable(onelake_uri, storage_options={"bearer_token": f"{token_val}", "use_fabric_endpoint": "true"})
   df = dt.to_pandas()
   print(df.head())
   

7. Écrivez une table Delta dans OneLake.

   target_uri = f"abfss://{workspace_id}@onelake.dfs.fabric.microsoft.com/{lakehouse_id}.lakehouse/Tables/<target_table_name>"
   write_deltalake(
       target_uri,
       df,
       mode="overwrite",
       storage_options={"bearer_token": f"{token_val}", "use_fabric_endpoint": "true"}
   )
   

Considérations relatives à la conception

• Utilisez un modèle de rédacteur par chemin d’accès de table, si possible. L’écriture dans les mêmes chemins de stockage à partir de plusieurs moteurs de calcul ou versions du runtime peut entraîner des conflits.
• Utilisez la gestion des secrets pour les informations d’identification du principal de service.
• Utilisez les raccourcis OneLake lorsque vous avez besoin d’un accès virtualisé plutôt que d’écrire physiquement des données dans un autre emplacement lakehouse.

Contenu connexe

• Utilisez OneLake avec Azure Databricks
• Montage du stockage d'objets cloud sur Azure Databricks