Självstudie: Uppgradera dina Azure Data Factory-pipelines till Fabric-pipelines med hjälp av PowerShell

Du kan migrera dina Azure Data Factory-pipelines (ADF) till Microsoft Fabric med hjälp av PowerShell-modulen Microsoft.FabricPipelineUpgrade. Den här självstudien innehåller ett exempel på alla steg för att utföra migreringen med specifika instruktioner, skärmbilder och felsökningssteg. En mer allmän, koncis guide finns i översikten.

Förbereda för en uppgradering
Så här uppgraderar du en ADF-pipeline till en Fabric-pipeline
Läsa och hantera aviseringar

Förutsättningar

Kom igång genom att se till att du har följande förutsättningar:

Klientorganisation: Din ADF- och Fabric-arbetsyta måste finnas i samma Microsoft Entra-ID-klientorganisation.
Fabric: Ett klientkonto med en aktiv Fabric-prenumeration – Skapa ett konto kostnadsfritt.
Rekommendationer för infrastrukturarbetsyta (valfritt): Vi rekommenderar att du använder en ny infrastrukturarbetsyta i samma region som din ADF för uppgraderingar för bästa prestanda.
Behörigheter: Läsbehörighet till ADF-arbetsytan och objekt som du migrerar och Deltagare eller högre rättigheter i Fabric-arbetsytan som du skriver till.
Nätverk och autentisering: Kontrollera att du kan logga in på både Azure och Fabric från datorn (interaktivt eller tjänstens huvudnamn).

Förbereda uppgraderingen

Innan du börjar uppgradera pipelines kontrollerar du att din miljö har de verktyg och moduler som krävs:

PowerShell 7.4.2 (x64) eller senare
FabricPipelineUpgrade-modul

Installera PowerShell 7.4.2 (x64) eller senare

Du behöver PowerShell 7.4.2 eller senare på datorn.

Ladda ned PowerShell

Installera och importera modulen FabricPipelineUpgrade

Öppna PowerShell 7 (x64).
Välj Start-menyn, sök efter PowerShell 7, öppna appens snabbmeny och välj Kör som administratör.

Installera modulen från PowerShell-galleriet i det upphöjda PowerShell-fönstret:

Install-Module Microsoft.FabricPipelineUpgrade -Repository PSGallery -SkipPublisherCheck

Importera modulen till sessionen:

Import-Module Microsoft.FabricPipelineUpgrade

Om du ser ett signerings- eller körningspolicyfel, kör det här kommandot och importera sedan modulen igen.
```
Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
```

Verifiera installationen

Kör det här kommandot för att bekräfta att modulen har lästs in korrekt:

Get-Command -Module Microsoft.FabricPipelineUpgrade

Skärmbild av modulkommandots utdata.

Håll PowerShell-fönstret öppet. du använder den för uppgraderingen.

Din första uppgradering

Vi skapar en exempelpipeline och uppgraderar den till Fabric som en genomgång av processen.

Skapa en enkel ADF-pipeline

I Azure Data Factory Studio skapar du en pipeline och lägger till en wait-aktivitet. Du kan kalla det vad som helst, men i den här självstudien används pipeline1.

Förbereda Din PowerShell-miljö

I PowerShell-fönstret ersätter du värdena för <your subscription ID> och kör dessa kommandon i PowerShell för att logga in och ange din prenumeration.
```
Add-AzAccount 
Select-AzSubscription -SubscriptionId <your subscription ID>
```

Kör det här kommandot för att lagra den säkra ADF-token för sessionen:

$adfSecureToken = (Get-AzAccessToken -ResourceUrl "https://management.azure.com/").Token

I PowerShell-fönstret ersätter du värdena för <your subscription ID>, <your Resource Group Name>och <your Factory Name>och kör:
```
Import-AdfFactory -SubscriptionId <your subscription ID> -ResourceGroupName <your Resource Group Name> -FactoryName <your Factory Name> -PipelineName "pipeline1" -AdfToken $adfSecureToken
```
Tips/Råd

För datafabriker med flera pipelines kan du importera alla pipelines samtidigt genom att utelämna parametern -PipelineName .

Det här kommandot läser in pipelinen och associerade artefakter från Azure Data Factory och skapar JSON för den första "Uppgraderingsförloppet".

