Tutorial: Actualización de las canalizaciones de Azure Data Factory a canalizaciones de Fabric mediante PowerShell

Puede migrar las canalizaciones de Azure Data Factory (ADF) a Microsoft Fabric mediante el módulo de PowerShell Microsoft.FabricPipelineUpgrade. En este tutorial se proporciona un ejemplo de todos los pasos para realizar la migración con instrucciones, capturas de pantalla y pasos de solución de problemas específicos. Para obtener una guía más general y concisa, consulte la información general.

Preparación de una actualización
Actualización de una canalización de ADF a una canalización de Fabric
Leer y controlar alertas

Prerrequisitos

Para empezar, asegúrese de que tiene los siguientes requisitos previos:

Inquilino: el área de trabajo de ADF y Fabric debe estar en el mismo inquilino de Id. de Microsoft Entra.
Fabric: una cuenta de inquilino con una suscripción de Fabric activa: cree una cuenta de forma gratuita.
Recomendaciones del área de trabajo de Fabric (opcional): se recomienda usar un área de trabajo de Fabric nueva en la misma región que la instancia de ADF para las actualizaciones para mejorar el rendimiento.
Permisos: acceso de lectura al área de trabajo y elementos de ADF que migrará y derechos de colaborador o superiores en el área de trabajo de Fabric a la que escribirá.
Red y autenticación: asegúrese de que puede iniciar sesión en Azure y Fabric desde su máquina (de forma interactiva o con un principal de servicio).

Preparación de la actualización

Antes de empezar a actualizar canalizaciones, compruebe que el entorno tiene las herramientas y módulos necesarios:

PowerShell 7.4.2 (x64) o posterior
Módulo FabricPipelineUpgrade

Instalación de PowerShell 7.4.2 (x64) o posterior

Necesitas PowerShell 7.4.2 o posterior en tu equipo.

Descarga de PowerShell

Instalación e importación del módulo FabricPipelineUpgrade

Abra PowerShell 7 (x64).
Seleccione el menú Inicio, busque PowerShell 7, abra el menú contextual de la aplicación y seleccione Ejecutar como administrador.
En la ventana de PowerShell con privilegios elevados, instale el módulo desde la Galería de PowerShell:
```
Install-Module Microsoft.FabricPipelineUpgrade -Repository PSGallery -SkipPublisherCheck
```

Importe el módulo en la sesión:

Import-Module Microsoft.FabricPipelineUpgrade

Si ve un error de directiva de firma o ejecución, ejecute este comando y vuelva a importar el módulo:
```
Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass
```

Compruebe la instalación

Ejecute este comando para confirmar que el módulo se cargó correctamente:

Get-Command -Module Microsoft.FabricPipelineUpgrade

Captura de pantalla de la salida del comando del módulo.

Mantenga abierta la ventana de PowerShell; lo usará para la actualización.

La primera actualización

Crearemos una canalización de ejemplo y la actualizaremos a Fabric como tutorial del proceso.

Crea una canalización sencilla de ADF

En Azure Data Factory Studio, cree una canalización y agregue una actividad Wait. Puede asignarle un nombre a cualquier cosa, pero en este tutorial se usa pipeline1.

Preparación del entorno de PowerShell

En la ventana de PowerShell, reemplace los valores de <your subscription ID> y ejecute estos comandos en PowerShell para iniciar sesión y establecer la suscripción:
```
Add-AzAccount 
Select-AzSubscription -SubscriptionId <your subscription ID>
```

Ejecute este comando para almacenar el token de ADF seguro para la sesión:

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

En la ventana de PowerShell, reemplace los valores de <your subscription ID>, <your Resource Group Name>y <your Factory Name>, y ejecute:
```
Import-AdfFactory -SubscriptionId <your subscription ID> -ResourceGroupName <your Resource Group Name> -FactoryName <your Factory Name> -PipelineName "pipeline1" -AdfToken $adfSecureToken
```
Sugerencia

Para Factorías de datos con varias canalizaciones, puede importar todas las canalizaciones a la vez dejando fuera el -PipelineName parámetro .

Este comando carga la canalización y los artefactos asociados desde Azure Data Factory y crea el json para el primer "Progreso de actualización".

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

Qué significan estos campos

