Zelfstudie: Uw Azure Data Factory-pijplijnen upgraden naar Fabric-pijplijnen met behulp van PowerShell

U kunt uw ADF-pijplijnen (Azure Data Factory) migreren naar Microsoft Fabric met behulp van de PowerShell-module Microsoft.FabricPipelineUpgrade. Deze zelfstudie bevat een voorbeeld van alle stappen voor het uitvoeren van de migratie met specifieke instructies, schermopnamen en stappen voor probleemoplossing. Zie het overzicht voor een meer algemene, beknopte handleiding.

Voorbereiden op een upgrade
Een ADF-pijplijn upgraden naar een Fabric-pijplijn
Waarschuwingen lezen en afhandelen

Vereiste voorwaarden

Zorg ervoor dat u aan de volgende vereisten voldoet om aan de slag te gaan:

Tenant: uw ADF- en Fabric-werkruimte moeten zich in dezelfde Microsoft Entra ID-tenant bevinden.
Fabric: Een tenantaccount met een actief Fabric-abonnement : maak gratis een account.
Aanbevelingen voor Fabric-werkruimten (optioneel): We raden aan een nieuwe Fabric-werkruimte in dezelfde regio als uw ADF te gebruiken voor upgrades voor de beste prestaties.
Machtigingen: Leestoegang tot de ADF-werkruimte en items die u migreert en Contributierechten of hoger in de Fabric-werkruimte waarin u schrijft.
Netwerk en verificatie: zorg ervoor dat u zich kunt aanmelden bij zowel Azure als Fabric vanaf uw computer (interactief of service-principal).

Upgrade voorbereiden

Voordat u pijplijnen gaat upgraden, controleert u of uw omgeving beschikt over de vereiste hulpprogramma's en modules:

PowerShell 7.4.2 (x64) of hoger
FabricPipelineUpgrade-module

PowerShell 7.4.2 (x64) of hoger installeren

U hebt PowerShell 7.4.2 of hoger nodig op uw computer.

PowerShell downloaden

De Module FabricPipelineUpgrade installeren en importeren

Open PowerShell 7 (x64).
Selecteer het startmenu, zoek naar PowerShell 7, open het contextmenu van de app en selecteer Uitvoeren als administrator.
Installeer in het PowerShell-venster met verhoogde bevoegdheid de module vanuit de PowerShell Gallery:
```
Install-Module Microsoft.FabricPipelineUpgrade -Repository PSGallery -SkipPublisherCheck
```

Importeer de module in uw sessie:

Import-Module Microsoft.FabricPipelineUpgrade

Als er een fout optreedt in het beleid voor ondertekening of uitvoering, voert u deze opdracht uit en importeert u de module opnieuw:
```
Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
```

Uw installatie controleren

Voer deze opdracht uit om te bevestigen dat de module correct is geladen:

Get-Command -Module Microsoft.FabricPipelineUpgrade

Schermopname van de uitvoer van de moduleopdracht.

Houd uw PowerShell-venster open; u gebruikt deze voor de upgrade.

Uw eerste upgrade

We maken een voorbeeldpijplijn en upgraden deze naar Fabric als een overzicht van het proces.

Een eenvoudige ADF-pijplijn maken

Maak in Azure Data Factory Studio een pijplijn en voeg een wachtactiviteit toe. U kunt het een naam geven die u wilt, maar in deze zelfstudie wordt pijplijn1 gebruikt.

Uw PowerShell-omgeving voorbereiden

Vervang in uw PowerShell-venster de waarden voor <your subscription ID> en voer deze opdrachten uit in PowerShell om u aan te melden en uw abonnement in te stellen:
```
Add-AzAccount 
Select-AzSubscription -SubscriptionId <your subscription ID>
```

Voer deze opdracht uit om het beveiligde ADF-token voor uw sessie op te slaan:

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

Vervang in het PowerShell-venster de waarden voor <your subscription ID>, <your Resource Group Name>en <your Factory Name>voer het volgende uit:
```
Import-AdfFactory -SubscriptionId <your subscription ID> -ResourceGroupName <your Resource Group Name> -FactoryName <your Factory Name> -PipelineName "pipeline1" -AdfToken $adfSecureToken
```
Aanbeveling

Voor Data Factory's met meerdere pijplijnen kunt u alle pijplijnen tegelijk importeren door de -PipelineName parameter weg te laten.

Met deze opdracht worden de pijplijn en de bijbehorende artefacten uit uw Azure Data Factory geladen en wordt de JSON gemaakt voor de eerste upgradevoortgang.

{
  "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": []
}

Wat deze velden betekenen