{
  "state": "Succeeded",
  "alerts": [],
  "result": {
    "importedResources": {
      "type": "AdfSupportFile",
      "adfName": "testdatafactory,
      "pipelines": {
        "pipeline1": {
          "name": "pipeline1",
          "type": "Microsoft.DataFactory/factories/pipelines",
          "properties": {
            "activities": [
              {
                "name": "Wait1",
                "type": "Wait",
                "dependsOn": [],
                "userProperties": [],
                "typeProperties": {
                  "waitTimeInSeconds": 1
                }
              }
            ],
            ],
            "policy": {
              "elapsedTimeMetric": {}
            },
            "annotations": [],
            "lastPublishTime": "2025-09-09T02:46:36Z"
          },
          "etag": "aaaaaaaa-bbbb-cccc-1111-222222222222"
        }
      },
      "datasets": {},
      "linkedServices": {},
      "triggers": {}
    }
  },
  "resolutions": []
}

Vad dessa fält betyder

state: Visar statusen. Om det står Lyckades, är du bra.
aviseringar: Visar en lista över eventuella problem eller extra information.
result: Visar resultatet. Här visar importedResources ADF-artefakterna.
resolutioner: Används för att mappa ADF-länkade tjänster till Fabric Connections (senare avsnitt).

Konvertera din ADF-pipeline till en Fabric-pipeline

I PowerShell-fönstret tar du kommandot Import-AdfFactory som du precis körde och lägger till | och sedan kommandot ConvertTo-FabricResources i slutet av raden.

Det fullständiga kommandot bör se ut så här:

Import-AdfFactory -SubscriptionId <your subscription ID> -ResourceGroupName <your Resource Group Name> -FactoryName <your Factory Name> -PipelineName  "pipeline1" -AdfToken $adfSecureToken | ConvertTo-FabricResources

Kör kommandot . Du bör se ett svar som liknar detta:

{
  "state": "Succeeded",
  "alerts": [],
  "result": {
    "exportableFabricResources": [
      {
        "resourceType": "DataPipeline",
        "resourceName": "pipeline1",
        "resolve": [],
        "export": {
          "name": "pipeline1",
          "properties": {
            "activities": [
              {
                "name": "Wait1",
                "type": "Wait",
                "dependsOn": [],
                "userProperties": [],
                "description": null,
                "typeProperties": {
                  "waitTimeInSeconds": 1
                }
              }
            ]
          },
          "annotations": []
        }
      }
    ]
  },
  "resolutions": []
}

Du ser fortfarande standarduppgraderingsförloppet, men nu innehåller resultatfältet exportableFabricResources. Det förväntas; du gör Fabricresurserna klara för export.

Du får lära dig mer om upplösningsfältet senare. För tillfället visar exportfältet en Fabric-pipeline med en Vänta-aktivitet.

Om du stannar här fungerar det här kommandot som ett What-If-scenario: det visar vad uppgraderingen skulle skapa och är ett bra sätt att kontrollera uppgraderingen innan du gör några ändringar.

Samla in information från din Fabric-arbetsyta

Innan du exporterar Fabric-pipelinen, behöver du några detaljer från din Fabric-arbetsyta. Öppna en tom textfil för att kopiera de värden du behöver senare.

Öppna Microsoft Fabric UX och navigera till din Data Factory-arbetsyta.
Hitta ditt arbetsyte-ID och kopiera det till textfilen.
Kör det här PowerShell-kommandot för att hämta åtkomsttoken för infrastrukturresurser och lagra den för sessionen:
```
$fabricSecureToken = (Get-AzAccessToken -ResourceUrl "https://analysis.windows.net/powerbi/api").Token
```
Tips/Råd

Åtkomsttoken upphör att gälla efter ungefär en timme. När det händer kör du kommandot igen. Du vet att token har upphört att gälla om Export-FabricResources returnerar ett tokenutgångsfel.

Exportera infrastrukturledning

Kombinera all information som du samlade in i det här kommandot:

Import-AdfFactory -SubscriptionId <your Subscription ID> -ResourceGroupName <your Resource Group Name> -FactoryName <your Data Factory Name> -PipelineName  "pipeline1" -AdfToken $adfSecureToken | ConvertTo-FabricResources | Export-FabricResources -Region <region> -Workspace <workspaceId> -Token $fabricSecureToken

Kopiera nu kommandot från textdokumentet till PowerShell-fönstret och kör kommandot .

Du bör se ett svar som liknar detta:

{
    "state": "Succeeded",
    "alerts": [],
    "result": {
      "exportedFabricResources": {
        "pipeline1": {
          "type": "DataPipeline",
          "workspaceId": "<your Workspace ID>",
          "id": "<The GUID of your new Pipeline>,
          "displayName": "pipeline1",
          "description": null
        }
      }
    }
  }

Det betyder att det fungerade! Avsnittet exportedFabricResources visar din nya pipeline och dess ID. Öppna nu arbetsytan Fabric i Fabric UX. Uppdatera sidan så visas pipeline1 i listan. Öppna den så hittar du exakt det du förväntar dig!

