Integrare OneLake con Azure Databricks

Questo articolo illustra come accedere ai dati OneLake da Azure Databricks. Entrambi gli approcci usano l'autenticazione dell'entità servizio e l'endpoint ABFS di OneLake. Scegliere la sezione corrispondente al tipo di calcolo di Databricks:

• Cluster standard o di lavoro: usare il driver Spark ABFS con la configurazione OAuth per leggere e scrivere dati direttamente tramite il DataFrame Spark.
• Calcolo serverless: i runtime serverless non consentono di impostare proprietà di configurazione Spark personalizzate. Usare invece il Libreria di Autenticazione Microsoft (MSAL) e la libreria Python deltalake per autenticare e leggere o scrivere tabelle Delta.

Per gli scenari di integrazione di Databricks correlati, vedere le risorse seguenti:

Prerequisiti

Prima di connettersi, assicurarsi di avere:

• Un'area di lavoro e un lakehouse di Fabric.
• Un’area di lavoro Premium di Azure Databricks.
• Un principale del servizio con almeno l'assegnazione del ruolo del workspace Collaboratore.
• Segreti di Databricks o Azure Key Vault (AKV) per archiviare e recuperare i segreti. Gli esempi in questo articolo usano i segreti di Databricks.

Connettersi a OneLake con un cluster standard

Usare il formato corretto del percorso ABFS di OneLake

Usare uno dei formati URI seguenti:

• 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>

È possibile usare ID o nomi. Se si usano nomi, evitare caratteri speciali e spazi vuoti nei nomi di area di lavoro e lakehouse.

Usare l'autenticazione basata su entità servizio

Usare questa opzione per i processi automatizzati e la rotazione centralizzata dei segreti di accesso.

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

Connetti a OneLake con elaborazione serverless

Databricks serverless compute consente di eseguire carichi di lavoro senza effettuare il provisioning di un cluster, ma consente solo un subset di proprietà Spark supportate. Non è possibile impostare la fs.azure.* configurazione spark usata nei cluster standard.

Se si tenta di impostare una configurazione Spark non supportata in un notebook serverless, il sistema restituisce un errore CONFIG_NOT_AVAILABLE.

Usare invece MSAL per acquisire un token OAuth e la libreria Python deltalake per leggere o scrivere tabelle Delta con tale token.

Configurare un notebook serverless

1. Crea un notebook nell'area di lavoro di Databricks e collegalo al calcolo serverless.

   

2. Importare Python moduli. In questo esempio usare due moduli:

   • msal esegue l'autenticazione con il Microsoft Identity Platform.
   • deltalake legge e scrive tabelle Delta Lake con Python.

   from msal import ConfidentialClientApplication
   from deltalake import DeltaTable, write_deltalake
   

3. Dichiarare le variabili per il tenant di Microsoft Entra, compreso l'ID applicazione. Usare l'ID tenant del tenant in cui viene distribuito Microsoft Fabric.

   # 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. Dichiarare le variabili dell'area di lavoro 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. Inizializzare il client per ottenere un token.

   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. Leggere una tabella Delta da OneLake.

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

7. Scrivere una tabella Delta in 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"}
   )
   

Considerazioni relative alla progettazione

• Usare un modello di scrittura per ogni percorso di tabella, dove possibile. La scrittura negli stessi percorsi di archiviazione da più motori di calcolo o versioni di runtime può causare conflitti.
• Usare la gestione dei segreti per le credenziali del principale di servizio.
• Usare i tasti di scelta rapida OneLake quando è necessario l'accesso virtualizzato invece di scrivere fisicamente i dati in un'altra posizione lakehouse.

Contenuti correlati

• Usare OneLake con Azure Databricks
• Mounting cloud object storage on Azure Databricks