Intégrer OneLake à Azure Machine Learning

OneLake est la couche de stockage à lacs ouverts de Fabric avec un accès compatible stockage Azure. Il expose les données Fabric via onelake.dfs.fabric.microsoft.com pour l’accès à ADLS Gen2/DFS et onelake.blob.fabric.microsoft.com pour l’accès à l’API Blob. Cet article explique comment Azure Machine Learning peut utiliser ces interfaces via des magasins de données Azure Machine Learning, des entrées et sorties des points de terminaison de traitement par lots, et un accès direct abfss:// à partir de carnets de notes ou de scripts.

Azure Machine Learning fournit trois points d’intégration principaux avec OneLake :

Magasins de données - enregistrez un emplacement Fabric Lakehouse Files en tant que magasin de données Azure Machine Learning et référencez-le depuis des travaux et des ressources de données. Azure Machine Learning prend également en charge le lien direct vers Fabric tables Lakehouse, mais ce modèle implique une copie vers ADLS Gen2 et n'est pas abordé dans ce document.
Points de terminaison de traitement par lot - invoquez des déploiements de traitement par lot avec des entrées et des sorties stockées dans OneLake (aujourd’hui via un magasin de données enregistré ou via un magasin de données Blob/ADLS adossé à un raccourci).
API OneLake / accès ABFSS direct - lire et écrire dans OneLake directement à partir de notebooks et de scripts s’exécutant sur des environnements d’exécution d’Azure Machine Learning.

Point d’intégration dans Azure Machine Learning	surface de OneLake	surface de Azure Machine Learning	Les données sont-elles copiées dans ADLS Gen2 ?	URI principal à utiliser dans Azure Machine Learning
Magasin de données OneLake	section Lakehouse `/Files`.	CLI / SDK (YAML)	No	`azureml://datastores/<name>/paths/<path>`
Table lakehouse OneLake (liée à l’interface utilisateur)	section Lakehouse `/Tables`.	Azure Machine Learning studio (interface utilisateur)	Oui : copié via Fabric pipeline vers ADLS Gen2, puis inscrit	`azureml://datastores/<adls_ds>/paths/<path>`
Entrée/sortie du point de terminaison Batch	Lakehouse `/Files` (via le raccourci ADLS).	CLI / SDK / REST	Optional	`azureml://datastores/<name>/paths/<path>` ou `abfss://...`
API directe OneLake / ABFSS	`/Files` et `/Tables`	Notebooks / scripts sur Azure Machine Learning calcul	No	`abfss://<workspace>@onelake.dfs.fabric.microsoft.com/<lakehouse>.Lakehouse/Files/...`

Note

azureml://est un schéma d’URI spécifique à Azure Machine Learning, et non un protocole de stockage. Le plan de contrôle et le runtime de données d’Azure Machine Learning l’utilisent pour déterminer l’emplacement du stockage sous-jacent (Blob, ADLS Gen2, OneLake, entre autres) à l’aide des métadonnées de connexion et des informations d’identification enregistrées dans le magasin de données nommé.

OneLake en tant que magasin de données Azure Machine Learning

