Integrera OneLake med Azure Machine Learning

OneLake är Fabric:s öppna sjölagringslager med Azure Storage-kompatibel åtkomst. Den exponerar Fabric data via onelake.dfs.fabric.microsoft.com för ADLS Gen2/DFS-åtkomst och onelake.blob.fabric.microsoft.com för blob-API-åtkomst. Den här artikeln beskriver hur Azure Machine Learning kan använda dessa lagringsytor via AML-datalagringsplatser, batchslutpunkters indata och utdata samt direkt abfss:// åtkomst från anteckningsböcker eller skript.

Azure Machine Learning tillhandahåller tre primära integreringspunkter med OneLake:

Datalager – registrera en Fabric Lakehouse-plats Files som en Azure Machine Learning datalager och referera till den från jobb och datatillgångar. Azure Machine Learning har också stöd för direktlänk till Fabric Lakehouse-tabeller, men det mönstret omfattar en kopia till ADLS Gen2 och beskrivs inte i det här dokumentet.
Batch-slutpunkter – anropa batchdistributioner med indata och utdata som finns i OneLake (i dag via ett registrerat datalager eller via ett genvägsbaserat Blob/ADLS-datalager).
OneLake-API:er/direkt ABFSS-åtkomst – läsa och skriva OneLake direkt från notebook-filer och skript som körs i Azure Machine Learning körningsmiljöer.

Integrationsplats i Azure Machine Learning	OneLake-gränssnitt	Azure Machine Learning-gränssnitt	Kopieras data till ADLS Gen2?	Primär URI som ska användas i Azure Machine Learning
OneLake-datalager	Lakehouse-`/Files`avsnitt.	CLI/SDK (YAML)	No	`azureml://datastores/<name>/paths/<path>`
OneLake lakehouse-tabell (UI-länkad)	Lakehouse-`/Tables`avsnitt.	Azure Machine Learning Studio (användargränssnitt)	Ja – kopieras via Fabric pipeline till ADLS Gen2 och registreras sedan	`azureml://datastores/<adls_ds>/paths/<path>`
Indata/utdata för batch-slutpunkt	Lakehouse `/Files` (via ADLS-genväg).	CLI/SDK/REST	Optional	`azureml://datastores/<name>/paths/<path>` eller `abfss://...`
Direct OneLake API/ABFSS	`/Files` och `/Tables`	Notebook-filer/skript på Azure Machine Learning beräkning	No	`abfss://<workspace>@onelake.dfs.fabric.microsoft.com/<lakehouse>.Lakehouse/Files/...`

Note

azureml://är ett Azure Machine Learning-specifikt URI-schema, inte ett lagringsprotokoll. Azure Machine Learnings styrplan och datakörtid använder detta för att fastställa vilken underliggande lagringsplats som ska användas (Blob, ADLS Gen2, OneLake med mera) med hjälp av de anslutningsmetadata och autentiseringsuppgifter som registrerats på det namngivna datalagret.

OneLake som ett Azure Machine Learning datalager