Din andra uppgradering: Kopiera vissa data

Den här andra uppgraderingen liknar den första, men introducerar ett par nya begrepp:

Datauppsättningar och AnslutnaTjänster
Resolutions

Uppgraderingen av infrastrukturledning stöder för närvarande en begränsad uppsättning datauppsättningar, så vi använder Azure Blob Storage-anslutningar och JSON-datauppsättningar. Vi går in.

I ADF Studio skapar du en pipeline som kopierar en JSON-fil från en mapp i Azure Blob Storage till en annan. Vi kallar den här pipelinen "pipeline2" och Azure Blob Storage-anslutningen "BlobStore1", men återigen kan du använda alla namn du vill.

Kör samma What-If kommando som tidigare för att importera pipelinen och kontrollera vad migreringsresultatet skulle bli. Se till att uppdatera pipelinenamnet.

Import-AdfFactory -SubscriptionId <your Subscription ID> -ResourceGroupName <your Resource Group Name> -FactoryName <your Data Factory Name> -PipelineName  "pipeline2" -AdfToken $adfSecureToken | ConvertTo-FabricResources

I utdata ser pipelinen ut ungefär som tidigare, men nu finns det mer information, inklusive två exportableFabricResources:

En för en anslutning
En för en processkedja

Här är ett exempel på avsnittet Anslutning i utdata:

{
    "resourceName": "BlobStore1",
    "resourceType": "Connection",
    "resolve": [
    {
        "type": "LinkedServiceToConnectionId",
        "key": "BlobStore1",
        "targetPath": "id",
        "hint": {
        "linkedServiceName": "BlobStore1",
        "connectionType": "AzureBlobStorage",
        "datasource": "...",
        "template": {
            "type": "LinkedServiceToConnectionId",
            "key": "BlobStore1",
            "value": "<Fabric Connection ID>"
        }
        }
    }
    ],
    "export": {
    "id": "00000000-0000-0000-0000-000000000000"
    }
}

Lösningssteget säger: Find the correct GUID and insert it into the id field of this resource. För tillfället är ID:t alla nollor (ett tomt GUID). Eftersom exportören inte kan lösa det ger tipset vägledning om hur du löser problemet.

Avsnittet Pipeline har liknande steg:

"resolve": [
  {
    "type": "AdfResourceNameToFabricResourceId",
    "key": "Connection:BlobStore1",
    "targetPath": "properties.activities[0].typeProperties.source.datasetSettings.externalReferences.connection"
  },
  {
    "type": "AdfResourceNameToFabricResourceId",
    "key": "Connection:BlobStore1",
    "targetPath": "properties.activities[0].typeProperties.sink.datasetSettings.externalReferences.connection"
  }
],

Vad gör de här stegen?

Dessa resolve steg är instruktioner för att mappa dina ADF-länkade tjänster till aktiviteternas källa och mottagare med motsvarande Fabric-anslutnings-ID.

Varför inträffar det här?

Uppgraderaren kan inte känna till Fabric-resurs-ID för en anslutning eller pipeline förrän dessa resurser verkligen finns. Det ger därför ett tips om hur du skapar nödvändiga resurser och fyller i din lösningsfil.

Nu låt oss exportera Fabric-pipeline (försök 1)

Om dina åtkomsttoken har upphört att gälla uppdaterar du dem nu.

Kör samma steg som du använde i föregående lektion, men för "pipeline2" den här gången.

Import-AdfFactory -SubscriptionId <your Subscription ID> -ResourceGroupName <your Resource Group Name> -FactoryName <your Data Factory Name> -PipelineName  "pipeline2" -AdfToken $adfSecureToken | ConvertTo-FabricResources | Export-FabricResources -Region <region> -Workspace <workspaceId> -Token $fabricSecureToken

Detta misslyckas. Den här gången Import | Convert | Export returnerar kommandot något i stil med:

{
    "state": "Failed",
    "alerts": [
      {
        "severity": "RequiresUserAction",
        "details": "Please use the hint and template to create/find a new connection and add its ID to your resolutions.",
        "connectionHint": {
          "linkedServiceName": "BlobStore1",
          "connectionType": "AzureBlobStorage",
          "datasource": "...",
          "template": {
            "type": "LinkedServiceToConnectionId",
            "key": "BlobStore1",
            "value": "<Fabric Connection ID>"
          }
        }
      }
    ],
    "resolutions": [],
    "result": {}
  }

(Om du läser slutet av det sista steget kanske du känner igen connectionHint.)

Felet säger att vi måste "lägga till ett anslutnings-ID till dina lösningar".

Vad gick fel?