state: muestra el estado. Si dice Exitoso, todo está bien.
alertas: enumera cualquier problema o información adicional.
result: muestra el resultado. Aquí, importedResources enumera los artefactos de ADF.
resoluciones: se usa para asignar servicios vinculados de ADF a conexiones de Fabric (sección posterior).

Convierta su canalización de ADF a una canalización de Fabric

En la ventana de PowerShell, tome el comando Import-AdfFactory que acaba de ejecutar y agregue | y, a continuación, el comando ConvertTo-FabricResources al final de la línea.

El comando completo debe tener este aspecto:

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

Ejecute el comando . Debería ver una respuesta similar a la siguiente:

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

Seguirá viendo el progreso de la actualización estándar, pero ahora el campo de resultados incluye exportableFabricResources. Eso es lo esperado; obtendrá los recursos de Fabric listos para exportar.

Más adelante obtendrá información sobre el campo resoluciones. Por ahora, el campo de exportación muestra una canalización de Fabric con una actividad Wait.

Si se detiene aquí, este comando actúa como what-If: muestra lo que la actualización crearía y es una buena manera de validar la actualización antes de realizar cambios.

Reúne información de tu espacio de trabajo de Fabric

Antes de exportar la canalización de Fabric, necesitará algunos detalles del área de trabajo de Fabric. Abra un archivo de texto en blanco para copiar los valores que necesitará más adelante.

Abra la experiencia de usuario de Microsoft Fabric y vaya al área de trabajo de Data Factory.
Busque el identificador del área de trabajo y cópielo en el archivo de texto.
Ejecute este comando de PowerShell para obtener el token de acceso de Fabric y almacenarlo para la sesión:
```
$fabricSecureToken = (Get-AzAccessToken -ResourceUrl "https://analysis.windows.net/powerbi/api").Token
```
Sugerencia

Los tokens de acceso expiran después de aproximadamente una hora. Cuando esto suceda, vuelva a ejecutar el comando. Sabrá que el token ha expirado si Export-FabricResources devuelve un error de expiración del token.

Exportar la Fabric Pipeline

Combine todos los detalles recopilados en este comando:

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

Ahora, copie el comando del documento de texto en la ventana de PowerShell y ejecute el comando.

Debería ver una respuesta similar a la siguiente:

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

¡Esto significa que funcionó! La sección exportedFabricResources muestra la nueva canalización y su identificador. Ahora, abre el área de trabajo de Fabric en la interfaz de usuario de Fabric. Actualice la página y verá pipeline1 en la lista. ¡Ábralo y encontrará exactamente lo que espera!

Segunda actualización: Copiar algunos datos

Esta segunda actualización es muy similar a la primera, pero presenta un par de nuevos conceptos:

Conjuntos de datos y Servicios Vinculados
Soluciones

Actualmente, fabric Pipeline Upgrader admite un conjunto limitado de conjuntos de datos, por lo que usaremos conexiones de Azure Blob Storage y conjuntos de datos JSON. Vamos a profundizar.

En ADF Studio, cree una canalización que copie un archivo JSON de una carpeta de Azure Blob Storage a otra. Llamaremos a esta canalización "pipeline2" y la conexión de Azure Blob Storage "BlobStore1", pero de nuevo, puede usar los nombres que quiera.

Ejecute el mismo comando What-If que antes para importar la canalización y compruebe cuál sería el resultado de la migración. Asegúrese de actualizar el nombre de la canalización.

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

En la salida, la canalización es similar a la anterior, pero ahora hay más detalles, incluidos dos exportableFabricResources:

Una para una conexión
Uno para una canalización

Este es un ejemplo de la sección Conexión de la salida:

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

El paso de resolución indica: Find the correct GUID and insert it into the id field of this resource. Por ahora, el identificador es ceros (un GUID vacío). Dado que el exportador no puede resolverlo, la sugerencia proporciona instrucciones sobre cómo resolver el problema.

La sección Pipeline tiene pasos similares:

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

¿Qué hacen estos pasos?

Estos resolve pasos son instrucciones para asignar los servicios vinculados de ADF a las actividades de origen y destino con el identificador de conexión de Fabric correspondiente.

¿Por qué ocurre esto?