status: Geeft de status weer. Als er 'Geslaagd' staat, is het goed.
waarschuwingen: bevat eventuele problemen of extra informatie.
resultaat: Geeft het resultaat weer. Hier worden in importedResources de ADF-artefacten vermeld.
oplossingen: wordt gebruikt voor het toewijzen van gekoppelde ADF-services aan Fabric-verbindingen (latere sectie).

Uw ADF-pijplijn converteren naar een Fabric-pijplijn

Voer in het PowerShell-venster de Import-AdfFactory opdracht uit die u zojuist hebt uitgevoerd en voeg | vervolgens de ConvertTo-FabricResources opdracht toe aan het einde van de regel.

De volledige opdracht moet er als volgt uitzien:
```
Import-AdfFactory -SubscriptionId <your subscription ID> -ResourceGroupName <your Resource Group Name> -FactoryName <your Factory Name> -PipelineName  "pipeline1" -AdfToken $adfSecureToken | ConvertTo-FabricResources
```

Voer de opdracht uit. U zou een antwoord moeten zien zoals dit:

{
  "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": []
}

U ziet nog steeds de standaardvoortgang van de upgrade, maar nu bevat het resultaatveld exportableFabricResources. Dat is verwacht. U krijgt de Fabric-resources klaar om te exporteren.

Je leert later meer over het resolutieveld. Voorlopig toont het exportveld een Fabric-pijplijn met een wachtactiviteit.

Als u hier stopt, fungeert deze opdracht als een What-If: het laat zien wat de upgrade zou maken en is een goede manier om de upgrade te valideren voordat u wijzigingen aanbrengt.

Informatie verzamelen uit uw Fabric-werkruimte

Voordat u uw Fabric-pijplijn exporteert, hebt u enkele details nodig uit uw Fabric-werkruimte. Open een leeg tekstbestand om de waarden te kopiëren die u later nodig hebt.

Open Microsoft Fabric UX en navigeer naar uw Data Factory-werkruimte.
Zoek uw werkruimte-id en kopieer deze naar uw tekstbestand.
Voer deze PowerShell-opdracht uit om uw Fabric Access-token op te halen en op te slaan voor uw sessie:
```
$fabricSecureToken = (Get-AzAccessToken -ResourceUrl "https://analysis.windows.net/powerbi/api").Token
```
Aanbeveling

Toegangstokens verlopen na ongeveer een uur. Als dat gebeurt, voert u de opdracht opnieuw uit. U weet dat het token is verlopen als Export-FabricResources een tokenverloopfout retourneert.

De Fabric-pijplijn exporteren

Combineer alle gegevens die u in deze opdracht hebt verzameld:

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

Kopieer nu de opdracht uit het tekstdocument naar het PowerShell-venster en voer de opdracht uit.

U zou een antwoord moeten zien zoals dit:

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

Dit betekent dat het werkte! In de sectie exportFabricResources ziet u de nieuwe pijplijn en de bijbehorende id. Open nu uw Fabric-werkruimte in Fabric UX. Vernieuw de pagina en u ziet pijplijn1 in de lijst. Open het en u vindt precies wat u verwacht!

Uw tweede upgrade: enkele gegevens kopiëren

Deze tweede upgrade is vergelijkbaar met de eerste, maar introduceert een aantal nieuwe concepten:

Gegevenssets en gekoppelde diensten
Resolutions

De Fabric Pipeline Upgrader ondersteunt momenteel een beperkte set gegevenssets, dus we gebruiken Azure Blob Storage-verbindingen en JSON-gegevenssets. Laten we eens induiken.

Maak in ADF Studio een pijplijn waarmee een JSON-bestand wordt gekopieerd van de ene map in uw Azure Blob Storage naar een andere. We noemen deze pijplijn 'pipeline2' en de Azure Blob Storage-verbinding 'BlobStore1', maar u kunt ook elke gewenste naam gebruiken.

Voer dezelfde What-If opdracht uit als voorheen om uw pijplijn te importeren en te controleren wat het migratieresultaat zou zijn. Zorg ervoor dat u de naam van de pijplijn bijwerkt.

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

In de uitvoer ziet de pijplijn er ongeveer als voorheen uit, maar nu zijn er meer details, waaronder twee exportableFabricResources:

Een voor een verbinding
Een voor een pijplijn

Hier volgt een voorbeeld van de sectie Verbinding van de uitvoer:

{
    "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"
    }
}

De oplossingsstap zegt: Find the correct GUID and insert it into the id field of this resource. Voor nu is de id alle nullen (een lege GUID). Omdat de exporteur het niet kan oplossen, biedt de hint richtlijnen voor het oplossen van het probleem.

De sectie Pijplijn heeft vergelijkbare stappen:

"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"
  }
],

Wat doen deze stappen?

Deze resolve stappen zijn instructies om uw gekoppelde ADF-services toe te wijzen aan de bron en sink van de activiteiten met de bijbehorende Fabric Connection ID.