Fabrikuppgraderaren kan inte skapa fabric-anslutningar på egen hand. Du behöver hjälp genom att skapa en Infrastrukturanslutning manuellt och sedan tala om för uppgraderingen när den ska användas.

Skapa en lösningsfil

Skapa först en lösningsfil. Du kan ge den ett namn och spara det var du vill på datorn (så länge PowerShell kan komma åt det), men i den här självstudien används D:\Resolutions.json.
Initiera filen med:
```
[
]
```
Lägg sedan till din saknade upplösning från tipset som din uppgraderare gav dig. Du hittar den under "mall" i connectionHint avsnittet i felmeddelandet.
```
[
    "type": "LinkedServiceToConnectionId",
    "key": "BlobStore1",
    "value": "<Fabric Connection ID>"
]
```
Nu måste vi hitta den <Fabric Connection ID>. Det gör du genom att gå till arbetsytan Infrastruktur i Infrastruktur-UX, välja kugghjulsikonen i det övre högra hörnet och sedan välja Hantera anslutningar och gatewayer.
Om anslutningen inte finns i Infrastrukturresurser ännu skapar du en ny anslutning till samma Azure Blob Storage-konto som din ADF-pipeline använder. Du kan kalla det vad som helst, men i den här självstudiekursen används "myblob".
När du har skapat anslutningen hovra över ellipsknappen bredvid anslutningsnamnet för att visa menyn.
Välj Inställningar på menyn och kopiera sedan anslutnings-ID:t och klistra in det i filen Resolutions i stället för <Fabric Connection ID>.

Din lösningsfil bör se ut ungefär så här (din value kommer att vara annorlunda):

[
    {
        "type": "LinkedServiceToConnectionId",
        "key": "BlobStore1",
        "value": "dddddddd-9999-0000-1111-eeeeeeeeeeee"
    }
]

När du håller på kan du lägga till en kommentar i din lösning så här:

[
   {
      "comment": "Resolve the ADF 'BlobStore1' LinkedService to the Fabric 'myblob' Connection",
      "type": "LinkedServiceToConnectionId",
      "key": "BlobStore1",
      "value": "dddddddd-9999-0000-1111-eeeeeeeeeeee"
   }
]

Import-FabricResolutions-cmdlet

Du kan importera den här lösningsfilen för att kontrollera vad den gör.

Kör i PowerShell:

Import-FabricResolutions -rf "D:\Resolutions.json"

Du bör se:

{
  "state": "Succeeded",
  "alerts": [],
  "result": {},
  "resolutions": [
    {
      "type": "LinkedServiceToConnectionId",
      "key": "BlobStore1",
      "value": "dddddddd-9999-0000-1111-eeeeeeeeeeee"
    }
  ]
}

Det här är ett annat uppgraderingsförloppsobjekt, men nu är fältet resolutions ifyllt.

Du kan köra Import-FabricResolutions när som helst i kommandokedjan innanExport-FabricResources. Resolutionerna kommer att föras vidare till senare steg.

Exportera Fabric Pipeline (försök 2)

Nu när vi har en upplösningsfil kan vi försöka exportera igen efter att vi har lagt till Import-FabricResolutions steget.

Uppdatera kommandot genom att lägga till Import-FabricResolutions mellan Convert och Export:

Import-AdfFactory -SubscriptionId <your Subscription ID> -ResourceGroupName <your Resource Group Name> -FactoryName <your Data Factory Name> -PipelineName  "pipeline2" -AdfToken $adfSecureToken | ConvertTo-FabricResources | Import-FabricResolutions -ResolutionsFilename "<path to your resolutions file>" | Export-FabricResources -Region <region> -Workspace <workspaceId> -Token $fabricSecureToken

Kör kommandot i PowerShell.

Den här gången fungerar det! Återigen visar avsnittet exporteradeFabricResources din nya pipeline och dess ID.

Nu öppnar du din Fabric-arbetsyta i Fabric UX. Uppdatera sidan så visas pipeline1 i listan. Öppna den så hittar du exakt det du förväntar dig!

Nästa steg

Nu när du har uppgraderat två pipelines kan du använda det du har lärt dig för att uppgradera fler pipelines.

Mer information om vilka typer av aktiviteter och datauppsättningar som stöds finns i de funktioner som stöds.
Mer information om hur du skapar lösningsfilen för olika typer av pipelines finns i hur du lägger till anslutningar till din lösningsfil.
Allmänna steg för att utföra den här migreringen med Hjälp av PowerShell finns i: Migrera pipelines från Azure Data Factory till Fabric med hjälp av PowerShell.

Feedback

Var den här sidan till hjälp?

Last updated on 2025-09-22