En datalagerresurs är en arbetsyteomfattande abstraktion i Azure Machine Learning för en extern lagringsplats (OneLake, Azure Blob, ADLS Gen2, Azure Files). Den lagrar anslutningsmetadata för en befintlig lagringsresurs, slutpunkten, containern/filsystemet/objektet och autentiseringsuppgifter eller identitetskonfiguration, utan att etablera eller kopiera själva data. Olika upplevelser i Azure Machine Learning kan referera till datalager med hjälp av en stabil URI (azureml://datastores/<name>/paths/<path>).

Note

Azure Machine Learning Studio listar för närvarande inte OneLake som en datalagertyp i användargränssnittet, men CLI och SDK stöder skapande och hantering av OneLake-datalager via YAML-definition.

Anslutningsmetadata som krävs från Microsoft Fabric

Från lakehouse-objektets sida Egenskaper i Fabric hämtar du följande:

Slutpunkt – För OneLake använder onelake.dfs.fabric.microsoft.com eller onelake.blob.fabric.microsoft.com beroende på vilket protokoll du vill använda.
Arbetsytans GUID
Objekt-GUID (lakehouse GUID)

Skapa datalagringen i 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.

Använd Azure CLI och skapa datalagringen i målarbetsytan Azure Machine Learning. Ersätt platshållarna <name_of_AML_workspace> och <name_of_datastore> med lämpliga värden.

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

Använd ett datalager i Azure Machine Learning-jobb

När ett Azure Machine Learning datalager har registrerats är dess azureml:// URI tillgängligt för användning via olika upplevelser. Exemplet här visar hur du refererar till ett OneLake-datalager i ett Azure Machine Learning jobb. Följande URI är giltig som ett jobb Input/Output, i datatillgångsdefinitioner och var som helst Azure Machine Learning accepterar en datalagersökväg förutom batchslutpunkter, som för närvarande inte stöder OneLake som datalagertyp för indata eller utdata.

Följande jobbexempel kopierar en fil från en plats till en annan i samma OneLake-datalager. Du kan använda en blandning av olika lagringsmål som stöds (Blob, ADLS Gen2, OneLake) som indata och utdata i samma jobb.

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 funktioner som kan referera till ett OneLake-datalager direkt

#	Azure Machine Learning yta/gränssnitt	Direction	OneLake-adressering	Source
1	Azure Machine Learning jobb - `Input` / `Output` (CLI v2, SDK v2 `command`, `pipeline`, `sweep`)	R/W	`azureml://datastores/<onelake_ds>/paths/...`	Komma åt data i ett jobb
2	Dataresurser (`uri_file`, `uri_folder`) registrerade för en sökväg till OneLake-datalager	R (tillgångar är referenser som endast kan läsas)	`azureml://datastores/<onelake_ds>/paths/...` omsluten av versionshantering	Skapa datatillgångar
3	Azure Machine Learning-datakörningsmiljö via `azureml-fsspec` i anteckningsböcker/skript på Azure Machine Learning-beräkningsresurser	R/W	`azureml://datastores/<onelake_ds>/paths/...` öppnas med `fsspec.open(...)` eller `AzureMachineLearningFileSystem`	Få åtkomst till data från OneLake under interaktiv utveckling

OneLake med slutpunkter för batchbearbetning

Azure Machine Learning gör att du kan använda Fabric för att komma åt batchslutpunkter för modelldistribution för långvarig, asynkron slutsatsdragning med maskininlärningsmodeller och pipelines.

I det här mönstret är arkitekturmålet att behålla en enda fysisk kopia av både indata och utdataförutsägelser som är tillgängliga för båda plattformarna – Fabric och Azure Machine Learning. En fil i ADLS har två giltiga adresser – en azureml://datastores/... URI som Azure Machine Learning-batchslutpunkter accepterar som indata/utdata, och en lakehouse-sökväg (aktiverad via ADLS-genväg) som Fabric-notebooks, pipelines och SQL Analytics-slutpunkter kan fråga mot. Det här mönstret omfattar ingen kopia, ingen schemalagd synkronisering, ingen andra sanningskälla. Lakehouse-vyn och Azure Machine Learning-vyn är projektioner av samma lagringskonto.

Batchslutpunkter ligger mellan två OneLake-synliga mappar:

Indata – en kuraterad /Files lagringsplats (rålandningsyta, poängbedömda förfrågningar, dagliga partitioner) som har förberetts av Fabrics datateknikteam. Azure Machine Learning läser den via ett ADLS Gen2-datalager som pekar på samma lagring som genvägen.
Utdata – en lagringsplats för förutsägelser som batchjobbet skriver till i samma ADLS Gen2-konto, som visas i lakehouse via en genväg och är omedelbart tillgänglig för Fabric-notebookar, dataflöden eller ett inläsningssteg för en Delta-tabell.

Mer allmänt passar det här mönstret bra för scenarier där du redan har data landade i ADLS Gen2. Till exempel en befintlig datasjö som matar analys- eller ML-arbetsbelastningar. I stället för att migrera eller duplicera dessa data till OneLake, visar en OneLake-genväg den befintliga ADLS-platsen i ett Fabric lakehouse, medan samma konto förblir registrerat som ett datalager.

Åtkomst till OneLake SDK eller API från Azure Machine Learning-anteckningsböcker och skript

När koden körs på en Azure Machine Learning beräkning (beräkningsinstans, beräkningskluster eller serverlös beräkning) kan den läsa och skriva till OneLake direkt via abfss:// sökvägen eller dess OneLake-datalagersökväg. OneLake SDK och API:er erbjuder en flexibel integreringspunkt och kan användas för notebook-driven utforskning, anpassade träningsskript och komponenter som behöver både /Files och /Tables åtkomst via Azure Machine Learning beräkning.

OneLake använder en abfss:// URI för filer i OneLake, som kan användas som en giltig inmatningssökväg för jobb vid identitets- eller tjänsthuvudnamnsbaserad autentisering:

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

Prestanda och skalbarhet – välja rätt läsare i Azure Machine Learning

fsspec (och OneLake-backenddelen adlfs som den kapslar in) är en filsystemsabstraktion på Python-nivå. Det är praktiskt för notebook-filer men är inte i sig en parallell datamotor – dess samtidighet begränsas av en enda Python process. Prestanda beror därför på läsaren och motorn som sitter ovanpå den. I dokumentationen för Azure Machine Learnings datakörning rekommenderas uttryckligen att Azure Machine Learnings datakörning används i stället för Python-baserade nedladdningar på klientsidan för träningsdata, med hänvisning till observerade begränsningar i lagringsgenomströmningen "när klientkoden använder Python för att ladda ned data från lagring, på grund av problem med Global Interpreter Lock (GIL)."

Använda Azure Machine Learning Spark för storskalig databearbetning på OneLake

OneLake är utformat som en analyssjö och abfss:// slutpunkten är byggd för parallella, partitionerade läsmönster som Spark använder. För ETL i TB-skala, funktionsutveckling eller förberedelse av distribuerade träningsdata använder du Azure Machine Learning Spark över fsspec, helst i ett kluster med flera noder:

Serverlös Spark i Azure Machine Learning eller en ansluten Synapse Spark-pool – kör Spark-jobb/notebook-filer i Azure Machine Learning och läs OneLake direkt via abfss://. Se Apache Spark i Azure Machine Learning.
Fabric Spark – Spark-notebook-filer/jobb som körs i Fabric har förstklassig åtkomst till samma lakehouse och kan lämna över utvalda utdata till Azure Machine Learning via OneLake-datalager.

I följande exempel visas hur du läser en Lakehouse Delta-tabell från en Spark-session i Azure Machine Learning beräkning:

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

OneLake och Azure Machine Learning `mltable`

För närvarande går det inte att läsa OneLake-baserade data genom mltable vid strömning av filen. Observerade fel inkluderar ScriptExecution.StreamAccess.NotFound och Invalid argument (os error 22). Azure Machine Learnings beräkningsresurser kan få åtkomst till och läsa OneLake via azureml-fsspec, pyarrow eller Azure Storage Data Lake SDK med samma datalager och identitet.

I stället för ML-tabellen bör du överväga något av följande alternativ:

För läsningar från OneLake använder du helst uri_file / uri_folder datatillgångar och läser in dem med azureml-fsspec + pyarrow / pandas / polars / DuckDB (en enskild nod) eller med Spark på abfss:// (distribuerat). Själva Microsoft Learn-dokumentationen mltable noterar att för en enkel Parquet-mapp eller CSV-fil uri_file / uri_folder är det rekommenderade valet.
Om mltable semantik verkligen krävs - oftast som indata till AutoML, vilket kräver type: mltable - mellanlagra först data i ett ADLS Gen2-konto och skapa mltable mot den platsen. mltable är tillförlitlig på ADLS Gen2 idag.
OneLake-genvägsmönster (som diskuteras som en del av slutpunkter för batchbearbetning) passar naturligt för ML Table – samma fysiska fil finns i ADLS Gen2 (där mltable fungerar) och blir tillgänglig i Fabric-lakehouse via en genväg (där Fabric-verktyg kan se den), utan att kopieras.

mltable paketerar flera funktioner som uri_file / uri_folder inte tillhandahålls direkt. I följande tabell visas den närmaste motsvarigheten när du läser OneLake direkt.

`mltable` Kapacitet	Alternativ
Deklarativ, portabel läsritning (avgränsare, kodning, rubrik, partitionsstorlek, kolumntyper) sparas som en `MLTable` fil tillsammans med data	Fäst läsinställningarna i Python (`pyarrow.parquet.ParquetDataset`, , `pandas.read_csv(...)polars.scan_parquet(...)`, `duckdb.read_parquet(...)`) och håll inläsningsmodulen under källkontroll
Inbyggda transformationer vid läsning (`filter`, `drop_columns`, `convert_column_types`, `take_random_sample`)	Använd motsvarigheterna i den motor du väljer – `polars` / `duckdb` lata bildrutor trycker ned filter och projektioner på liknande sätt. Spark on `abfss://` gör samma sak i stor skala
Sammansättning av sökväg med flera källor – en tabell som omfattar flera filer, mappar, globmönster och till och med lagringskonton	Använd `fs.glob(...)` från `azureml-fsspec`, `pyarrow.dataset.dataset(paths)`eller Spark `spark.read.parquet(*paths)` för att läsa en lista över sökvägar som en logisk datauppsättning
`eval_mount` / `eval_download`-lägen i Azure Machine Learning-jobb (lös upp sökvägar från `MLTable`-filen när jobbet skickas, montera endast det som refereras till)	Materialisera en kurerad delmängd uppströms (en Fabric-anteckningsbok eller ett förbearbetningsjobb i Azure Machine Learning skriver till en dedikerad mapp `/Files/curated/...`) och peka på `uri_folder`
Versionshantering av läsreceptet (inte bara data) via en datatillgång av typen `mltable`	Version av inläsningsskriptet med modellkoden i Git eller parkoppla en `uri_folder` datatillgång med en liten inläsningsmodul incheckad bredvid träningsskriptet
**AutoML-indata – AutoML-mandat `type: mltable` (Konfigurera AutoML-utbildning)	Mellanlagra data i ADLS Gen2 (en genväg från lakehouset bevarar en enda fysisk kopia) och bygg `mltable` där

För anpassad träning och bedömning på OneLake använder du uri_file / uri_folder plus en valfri motor (pyarrow / polars / duckdben nod eller Spark distribuerad i Azure Machine Learning). Dessa alternativ erbjuder samma funktionella funktioner som mltable med jämförbart eller bättre dataflöde. För AutoML dirigerar du via ADLS Gen2 till dess att mltable över OneLake stöds. Du kan använda en genväg till OneLake för att undvika dataduplicering och fortfarande ha data tillgängliga i Fabric för andra användningsfall.

Considerations

Identitetsmodell. OneLake använder SaaS-identitetsmodellen så att den inte exponerar ett prenumerations-ID. I stället för Azure-rollbaserad åtkomstkontroll (Azure RBAC) på lagringskontot styrs åtkomsten av Fabric-arbetsyteroller (administratör, medlem, bidragsgivare, läsare) på mållakehouse. OneLake-dataarkivet stöder två autentiseringslägen som dokumenteras i Skapa datalager. För att konfigurera datalagret och få åtkomst till Fabric-lakehouse behöver du en användare med både rollen Deltagare i Fabric-arbetsytan och administratörsrollen för Azure Machine Learning-arbetsytan.
Enskild kopia av data. Datalagret i OneLake och direktåtkomst via ABFSS bevarar OneLakes princip om en enda kopia. Genvägsmönstret för batchslutpunkter följer logiskt sett denna princip men kräver ett ADLS Gen2-konto som underliggande fysisk lagringsplats.
Samlokalisering av regioner Placera Azure Machine Learning-arbetsytan, beräknings- och Fabric-kapaciteten eller OneLake-regionen i samma region för att undvika utgående trafik mellan regioner.

Feedback

Var den här sidan till hjälp?

Uppdaterades senast 2026-09-11