El actualizador no puede conocer el identificador de recurso de Fabric de una conexión o canalización hasta que existan esos recursos. Por lo tanto, proporciona una sugerencia sobre cómo crear los recursos necesarios y rellenar el archivo de resolución.

Ahora vamos a exportar el Fabric Pipeline (intento 1)

Si los tokens de acceso han expirado, actualícelas ahora.

Ejecute los mismos pasos que usó en la lección anterior, pero para "pipeline2" esta vez.

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

Esto falla. Esta vez, el Import | Convert | Export comando devuelve algo parecido a:

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

(Si lee el final del último paso, puede reconocer connectionHint).

El error indica que es necesario "agregar el identificador de una conexión a las resoluciones".

¿Qué salió mal?

El Fabric Upgrader no puede crear conexiones de Fabric por sí mismo. Debe ayudarle mediante la creación manual de una conexión de Fabric y, a continuación, indicar al actualizador cuándo usarlo.

Creación de un archivo de resoluciones

En primer lugar, cree un archivo de resoluciones. Puede asignarle un nombre a cualquier cosa y guardarlo donde quiera en el equipo (siempre que PowerShell pueda acceder a él), pero en este tutorial se usa D:\Resolutions.json.
Inicialice el archivo con:
```
[
]
```
A continuación, añade la resolución que falta según la sugerencia que te dio el actualizador. Puede encontrarlo en "plantilla" en la connectionHint sección del mensaje de error.
```
[
    "type": "LinkedServiceToConnectionId",
    "key": "BlobStore1",
    "value": "<Fabric Connection ID>"
]
```
A continuación, debemos encontrar que <Fabric Connection ID>. Para ello, vaya al área de trabajo de Fabric en La experiencia del usuario de Fabric, seleccione el icono de engranaje en la esquina superior derecha y, a continuación, seleccione Administrar conexiones y puertas de enlace.
Si la conexión aún no existe en Fabric, cree una nueva conexión a la misma cuenta de Azure Blob Storage que usa su canalización de ADF. Puede asignarle un nombre a cualquier cosa, pero en este tutorial se usa "myblob".
Después de crear la conexión, mantenga el puntero sobre el botón de puntos suspensivos situado junto al nombre de conexión para mostrar el menú.
Seleccione Configuración en el menú y, a continuación, copie el identificador de conexión y péguelo en el archivo Resoluciones en lugar de <Fabric Connection ID>.

Su archivo de resoluciones debe tener un aspecto similar al siguiente (su value será diferente):

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

Mientras lo haces, puedes añadir un comentario a tu resolución tal como sigue:

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

Cmdlet de Import-FabricResolutions

Puede importar este archivo de resoluciones para comprobar lo que hace.

En PowerShell, ejecute:

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

Debería ver:

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

Se trata de otro objeto de progreso de actualización, pero ahora el campo resolutions se rellena.

Puedes ejecutar Import-FabricResolutions en cualquier punto de la cadena de comandos antesExport-FabricResources. Las resoluciones se llevarán a cabo en pasos posteriores.

Exportación del Fabric Pipeline (intento 2)

Ahora que tenemos un archivo de resoluciones, podemos volver a intentar la exportación después de agregar el Import-FabricResolutions paso.

Actualice el comando agregando Import-FabricResolutions entre Convert y 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

Ejecute el comando en PowerShell.

¡Esta vez, funciona! De nuevo, la sección exportedFabricResources muestra la nueva canalización y su identificador.

Ahora abre tu área de trabajo de Fabric en Fabric UX. Actualice la página y verá pipeline1 en la lista. ¡Ábralo y encontrará exactamente lo que espera!

Pasos siguientes

Ahora que ha actualizado correctamente dos canalizaciones, puede usar lo que ha aprendido para actualizar más canalizaciones.

Para obtener más información sobre los tipos de actividades y conjuntos de datos admitidos, consulte la funcionalidad admitida.
Para obtener más información sobre cómo crear el archivo de resoluciones para distintos tipos de canalizaciones, consulte cómo agregar conexiones al archivo de resoluciones.
Para conocer los pasos generales sobre cómo realizar esta migración mediante PowerShell, consulte: Migración de canalizaciones de Azure Data Factory a Fabric mediante PowerShell.

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2025-09-22