Un magasin de données est une abstraction Azure Machine Learning étendue à l’espace de travail sur un emplacement de stockage externe (OneLake, Azure Blob, ADLS Gen2, Azure Files). Il stocke les métadonnées de connexion pour une ressource de stockage existante, le point de terminaison, le conteneur/le système de fichiers/élément et les informations d’identification ou la configuration d’identité, sans provisionner ni copier les données elles-mêmes. Diverses expériences au sein de Azure Machine Learning peuvent référencer des magasins de données à l’aide d’un URI stable (azureml://datastores/<name>/paths/<path>).

Note

Azure Machine Learning studio ne répertorie pas actuellement OneLake comme type de magasin de données dans l'interface utilisateur, mais l'interface CLI et le SDK prennent en charge la création et la gestion des magasins de données OneLake via la définition YAML.

Métadonnées de connexion requises à partir de Microsoft Fabric

À partir de la page Propriétés de l’élément lakehouse dans Fabric, capturez :

Point de terminaison : Pour OneLake, utilisez onelake.dfs.fabric.microsoft.com ou onelake.blob.fabric.microsoft.com selon le protocole que vous souhaitez utiliser.
GUID de l’espace de travail
GUID de l’élément (le GUID du lakehouse)

Créer le magasin de données dans Azure Machine Learning

onelake-datastore.yml :

$schema: https://azuremlschemas.azureedge.net/latest/oneLakeDatastore.schema.json
name: <name_of_datastore>
type: onelake
description: Datastore pointing to a Microsoft Fabric lakehouse.
onelake_workspace_name: <workspace_guid>
endpoint: onelake.dfs.fabric.microsoft.com
artifact:
  type: lakehouse
  name: <item_guid>/Files   # Include /Files in the name to point at the lakehouse Files layer; omit it to point at the root of the item.

À l’aide de Azure CLI, créez le magasin de données dans l’espace de travail Azure Machine Learning cible. Remplacez les espaces réservés <name_of_AML_workspace> et <name_of_datastore> par les valeurs appropriées.

az ml datastore create --file ./onelake-datastore.yml \
    --resource-group rg-amlonelake \
    --workspace-name <name_of_AML_workspace>

Utiliser un magasin de données dans des travaux Azure Machine Learning

Une fois qu’un magasin de données Azure Machine Learning est inscrit, son azureml:// URI est disponible pour une utilisation via différentes expériences. L’exemple montre ici comment référencer un magasin de données OneLake dans un travail Azure Machine Learning. L’URI suivant est valide dans un travail Input/Output, dans les définitions de ressources de données et partout où Azure Machine Learning accepte un chemin de magasin de données, à l’exception des points de terminaison par lots, qui ne prennent actuellement pas en charge OneLake comme type de magasin de données en entrée ou en sortie.

L’exemple de travail suivant copie un fichier d’un emplacement vers un autre dans le même magasin de données OneLake. Vous pouvez utiliser une combinaison de différentes cibles de stockage prises en charge (Blob, ADLS Gen2, OneLake) comme entrées et sorties dans le même travail.

type: command
command: cp ${{inputs.input_data}} ${{outputs.output_data}}
compute: azureml:<replace_with_aml_compute_target>
environment: azureml://registries/azureml/environments/sklearn-1.1/versions/4
inputs:
  input_data:
    mode: ro_mount
    path: azureml://datastores/<name_of_datastore>/paths/<folder-path>/<file-name> # Do not include /Files in the <file-name> portion of the path. Reason being that the datastore is already pointed at the /Files layer of the lakehouse via the artifact name in the datastore definition.
    type: uri_file
outputs:
  output_data:
    mode: rw_mount
    path: azureml://datastores/<name_of_datastore>/paths/<folder-path>/<file-name> # Do not include /Files in the <file-name> portion of the path. Reason being that the datastore is already pointed at the /Files layer of the lakehouse via the artifact name in the datastore definition.
    type: uri_file
    # optional: if you want to create a data asset from the output, 
    # then uncomment `name` (`name` can be set without setting `version`, and in this way, we will set `version` automatically for you)
    # name: <name_of_data_asset> # use `name` and `version` to create a data asset from the output
    # version: <version_of_data_asset>

Azure Machine Learning expériences qui peuvent référencer directement un magasin de données OneLake

#	surface / interface d’Azure Machine Learning	Direction	Adressage de OneLake	Source
1	travaux Azure Machine Learning - `Input` / `Output` (CLI v2, SDK v2 `command`, `pipeline`, ) `sweep`	R / W	`azureml://datastores/<onelake_ds>/paths/...`	Accéder aux données dans un travail
2	Ressources de données (`uri_file`, `uri_folder`) inscrites sur un chemin de magasin de données OneLake	R (les ressources sont des références en lecture seule)	`azureml://datastores/<onelake_ds>/paths/...` encapsulé avec contrôle de version	Créer des éléments de données
3	Runtime de données Azure Machine Learning via `azureml-fsspec` dans des notebooks/scripts sur les ressources de calcul Azure Machine Learning	R / W	`azureml://datastores/<onelake_ds>/paths/...` ouvert avec `fsspec.open(...)` ou `AzureMachineLearningFileSystem`	Accéder aux données à partir de OneLake pendant le développement interactif

OneLake avec des points de terminaison par lots

Azure Machine Learning vous permet d’utiliser Fabric pour accéder aux points de terminaison de traitement par lot pour le déploiement de modèles pour une inférence asynchrone de longue durée avec des modèles et des pipelines d’apprentissage automatique.

Dans ce modèle, l’objectif architectural est de conserver une copie physique unique des données des fonctionnalités d’entrée et des prédictions de sortie accessibles aux deux plateformes - Fabric et Azure Machine Learning. Un fichier dans ADLS possède deux adresses valides : un azureml://datastores/... URI que les points de terminaison de traitement par lots d’Azure Machine Learning acceptent en entrée et en sortie, ainsi qu’un chemin d’accès lakehouse (activé via un raccourci ADLS) que les notebooks, pipelines et points de terminaison SQL Analytics de Fabric peuvent interroger. Ce modèle n’implique aucune copie, aucune synchronisation planifiée, aucune deuxième source de vérité. La vue du lakehouse et la vue d’Azure Machine Learning sont des projections du même compte de stockage.

Les points de terminaison Batch se trouvent entre deux dossiers OneLake visibles :

Entrées - un emplacement structuré /Files (zone d’atterrissage brute, requêtes évaluées, partitions quotidiennes) préparé par l’ingénierie des données Fabric. Azure Machine Learning la lit via un magasin de données ADLS Gen2 pointant vers le même espace de stockage que le raccourci.
Sorties - un emplacement des prédictions /Files écrit par le traitement par lots dans le même compte ADLS Gen2, qui apparaît dans le lakehouse via un raccourci et est immédiatement disponible pour les notebooks Fabric, les flux de données ou une étape de chargement dans une table Delta.

Plus largement, ce modèle est adapté aux scénarios où vous avez déjà des données atterries dans ADLS Gen2. Par exemple, un lac de données existant alimentant des charges de travail d’analytique ou de machine learning. Au lieu de migrer ou de dupliquer ces données vers OneLake, un raccourci OneLake fait apparaître l’emplacement ADLS existant à l’intérieur d’une Fabric lakehouse, tandis que le même compte reste inscrit en tant que magasin de données.

Accès au kit de développement logiciel (SDK) OneLake ou à l’API depuis les notebooks et scripts d’Azure Machine Learning

Lorsque le code s’exécute sur une ressource de calcul Azure Machine Learning (instance de calcul, cluster de calcul ou calcul sans serveur), il peut lire et écrire directement dans OneLake via le chemin abfss:// ou le chemin de son magasin de données OneLake. Le SDK OneLake et les API offrent un point d’intégration flexible et peuvent être utilisés pour l’exploration pilotée par notebook, les scripts d’entraînement personnalisés et les composants qui nécessitent un accès à la fois à /Files et à /Tables via les ressources de calcul Azure Machine Learning.

OneLake utilise un URI abfss:// pour les fichiers dans OneLake, et cet URI peut être utilisé comme chemin d’entrée de tâche valide pour l’authentification basée sur une identité ou un principal de service :

abfss://<workspace_guid>@<endpoint>/<item_guid>/Files/<path>

Performances et scalabilité : choix du lecteur approprié dans Azure Machine Learning

fsspec(et le back-end OneLake adlfs qu’il encapsule) est une abstraction de système de fichiers de niveau Python. Il est pratique pour les notebooks, mais n'est pas lui-même un moteur de données parallèle : sa concurrence est limitée par un seul processus de Python. Les performances dépendent donc du lecteur et du moteur assis au-dessus de celui-ci. La documentation de Azure Machine Learning runtime de données recommande explicitement d’utiliser le runtime de données Azure Machine Learning sur les téléchargements Python côté client pour les données d’apprentissage, notant les contraintes de débit de stockage observées « lorsque le code client utilise Python pour télécharger des données à partir du stockage, en raison des problèmes de verrouillage d’interpréteur global (GIL).

Utiliser Azure Machine Learning Spark pour le traitement des données à grande échelle sur OneLake

OneLake est conçu comme un lac d’analytique et le abfss:// point de terminaison est conçu pour les modèles de lecture partitionnés parallèles que Spark utilise. Pour les traitements ETL à l’échelle du téraoctet, l’ingénierie des caractéristiques ou la préparation distribuée des données d’entraînement, utilisez Azure Machine Learning Spark avec fsspec, idéalement sur un cluster multinœud :

Spark serverless dans Azure Machine Learning ou un pool Synapse Spark attaché : exécutez des travaux/notebooks Spark dans Azure Machine Learning et lisez OneLake directement via abfss://. Consultez Apache Spark dans Azure Machine Learning.
Fabric Spark - Les blocs-notes/tâches Spark exécutés dans Fabric ont un accès direct au même lakehouse et peuvent transmettre des résultats sélectionnés à Azure Machine Learning via le datastore OneLake.

L’exemple suivant illustre la lecture d’une table Lakehouse Delta à partir d’une session Spark dans Azure Machine Learning calcul :

df = (
    spark.read.format("delta")
        .load(
            "abfss://<workspace_guid>@onelake.dfs.fabric.microsoft.com/"
            "<item_guid>/Tables/<table-name>"
        )
)

OneLake et Azure Machine Learning `mltable`

Actuellement, la lecture de données prises en charge par OneLake via mltable échoue lors de la lecture en continu du fichier. Les erreurs observées incluent ScriptExecution.StreamAccess.NotFound et Invalid argument (os error 22). Les ressources de calcul d’Azure Machine Learning peuvent accéder à OneLake et le lire via azureml-fsspec, pyarrow, ou le SDK stockage Azure lac de données, à l’aide du même magasin de données et de la même identité.

À la place de la table ML, envisagez l’une des alternatives suivantes :

Pour les lectures OneLake, préférez uri_file / uri_folder les ressources de données et chargez-les avec azureml-fsspec + pyarrow / pandas / polars / DuckDB (nœud unique) ou avec Spark activé abfss:// (distribué). La documentation Microsoft Learn mltable elle-même note que pour un dossier Parquet ou un fichier CSV simple, uri_file / uri_folder sont le choix recommandé.
Si la sémantique mltable est réellement requise — le plus souvent comme entrée pour AutoML, qui exige type: mltable — transférez d’abord les données vers un compte ADLS Gen2, puis créez le mltable à partir de cet emplacement. mltable est fiable sur ADLS Gen2 aujourd’hui.
Le schéma de raccourci OneLake (abordé dans la section sur les points de terminaison par lots) convient naturellement à ML Table : le même fichier physique réside dans ADLS Gen2 (où mltable fonctionne) et apparaît dans le lakehouse Fabric via un raccourci (où les outils Fabric peuvent le voir), sans qu’aucune copie ne soit nécessaire.

mltable regroupe plusieurs fonctionnalités que uri_file / uri_folder n’offrent pas en standard. Le tableau suivant répertorie l’équivalent le plus proche lorsque vous lisez OneLake directement.

`mltable` capacité	Alternatif
Schéma de lecture déclaratif et portable (délimiteur, encodage, en-tête, taille de partition, types de colonnes) conservé dans un fichier `MLTable` avec les données	Épinglez les paramètres de lecture dans Python (`pyarrow.parquet.ParquetDataset`, `pandas.read_csv(...)`, `polars.scan_parquet(...)`, `duckdb.read_parquet(...)`) et conservez ce module de chargeur sous contrôle de code source
Transformations intégrées au moment de la lecture (`filter`, `drop_columns`, `convert_column_types`, `take_random_sample`)	Appliquez les équivalents dans le moteur de votre choix - `polars` / `duckdb` les lazy frames appliquent le pushdown des filtres et des projections de manière similaire ; Spark sur `abfss://` fait de même à grande échelle
Composition de chemins d’accès à plusieurs sources : une table couvrant plusieurs fichiers, dossiers, modèles glob et même comptes de stockage	Utiliser `fs.glob(...)` à partir de `azureml-fsspec`, `pyarrow.dataset.dataset(paths)` ou du `spark.read.parquet(*paths)` de Spark pour lire une liste de chemins d’accès comme un seul jeu de données logique
`eval_mount` / `eval_download` modes dans les travaux Azure Machine Learning (résolution des chemins à partir du fichier `MLTable` lors de la soumission du travail, monter uniquement les éléments référencés)	Matérialisez un sous-ensemble organisé en amont (un notebook Fabric ou un travail de prétraitement Azure Machine Learning écrit dans un dossier dédié `/Files/curated/...`) et faites-le pointer vers `uri_folder`
Gestion des versions de la recette de lecture (pas seulement des données) via une ressource de données de type `mltable`	Versionnez le script de chargement avec le code du modèle dans Git, ou associez une ressource de données `uri_folder` à un petit module de chargement enregistré à côté du script d’entraînement
**Entrée pour AutoML—AutoML nécessite `type: mltable` (Configurer l’entraînement AutoML)	Placez les données dans ADLS Gen2 (le raccourci depuis le lakehouse conserve une seule copie physique) et créez le `mltable` à cet emplacement

Pour l’entraînement et le scoring personnalisés sur OneLake, utilisez uri_file / uri_folder plus un moteur de votre choix (pyarrow / polars / duckdbà nœud unique ou Spark distribué dans Azure Machine Learning). Ces options offrent les mêmes fonctionnalités fonctionnelles qu’avec mltable un débit comparable ou meilleur. Pour AutoML, routez via ADLS Gen2 jusqu’à ce que mltable OneLake soit pris en charge. Vous pouvez utiliser un raccourci vers OneLake pour éviter la duplication des données et disposer des données disponibles dans Fabric pour d’autres cas d’usage.

Considerations

Modèle d’identité. OneLake utilise le modèle d’identité SaaS. Il n’expose donc pas d’ID d’abonnement. Au lieu du contrôle d’accès en fonction du rôle Azure (Azure RBAC) sur le compte de stockage, l’accès est régi par les rôles d’espace de travail Fabric (Administrateur, Membre, Contributeur, Lecteur) sur le lakehouse cible. Le magasin de données OneLake prend en charge deux modes d’informations d’identification, qui sont documentés dans Créer des magasins de données. Pour configurer le magasin de données et accéder au Fabric lakehouse, vous avez besoin d’un utilisateur avec le rôle Contributeur de l’espace de travail Fabric et le rôle d’administrateur de l’espace de travail Azure Machine Learning.
Copie unique de données. Le magasin de données OneLake et l’accès direct ABFSS conservent le principe de « copie unique » de OneLake. Le schéma de raccourci pour les points de terminaison batch préserve ce principe d’un point de vue logique, mais nécessite un compte ADLS Gen2 comme stockage physique sous-jacent.
Colocalisation régionale. Placez l’espace de travail Azure Machine Learning, le calcul et la capacité de Fabric ou la région OneLake dans la même région pour éviter la sortie interrégion.

Commentaires

Cette page a-t-elle été utile ?

Dernière mise à jour : 2026-06-26