Waarom gebeurt dit?

De upgrader kan de fabric-resource-id voor een verbinding of pijplijn pas kennen als deze resources bestaan. Dus, biedt het een tip over hoe u de benodigde bronnen kunt maken en uw resolutiebestand kunt invullen.

Nu gaan we de Fabric Pipeline exporteren (poging 1)

Als uw toegangstokens zijn verlopen, vernieuwt u deze nu.

Voer dezelfde stappen uit die u in de vorige les hebt gebruikt, maar voor 'pipeline2' deze keer.

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

Dit mislukt. Deze keer retourneert de Import | Convert | Export opdracht iets als:

{
    "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": {}
  }

Als u het einde van de laatste stap hebt gelezen, herkent u mogelijk connectionHint.

De fout geeft aan dat we een verbindings-ID moeten toevoegen aan je resoluties.

Wat is er misgegaan?

De Fabric Upgrader kan zelf geen Fabric-verbindingen maken. U moet helpen door handmatig een Fabric-verbinding te maken en vervolgens de upgrader te vertellen wanneer deze moet worden gebruikt.

Een oplossingsbestand maken

Maak eerst een oplossingsbestand. U kunt alles een naam opgeven en opslaan waar u maar wilt op uw computer (zolang PowerShell er toegang toe heeft), maar in deze zelfstudie wordt gebruikgemaakt van D:\Resolutions.json.
Initialiseer het bestand met:
```
[
]
```
Voeg vervolgens uw ontbrekende resolutie toe aan de hint die uw upgrader u heeft gegeven. U vindt deze onder Sjabloon in de connectionHint sectie van het foutbericht.
```
[
    "type": "LinkedServiceToConnectionId",
    "key": "BlobStore1",
    "value": "<Fabric Connection ID>"
]
```
Vervolgens moeten we dat <Fabric Connection ID>vinden. Hiervoor gaat u naar uw Fabric-werkruimte in Fabric UX, selecteert u het tandwielpictogram in de rechterbovenhoek en selecteert u Verbindingen en gateways beheren.
Als de verbinding nog niet bestaat in Fabric, maakt u een nieuwe verbinding met hetzelfde Azure Blob Storage-account dat door uw ADF-pijplijn wordt gebruikt. U kunt het noemen zoals u wilt, maar in deze zelfstudie wordt de naam 'myblob' gebruikt.
Nadat u de verbinding hebt gemaakt, plaatst u de muisaanwijzer op de knop met het beletselteken naast de verbindingsnaam om het menu weer te geven.
Selecteer Instellingen in het menu, kopieer de verbindings-id en plak deze in het bestand Resoluties in plaats van <Fabric Connection ID>.

Uw oplossingsbestand ziet er ongeveer als volgt uit (uw value zal anders zijn):

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

Terwijl u eraan werkt, kunt u als volgt een opmerking toevoegen aan uw resolutie:

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

De cmdlet Import-FabricResolutions

U kunt dit oplossingsbestand importeren om te controleren wat het doet.

Voer in PowerShell het volgende uit:

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

U ziet het volgende:

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

Dit is een ander voortgangsobject voor de upgrade, maar nu is het resolutions veld ingevuld.

U kunt Import-FabricResolutions op elk gewenst moment in de opdrachtketen voorExport-FabricResources uitvoeren. De resoluties zullen worden meegenomen naar latere stappen.

De Fabric-pijplijn exporteren (poging 2)

Nu we een oplossingsbestand hebben, kunnen we de export opnieuw proberen na het toevoegen van de Import-FabricResolutions stap.

Werk uw opdracht bij door toe te voegen Import-FabricResolutions tussen Convert en 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

Voer de opdracht uit in PowerShell.

Deze keer werkt het! In de sectie 'exportFabricResources' ziet u de nieuwe pijplijn en de bijbehorende ID.

Open nu uw Fabric-werkruimte in Fabric UX. Vernieuw de pagina en u ziet pijplijn1 in de lijst. Open het en u vindt precies wat u verwacht!

Volgende stappen

Nu u twee pijplijnen hebt bijgewerkt, kunt u gebruiken wat u hebt geleerd om meer pijplijnen te upgraden.

Zie de ondersteunde functionaliteit voor meer informatie over de typen activiteiten en gegevenssets die worden ondersteund.
Zie voor meer informatie over het maken van het oplossingsbestand voor verschillende soorten pijplijnen hoe u verbindingen toevoegt aan uw oplossingsbestand.
Zie voor algemene stappen voor het uitvoeren van deze migratie met behulp van PowerShell: Pijplijnen migreren van Azure Data Factory naar Fabric met behulp van PowerShell.

Feedback

Is deze pagina nuttig?

Last updated on 2025-09-22