Microsoft Fabric

Migrer des packages SSIS vers Microsoft Fabric : retirer, réhéberger, reconstruire ou repenser

Guide pratique de migration SSIS vers Microsoft Fabric : ce qui correspond à Fabric Data Factory et ce qu’il faut repenser, comment inventorier et évaluer les packages, quand utiliser Invoke SSIS Package (préversion), comment migrer par vagues et basculer sans casser la production.

Par JaviPublié Mis à jour 30 min de lectureIntermédiaire

Dans cet article

La plupart des équipes qui passent à Microsoft Fabric arrivent avec un parc SSIS : des dizaines ou des centaines de packages .dtsx, les jobs SQL Agent qui les lancent, des fichiers de configuration, et quelques packages que personne ne veut toucher. La vraie question n’est pas « quel composant Fabric remplace la Data Flow Task ? ». C’est :

J’ai un parc SSIS existant. Qu’est-ce qui a réellement un équivalent dans Microsoft Fabric, qu’est-ce qui doit être repensé, qu’est-ce qui peut être réutilisé, et comment migrer sans casser la production ?

Le principe de migration. Migrer SSIS vers Microsoft Fabric est rarement une conversion package par package. Chaque package regroupe plusieurs responsabilités : orchestration, ingestion, transformation, état, dépendances, planification, gestion des erreurs et contrôles opérationnels. Le travail consiste à les séparer, à associer chacune au service Fabric qui lui convient, puis à décider, package par package, s’il faut le retirer, le réhéberger, le reconstruire ou le repenser.

Deux faits encadrent tout ce qui suit :

  • Microsoft ne documente aucun convertisseur de .dtsx vers les pipelines Fabric. Des outils de conversion tiers existent ; leur résultat demande quand même l’évaluation et la validation décrites ici.
  • Fabric peut exécuter certains packages existants sans modification, grâce à l’activité Invoke SSIS Package. Elle est en préversion, et ses limites documentées (pas de sources locales, pas de points de terminaison privés, pas de composants personnalisés ou tiers) excluent beaucoup de packages réels.

Ce guide suppose que vous connaissez bien SSIS : packages, flux de contrôle, flux de données, gestionnaires de connexions, paramètres et configurations, planification SQL Agent. Il ne suppose pas que vous connaissez Fabric Data Factory. Les affirmations sur le comportement de Fabric sont documentées par Microsoft et liées dans les Sources ; les recommandations de séquencement, de notation et de conception relèvent des conseils de migration de Javi Builds et sont présentées comme telles.

La réponse courte

Un package SSIS et son job SQL Agent forment une seule unité déployable. Dans Fabric, les mêmes responsabilités se retrouvent en général dans des éléments différents :

  1. Package SSIS + job AgentUn seul .dtsx porte toutes les responsabilités
    • orchestration
      Correspondance prochePipeline Data FactoryFlux de contrôle, dépendances, planifications, nouvelles tentatives
    • ingestion
      Correspondance procheCopy activity · Copy jobDe la source vers OneLake ou le Warehouse, avec un mappage léger
    • transformation
      Correspondance partielleT-SQL · notebook · Dataflow Gen2Choisi selon le type de logique et le volume, pas selon le composant
    • état
      Refonte nécessaireWatermarks · journal d’exécutionRemplace les points de contrôle, la logique de reprise et les tables de log des packages
    • erreurs
      Correspondance partielleChemins d’échec · alertesRemplace les gestionnaires d’événements, les opérateurs et les tâches Send Mail
    • configuration
      Correspondance partielleConnexions · bibliothèques de variablesRemplace les gestionnaires de connexions, les configurations et les environnements
Un package SSIS, plusieurs destinations dans Fabric. Un package et son job Agent regroupent des responsabilités qui aboutissent dans des éléments Fabric différents. L’étiquette indique la qualité de la correspondance ; aucune n’est une conversion de fichier.

Ensuite, décidez du sort de chaque package :

Décision Ce que cela signifie Choisissez-la quand Éléments de preuve nécessaires
Retirer (Retire) Arrêter le package et ne pas le migrer Personne ne consomme sa sortie, il duplique un autre chargement, ou sa source ou sa cible est en cours de mise hors service Aucun consommateur en aval dans l’inventaire ; le responsable valide
Réhéberger (Rehost) Garder l’exécution dans SSIS pour l’instant : Invoke SSIS Package (préversion) dans Fabric, un runtime d’intégration Azure-SSIS dans Azure Data Factory, ou le serveur actuel Le package fonctionne, une réécriture n’apporte encore que peu de valeur, ou il présente un blocage sans remplacement natif dans Fabric aujourd’hui Il passe les contrôles de la préversion, ou il a un blocage documenté et une date de réexamen
Reconstruire (Rebuild) Réimplémenter le même comportement avec des éléments natifs de Fabric La logique est saine, mais le package est bloqué, fragile ou coûteux à garder sur SSIS Des résultats attendus contre lesquels tester
Repenser (Redesign) Changer la forme : périmètres, stockage, modèle de chargement Le problème, c’est la structure : rechargements complets chaque nuit, copies de staging qui n’existent que pour SSIS, longues chaînes de packages Une conception cible plus simple à exploiter et à prouver

La plupart des parcs utilisent les quatre. Beaucoup de packages précieux passent aussi par une période hybride, pendant laquelle Fabric reprend l’orchestration, le déplacement des données et la supervision tandis que SSIS conserve la logique risquée à réécrire. L’hybride est le chemin entre réhéberger et reconstruire, pas une destination :

  1. 1RéhébergerLe package tourne toujours dans SSIS ; Fabric le planifie et le supervise
  2. déplacer une responsabilité
    2HybrideFabric copie les données et gère les alertes ; SSIS garde la transformation risquée
  3. remplacer le reste
    3Reconstruire ou repenserPipeline, T-SQL ou notebooks natifs de Fabric ; runtime SSIS retiré
Le parcours habituel d’un package précieux et complexe. Chaque étape sort une responsabilité de plus de SSIS, et chacune est assez petite pour être validée et annulée. Retirer évite complètement ce parcours.

La carte des responsabilités

Associez des responsabilités, pas des composants. La colonne Correspondance utilise quatre étiquettes :

  • Correspondance proche : la fonction existe dans Fabric et se comporte comme un développeur SSIS s’y attend, avec de petites différences.
  • Correspondance partielle : même objectif, portée ou comportement différents. Utile comme point de départ, dangereuse comme hypothèse.
  • Refonte nécessaire : la fonction doit toujours être assurée, mais le mécanisme SSIS n’existe pas. Concevez-la à nouveau à partir du besoin.
  • Aucun équivalent direct : rien dans Fabric ne fournit cela. Supprimez le besoin.
Responsabilité SSIS Destination ou approche Fabric Correspondance Points d’attention
Orchestration (flux de contrôle, contraintes de précédence, conteneurs) Pipeline Data Factory : activités, conditions de dépendance (en cas de réussite, d’échec, d’achèvement, d’omission), If Condition, ForEach, Until Correspondance proche Les contraintes de précédence fondées sur des expressions deviennent des activités If Condition. Une activité avec plusieurs dépendances en amont les attend toutes
Planification (SQL Agent) Planifications de pipeline (jusqu’à 20 par pipeline), déclencheurs d’événements sur les fichiers, les jobs et l’espace de travail ; planifications propres aux notebooks, Copy jobs et dataflows Correspondance partielle Il n’existe pas d’objet de planification partagé qui lance plusieurs pipelines. Les opérateurs, proxies et la logique d’étapes d’Agent ne suivent pas
Ingestion depuis une base (source OLE DB ou ADO.NET vers une destination) Copy activity ou Copy job, via une passerelle de données locale ou une passerelle de réseau virtuel si nécessaire Correspondance proche L’authentification change souvent. Fabric Warehouse n’accepte que Microsoft Entra ID
Ingestion de fichiers (FTP ou SFTP, partages de fichiers, fichiers plats) Copy activity ou Copy job vers les Files ou les tables d’un Lakehouse ; un notebook quand l’analyse dépasse ce que Copy sait exprimer Correspondance partielle Les lettres de lecteur et les chemins UNC n’ont aucun sens dans Fabric. Les partages locaux exigent une passerelle
Transformations (composants de flux de données) T-SQL du Warehouse pour la logique ensembliste, Dataflow Gen2 pour une mise en forme de type Power Query, notebooks pour une logique volumineuse ou très codée Correspondance partielle Choisissez selon le type de logique et le volume. Spark n’est pas nécessaire pour chaque transformation
Exécution de procédures stockées (Execute SQL Task) Activité Script ou Stored procedure sur un Fabric Warehouse, une base de données SQL dans Fabric, ou une connexion SQL Server ou Azure SQL externe Correspondance proche Le T-SQL de Fabric Warehouse diffère : pas de déclencheurs, pas de requêtes récursives, contraintes NOT ENFORCED
Variables de package Variables et paramètres de pipeline ; paramètres de notebook Correspondance proche Les variables ont pour portée l’exécution du pipeline ; il n’y a pas de variables à portée de conteneur
Paramètres et configurations (.dtsConfig, paramètres de projet, environnements SSISDB) Paramètres de pipeline plus une bibliothèque de variables par environnement Correspondance partielle Seul .dtsConfig est une entrée documentée lorsque vous réhébergez avec Invoke SSIS Package
Gestionnaires de connexions Connexions Fabric (cloud ou passerelle) ; substitutions dans l’onglet Connection Managers pour un package réhébergé Correspondance partielle Les identifiants vivent dans la connexion, pas dans le package
Journalisation (fournisseurs de log, rapports SSISDB) Hub de supervision et historique des exécutions de pipeline, plus votre propre journal d’exécution Correspondance partielle L’historique dit qu’une exécution a eu lieu, pas ce qu’elle a chargé
Nouvelles tentatives Nombre et intervalle de nouvelles tentatives par activité ; boucles de reprise explicites pour des étapes entières Correspondance proche Une nouvelle tentative n’est sûre que si l’étape est idempotente
Points de contrôle (checkpoints) Étapes idempotentes, état durable dans des tables de watermark ou de contrôle, logique de reprise explicite Refonte nécessaire Il n’y a pas de fichiers de point de contrôle. Voir Points de contrôle
Transactions (TransactionOption, MSDTC) Transactions du Warehouse au sein d’un seul moteur ; chargements par étapes et idempotents entre les étapes Aucun équivalent direct Un pipeline ne peut pas englober plusieurs activités dans une seule transaction. Voir Transactions
Script Task Une expression de pipeline, un notebook, l’activité Functions (User data functions) ou un service hors de Fabric, selon ce que fait le script Refonte nécessaire Réécrivez l’intention, pas le C#. Voir Script Tasks
Execute Package Task Invoke pipeline (pipeline enfant), ou un pipeline parent plus plat Correspondance partielle Redessinez la chaîne avant de la reconstruire. Voir Chaînes de packages
Gestionnaires d’événements (OnError, OnTaskFailed) Chemins de dépendance en cas d’échec, activité Fail, activités Office 365 Outlook ou Teams, alertes issues de la supervision Correspondance partielle Pas de propagation d’événements : chaque chemin est câblé explicitement. Une activité Outlook reliée à plusieurs activités en échec ne se déclenche que si toutes échouent
Déploiement (ISPAC, dossiers SSISDB) Intégration Git et pipelines de déploiement, ou fabric-cicd Correspondance partielle Les Files du Lakehouse, où vivent les packages réhébergés, ne sont pas suivis par Git

Pour les tâches et composants qui reviennent le plus souvent :

Tâche ou composant SSIS Approche Fabric probable Remarques
Data Flow Task, déplacement seul Copy activity ou Copy job Bon choix quand le flux va de la source à la destination avec un mappage léger
Data Flow Task, transformation lourde Atterrir d’abord, puis T-SQL du Warehouse, Dataflow Gen2 ou notebook Lookups, colonnes dérivées et conversions deviennent en général du SQL ensembliste
OLE DB Destination vers un Fabric Warehouse Copy activity, ou COPY INTO depuis des fichiers déposés OLE DB Destination ne fonctionne pas avec Fabric Warehouse
Flat File Source Fichiers dans un Lakehouse ou ADLS Gen2, lus par Copy activity, notebook ou Dataflow Gen2 Encodages, délimiteurs et lignes d’en-tête demandent des paramètres explicites
File System Task Copy activity (copie binaire), activité Delete, opérations sur fichiers dans un notebook L’archivage devient une convention de chemin, pas un déplacement de dossier sur un serveur
Foreach Loop Container Activité ForEach sur la sortie d’un Get Metadata ou d’un Lookup Vérifiez le nombre de lots ; une boucle par fichier est souvent mieux remplacée par une copie au niveau du dossier
Sequence Container Activités regroupées, ou un pipeline enfant Les pipelines enfants rendent la réutilisation explicite
Send Mail Task Activité Office 365 Outlook ou Teams, ou alertes issues de la supervision Les connexions authentifiées par utilisateur doivent être recréées dans chaque espace de travail
Script Component T-SQL ensembliste, ou un notebook Une logique ligne par ligne s’exprime généralement mieux de façon ensembliste

Avant de choisir où s’exécutent les transformations, Pipelines vs notebooks dans Microsoft Fabric (en anglais) traite du choix de l’outil et Lakehouse ou Warehouse dans Microsoft Fabric de l’endroit où les données doivent vivre. Pour la transposition plus large des concepts SQL Server (instance, base de données, SQL Agent, Query Store), lisez De SQL Server à Microsoft Fabric : quel concept correspond à quoi ?.

Fabric ne rend pas bonne une mauvaise conception SSIS. Un package qui recharge tout chaque nuit, avale les erreurs et n’a pas de logique de reprise fera exactement la même chose dans Fabric. La migration est le moment de corriger ces points, ou au moins de les documenter.

Inventaire et évaluation

Faites-le avant de toucher au moindre package. L’inventaire transforme « migrer SSIS » d’un projet flou en une liste de décisions.

Pour chaque package, notez :

Domaine Ce qu’il faut relever Pourquoi c’est important
Identité et objectif Nom, emplacement (système de fichiers, dossier et projet SSISDB, MSDB), une phrase sur ce qui casse s’il s’arrête Les packages hors du système de fichiers doivent être exportés ; l’objectif fixe la priorité
Responsable Une personne ou une équipe nommée Quelqu’un doit valider le retrait ou la bascule
Sources Serveur, base de données, emplacement de fichier ou API, et où chacun se trouve (cloud, local, réseau privé) Les sources locales et privées bloquent Invoke SSIS Package aujourd’hui
Destinations Même niveau de détail que pour les sources Les destinations Fabric Warehouse exigent l’authentification Entra et COPY INTO
Fréquence et déclencheur Planification, arrivée de fichier, job en amont, lancement manuel Détermine planification, déclencheur d’événement ou pipeline parent
Dépendances Packages et jobs qui doivent s’exécuter avant ou après ; tables de staging partagées Ordre de bascule et regroupement en vagues
Gestionnaires de connexions Type (OLE DB, ADO.NET, Flat File, Azure Storage…), fournisseur, authentification Les changements de fournisseur et d’authentification sont fréquents
Paramètres, variables et configurations Paramètres de package et de projet, .dtsConfig, variables d’environnement, registre, configurations SQL Server, environnements SSISDB Deviennent des paramètres de pipeline, des bibliothèques de variables ou des substitutions de propriétés
Execute SQL Tasks Nombre, et s’ils appellent des procédures ou exécutent du SQL en ligne En général une correspondance proche ; vérifiez la compatibilité T-SQL avec Fabric Warehouse
Flux de données Nombre, composants, volumes de lignes Oriente vers Copy, T-SQL, Dataflow Gen2 ou notebook
Script Tasks et Script Components Langage, objectif, assemblys référencés En général la partie la plus difficile à remplacer
Composants personnalisés ou tiers Tâches, composants, gestionnaires de connexions Bloquent Invoke SSIS Package aujourd’hui
Exécutables externes Cibles d’Execute Process Task, PowerShell, outils en ligne de commande Il leur faut un nouvel emplacement ; Fabric n’a pas de serveur pour les exécuter
Dépendances au système de fichiers Chemins locaux, partages UNC, lecteurs mappés, dossiers d’archive Il faut un emplacement cloud comme les Files d’un Lakehouse ou ADLS Gen2
Points de contrôle et reprise SaveCheckpoints, fichiers de point de contrôle, manière dont les opérateurs relancent un chargement en échec Exigent une refonte idempotente
Transactions Conteneurs avec TransactionOption = Required, usage de MSDTC Aucun équivalent direct
Gestionnaires d’erreurs Gestionnaires d’événements, chemins de précédence en cas d’échec, personnes notifiées Doivent être reproduits ou améliorés explicitement
Niveau de protection Paramètre actuel Les niveaux à clé utilisateur échouent hors du profil de l’auteur
Mécanisme de planification Job SQL Agent (étapes, planifications, opérateurs, proxies), planificateur Windows, autre orchestrateur Voir SQL Agent
Historique d’exécution Exécutions, échecs, durée habituelle et pire cas, lignes et octets par exécution SLA, coût, et la référence de validation
SLA en aval et consommateurs Quand les données doivent être prêtes ; rapports, extractions et systèmes qui les lisent Calendrier de bascule, périmètre de validation, et candidats au retrait

Automatisez ce qui peut l’être. Le format .dtsx est du XML, donc les tâches, composants de flux de données, gestionnaires de connexions, niveaux de protection, points de contrôle, transactions et gestionnaires d’événements peuvent être extraits sur tout le parc. Ce script PowerShell en lecture seule écrit une ligne CSV par package :

# Inventory every .dtsx under a folder: tasks, data-flow components, connections and risk flags.
# Read-only. Packages saved with EncryptAll* protection levels are encrypted and report no tasks.
param([string]$Root = '.', [string]$Out = '.\ssis-inventory.csv')

$ns = @{ DTS = 'www.microsoft.com/SqlServer/Dts' }
function Count-Values($values) { ($values | Group-Object | Sort-Object Count -Descending | ForEach-Object { "$($_.Name)=$($_.Count)" }) -join '; ' }

Get-ChildItem -Path $Root -Filter *.dtsx -Recurse | ForEach-Object {
    [xml]$xml = Get-Content -LiteralPath $_.FullName -Raw
    $pkg = $xml.DocumentElement
    $attr = { param($xpath, $name) Select-Xml -Xml $xml -XPath $xpath -Namespace $ns | ForEach-Object { $_.Node.GetAttribute($name, $ns.DTS) } }

    $tasks = & $attr '//DTS:Executable' 'ExecutableType' | Where-Object { $_ -ne 'Microsoft.Package' }
    $components = Select-Xml -Xml $xml -XPath '//component' | ForEach-Object { $_.Node.GetAttribute('componentClassID') }

    [pscustomobject]@{
        Package            = $_.FullName
        ProtectionLevel    = $pkg.GetAttribute('ProtectionLevel', $ns.DTS)   # empty = 1 (EncryptSensitiveWithUserKey)
        Checkpoints        = $pkg.GetAttribute('SaveCheckpoints', $ns.DTS) -eq 'True'
        RequiredTxScopes   = @(Select-Xml -Xml $xml -XPath "//*[@DTS:TransactionOption='2']" -Namespace $ns).Count
        EventHandlers      = (& $attr '//DTS:EventHandler' 'EventName' | Sort-Object -Unique) -join '; '
        Tasks              = Count-Values $tasks
        NonMicrosoftTasks  = Count-Values ($tasks | Where-Object { $_ -notmatch '^(Microsoft\.|STOCK:)' })
        DataFlowComponents = Count-Values $components
        Connections        = Count-Values (& $attr '//DTS:ConnectionManager' 'CreationName')
    }
} | Export-Csv -Path $Out -NoTypeInformation

Lisez le résultat avec attention. NonMicrosoftTasks liste les tâches dont le type n’est pas une tâche ou un conteneur SSIS intégré : commencez par là l’examen des composants personnalisés. Un Script Component et un composant de flux de données .NET personnalisé apparaissent tous deux comme Microsoft.ManagedComponentHost ; ouvrez donc ces packages. Le script lit le format de package utilisé depuis SQL Server 2012 ; les formats plus anciens demandent un autre analyseur.

Pour les packages déployés dans le catalogue SSIS, l’historique d’exécution se trouve déjà dans SSISDB. Cette requête le résume sur les 90 derniers jours par package :

Requête SQL: Inventaire et évaluationT-SQL (Fabric Warehouse)
-- Runs, failures and duration per package over the last 90 days (SSIS Catalog only).
SELECT folder_name,
       project_name,
       package_name,
       COUNT(*)                                                  AS runs,
       SUM(CASE WHEN status IN (4, 6) THEN 1 ELSE 0 END)         AS failed_runs,  -- 4 failed, 6 ended unexpectedly
       AVG(DATEDIFF(SECOND, start_time, end_time))               AS avg_seconds,
       MAX(DATEDIFF(SECOND, start_time, end_time))               AS max_seconds,
       MAX(start_time)                                           AS last_run
FROM SSISDB.catalog.executions
WHERE start_time >= DATEADD(DAY, -90, SYSDATETIMEOFFSET())
GROUP BY folder_name, project_name, package_name
ORDER BY runs DESC;
T-SQL (Fabric Warehouse)13 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Un package qui ne s’est pas exécuté depuis 90 jours, ou dont personne ne sait nommer un consommateur, est candidat au retrait avant d’être candidat à la migration. Consacrez le temps humain à l’objectif métier, aux responsables, aux SLA et aux consommateurs en aval, qu’aucun script ne trouvera.

Évaluer la complexité de migration

Évaluez chaque package d’après son signal le plus difficile, pas d’après la moyenne. Un seul composant personnalisé rend un package de complexité élevée, quel que soit le reste.

Complexité Signaux typiques Décision habituelle
Faible Copie des données ou des fichiers entre systèmes accessibles ; Execute SQL Tasks simples ; flux de contrôle linéaire ; aucun composant personnalisé ; authentification prise en charge Reconstruire en natif, ou réhéberger s’il passe tous les contrôles de la préversion
Moyenne Plusieurs dépendances ; vraies transformations ; paramètres et configurations ; flux conditionnels ; quelques Script Tasks à l’objectif clair ; sources locales Reconstruire, souvent après une courte période hybride
Élevée Composants personnalisés ou tiers ; Script Tasks complexes ; transactions au niveau du package ; couplage fort aux partages de fichiers ou au serveur local ; dépendances COM ou natives ; chaînes Execute Package profondes ; points de contrôle ou gestionnaires d’événements complexes Réhéberger ou hybride d’abord, puis repenser ; jamais dans la première vague

Croisez la complexité avec la criticité métier pour placer chaque package dans une vague. Les packages de faible complexité et de faible criticité passent en premier, parce qu’ils apprennent la plateforme à l’équipe. Les packages de complexité et de criticité élevées passent en dernier, avec le plus de données de test.

Réhéberger : exécuter les packages que vous gardez

Réhéberger conserve la logique du package telle quelle et change l’endroit où il s’exécute ou ce qui l’orchestre. Il y a trois façons de le faire :

Option Où s’exécute le package Quand elle convient
Invoke SSIS Package (préversion) Un runtime SSIS géré par Fabric, depuis un pipeline Fabric Le package passe tous les contrôles de la préversion
Runtime d’intégration Azure-SSIS Azure Data Factory, appelé depuis Fabric avec l’activité Invoke pipeline Le package a besoin d’un réseau local ou privé, ou de composants personnalisés installés par configuration personnalisée
Le laisser où il est Le SQL Server et le SQL Agent actuels Un blocage n’a pas encore de remplacement, ou le package sera bientôt retiré ; notez la raison et une date de réexamen

Invoke SSIS Package (préversion)

Le déroulement, tel que Microsoft le documente actuellement :

  1. Téléversez le package dans OneLake. Placez le .dtsx, et son .dtsConfig s’il en a un, dans un dossier Files d’un Lakehouse comme Files/ssis-packages/, avec Upload → Upload files ou l’explorateur de fichiers OneLake.
  2. Ajoutez l’activité. Dans un pipeline Fabric, cherchez Invoke SSIS Package dans le volet Activities.
  3. Choisissez le package. Dans l’onglet Settings, sélectionnez Browse à côté de Package path.
  4. Ajoutez la configuration, le cas échéant. Sélectionnez le .dtsConfig dans Configuration path (facultatif).
  5. Fournissez les valeurs d’exécution. Substituez les propriétés des gestionnaires de connexions dans l’onglet Connection Managers (Scope, Name, Property, Value), et les propriétés ou variables du package dans l’onglet Property Overrides, par exemple \Package.Variables[User::<variable name>].Value. Les substitutions acceptent les expressions, paramètres et variables système du pipeline : c’est ainsi qu’un même package sert plusieurs environnements ou dates.
  6. Activez la journalisation (Enable logging) pour que les journaux d’exécution du package soient écrits dans OneLake ; la sortie de l’activité contient le chemin des journaux.
  7. Exécutez ou planifiez le pipeline, et suivez-le dans l’onglet Output du pipeline ou dans le hub Monitor.

L’onglet General de l’activité porte les réglages habituels de délai d’expiration, de nouvelles tentatives et d’intervalle entre tentatives.

Limites de la préversion

Préversion. L’activité Invoke SSIS Package est en préversion. Les fonctionnalités en préversion peuvent être limitées et changer avant la disponibilité générale. Vérifiez la documentation actuelle avant de planifier un travail de production autour d’elle.

Microsoft documente ces limites pour la préversion. Un package qui en rencontre une ne peut pas s’exécuter par l’activité aujourd’hui :

  • OneLake uniquement. Les packages du catalogue SSIS (SSISDB) ou de MSDB doivent être exportés en fichiers .dtsx puis téléversés.
  • Pas de sources ni de destinations locales.
  • Pas de points de terminaison en réseau privé, comme les ressources injectées dans un VNet ou exposées par point de terminaison privé.
  • Pas de composants personnalisés ou tiers.
  • Runtime fixe. Chaque espace de travail dispose de 4 vCores pour l’exécution SSIS, non modifiables pendant la préversion, et le runtime reste actif pendant une durée de vie fixe de 30 minutes après la fin de la dernière activité.

Regardez ce que cela exclut dans un parc typique : tout ce qui lit un SQL Server local, tout ce qui écrit sur un partage de fichiers, tout ce qui utilise un connecteur éditeur, tout ce qui se trouve dans un réseau verrouillé. Pour beaucoup d’organisations, c’est la majorité de leurs packages. Inventoriez d’abord, décidez ensuite ; ne découvrez pas ces limites pendant la bascule.

Les tutoriels de Microsoft montrent ce que l’activité peut atteindre : une base de données SQL dans Fabric (principal de service Microsoft Entra avec le gestionnaire de connexions OLE DB), ADLS Gen2 exposé dans OneLake par un raccourci, et Fabric Data Warehouse (authentification Microsoft Entra plus COPY INTO). Deux détails comptent pour la planification :

  • Fabric Data Warehouse n’accepte que l’authentification Microsoft Entra ID. Un package qui se connecte en authentification SQL ou Windows doit voir ses gestionnaires de connexions modifiés.
  • OLE DB Destination ne fonctionne pas avec Fabric Data Warehouse. Microsoft recommande de déposer les données dans ADLS Gen2 puis de les charger avec COPY INTO depuis une Execute SQL Task. Un package construit autour d’une OLE DB Destination vers l’entrepôt demande de vrais changements avant de pouvoir être « déplacé tel quel ».

Les fonctionnalités du modèle de déploiement de projet (paramètres de projet, gestionnaires de connexions de projet, environnements SSISDB) ne sont pas décrites dans la documentation de l’activité. Testez-les avec un vrai package avant de bâtir un plan dessus.

Runtimes d’intégration et passerelles

Si vos packages s’exécutent aujourd’hui sur un runtime d’intégration Azure-SSIS, ou si vos pipelines ADF utilisent des runtimes d’intégration auto-hébergés ou compatibles VNet, ces concepts ne se transposent pas un pour un. Les recommandations de Microsoft pour la mise à niveau d’ADF vers Fabric les associent ainsi :

Azure Data Factory Fabric Remarques
Runtime d’intégration Azure (réseau public) Rien à déplacer Fabric exécute le calcul cloud sur votre capacité
Runtime d’intégration auto-hébergé Passerelle de données locale À recréer sous forme de passerelles ; prévoyez dimensionnement et basculement
Runtime d’intégration Azure compatible VNet Passerelle de données de réseau virtuel Déployée dans votre propre réseau virtuel
Runtime d’intégration Azure-SSIS Non disponible dans Fabric L’option SSIS de Fabric est l’activité Invoke SSIS Package, avec son propre runtime géré

Les passerelles servent des charges Fabric précises. Microsoft indique la passerelle de données locale pour les pipelines, Copy job, Dataflow Gen2 et la mise en miroir, entre autres, avec une prise en charge définie connecteur par connecteur. La documentation d’Invoke SSIS Package ne décrit pas de prise en charge des passerelles et indique que l’activité ne peut pas atteindre les systèmes locaux ou en réseau privé. Ne supposez pas qu’installer une passerelle permet à un package réhébergé de lire votre SQL Server local.

Les pages de Microsoft n’en sont pas au même stade. La comparaison entre ADF et Fabric indique toujours les runtimes d’intégration Azure-SSIS comme « à déterminer », et les recommandations de mise à niveau suggèrent d’exécuter les packages SSIS dans ADF et de les appeler depuis Fabric. L’article dédié décrit l’activité en préversion. Considérez l’article dédié comme la référence sur ce que fait l’activité, et les recommandations de mise à niveau comme la description du pont ADF.

Pour un package local, les options sont donc : reconstruire le déplacement dans Fabric (Copy activity ou Copy job via une passerelle, puis transformation dans Fabric), déposer les données dans un emplacement cloud que le package peut lire et ne réhéberger que la transformation, ou garder le package sur un runtime d’intégration Azure-SSIS et l’orchestrer avec l’activité Invoke pipeline.

Valeurs sensibles et niveaux de protection

Les niveaux de protection décident si un package peut s’exécuter hors de la machine et de l’utilisateur qui l’ont enregistré. Vérifiez chaque package avant de le téléverser :

Niveau de protection Ce qui se passe quand le package passe dans Fabric
DontSaveSensitive Les valeurs sensibles ne sont pas stockées. Fournissez-les à l’exécution dans l’onglet Connection Managers ; Microsoft mentionne explicitement ce cas.
EncryptSensitiveWithPassword / EncryptAllWithPassword Le package a besoin de son mot de passe. Les tutoriels SSIS de Microsoft montrent un réglage facultatif Encryption password ; il ne figure pas sur la page principale de l’activité, vérifiez-le donc dans votre tenant.
EncryptSensitiveWithUserKey / EncryptAllWithUserKey Chiffré avec la clé de l’utilisateur Windows qui l’a enregistré. Un autre utilisateur ne peut pas déchiffrer les valeurs sensibles, et l’exécution échoue. Réenregistrez d’abord avec un autre niveau.
ServerStorage Utilisé par SSISDB et MSDB. Un projet exporté du catalogue vers le système de fichiers passe en EncryptSensitiveWithUserKey ; les packages exportés doivent donc aussi être réenregistrés.

DontSaveSensitive avec des substitutions à l’exécution est le modèle le plus propre : le fichier ne contient aucun secret, et les identifiants sont gérés à un seul endroit. Ne téléversez jamais un package contenant des identifiants en clair dans un Lakehouse partagé ; toute personne ayant accès aux fichiers peut les lire.

Modèle de coût

Microsoft facture l’activité sur le temps d’activité SSIS dans l’espace de travail, avec le compteur « SSIS in Fabric », à 1,35 CU-heure par vCore. Ce temps démarre quand la première activité Invoke SSIS Package de l’espace de travail démarre, continue tant qu’au moins une est en cours, et dure encore la durée de vie fixe de 30 minutes après la fin de la dernière. L’orchestration des pipelines ainsi que le stockage et les transactions OneLake sont facturés sur leurs propres compteurs. Conséquences pour la conception :

  • Des packages courts et dispersés coûtent plus cher qu’il n’y paraît. Un package de 2 minutes lancé toutes les heures garde le runtime actif environ 32 minutes par heure.
  • Regrouper les exécutions aide. Les packages qui démarrent à peu près en même temps partagent une même fenêtre d’activité.
  • Le temps d’activité SSIS puise dans la même capacité que vos notebooks, entrepôts et rapports. La capacité Microsoft Fabric expliquée (en anglais) montre comment cette consommation apparaît, et le Fabric Capacity Planner (en anglais) aide à juger la marge disponible.

Consultez la page de tarification actuelle avant toute estimation ; les tarifs de préversion peuvent changer.

Hybride : moderniser autour de SSIS

La stratégie hybride garde les parties de SSIS coûteuses ou risquées à réécrire et déplace tout le reste autour d’elles vers Fabric. Formes typiques :

  • Fabric orchestre le package. Un pipeline l’exécute, puis enchaîne les étapes en aval : une procédure du Warehouse, une actualisation de modèle sémantique, une notification.
  • Fabric déplace les données, SSIS les transforme. Une Copy activity ou un Copy job dépose les données sources dans le cloud, et le package ne fait plus que la transformation pour laquelle il était bon.
  • Fabric prend la supervision. Les exécutions de pipeline, le hub de supervision et un journal d’exécution partagé remplacent les tables de log du package comme source de vérité opérationnelle.
  • Modèle de l’étrangleur (strangler). Chaque livraison sort une responsabilité de plus du package (d’abord l’extraction, puis un lookup, puis le chargement) jusqu’à ce qu’il soit assez petit pour être retiré.

Pourquoi cela réduit le risque : vous changez une chose à la fois, la logique risquée continue de tourner dans le moteur où elle a été testée, la planification et la supervision de Fabric arrivent tôt, et un retour arrière ramène une seule responsabilité au lieu de restaurer tout un parc ETL. Le coût est une période avec deux technologies à exploiter. Donnez à chaque package hybride un responsable et un état cible, et suivez la quantité de logique SSIS restante.

Reconstruire et repenser

Reconstruire garde le comportement et change l’implémentation : mêmes entrées, mêmes sorties et mêmes règles métier, réalisées avec des pipelines, une Copy activity ou un Copy job, Dataflow Gen2, des notebooks et du T-SQL de Warehouse, comme dans la carte des responsabilités. Reconstruisez quand le package est très scripté, dépend de composants non pris en charge, s’appuie sur un comportement propre au serveur, échoue souvent, ou est bloqué par les limites de la préversion alors que le pont ADF ne vaut pas son coût d’exploitation.

Repenser change la forme. C’est le bon choix quand la structure du package existe à cause de SSIS, pas à cause du métier :

  • Les rechargements complets nocturnes deviennent des chargements incrémentiels avec watermarks et MERGE (en anglais).
  • Les bases de staging et les tables copies de copies se réduisent à une seule zone d’atterrissage dans OneLake que d’autres charges peuvent réutiliser.
  • Les boucles par fichier deviennent des copies au niveau du dossier et un traitement ensembliste de tout ce qui est arrivé.
  • Les périmètres des packages suivent les produits de données et les SLA plutôt que l’organisation du projet du développeur d’origine.
  • La gestion des erreurs et la journalisation deviennent un journal d’exécution partagé plutôt qu’une table de log par package.

Repenser coûte plus au départ et exige les preuves de test les plus solides, parce que la forme des sorties peut changer. Ne repensez pas la conception et ne changez pas les règles métier dans la même livraison : prouvez d’abord que la nouvelle conception reproduit les anciens chiffres.

Exemple détaillé : un fichier partenaire quotidien

Un package anonymisé et générique, du type que contiennent la plupart des parcs. Chaque nuit, un job SQL Agent lance à 06:00 LoadPartnerSettlements.dtsx :

  1. Une tâche SFTP tierce télécharge le fichier du jour vers un partage UNC, \\<file-share>\inbound\.
  2. Une Script Task vérifie que le fichier existe, que l’en-tête est correct et que le nombre de lignes de la ligne de fin correspond.
  3. Dans un Sequence Container avec TransactionOption = Required (MSDTC), une Execute SQL Task vide stg.Settlement, et un Data Flow (Flat File Source → Derived Column → Data Conversion → Lookup → OLE DB Destination) la charge.
  4. Une Execute SQL Task exécute etl.usp_LoadSettlement, qui fusionne le staging dans dbo.Settlement et recalcule rpt.DailySettlement sur un SQL Server local.
  5. Une File System Task déplace le fichier vers un dossier d’archive.
  6. Une Send Mail Task prévient l’équipe finance que les totaux sont prêts ; un gestionnaire d’événements OnError envoie un courriel au support.
  7. Les points de contrôle sont activés, pour qu’un opérateur puisse relancer à partir de la tâche en échec.

Pourquoi on ne peut pas simplement le réhéberger

Avec Invoke SSIS Package (préversion), il échoue à trois contrôles : un composant tiers, un partage UNC et une destination locale. Il pourrait être réhébergé sur un runtime d’intégration Azure-SSIS (configuration personnalisée pour le composant SFTP, accès réseau au partage et au serveur) et orchestré depuis Fabric. C’est un pont valable, mais chacune de ces dépendances existerait toujours après.

La conception Fabric

  • SSIS existantUn package, un job Agent
    1. SQL Agent à 06:00
    2. Tâche tierceSFTP vers partage UNC
    3. Validation par Script Task
    4. Transaction MSDTCVidage + flux de données
    5. usp_LoadSettlement
    6. Archivage, Send Mail
    7. SuppriméReprise par point de contrôle
  • Microsoft FabricUn pipeline, l’état dans des tables
    1. Planification ou déclencheur
    2. ModifiéCopy activity depuis SFTPDépose dans les Files du Lakehouse sous un chemin daté
    3. ValiderGet Metadata plus un Lookup ou une vérification en notebook
    4. Charger le stagingCopy activity ou COPY INTO dans le Warehouse
    5. Doit être idempotentProcédure de chargement idempotenteRemplace une date métier dans une seule transaction
    6. Ligne de journal d’exécutionFichier, lignes, totaux, statut
    7. Alerte sur échec ou retard
Le chargement du fichier partenaire, avant et après. Pas une conversion tâche par tâche. Lisez chaque colonne de haut en bas ; les étapes mises en évidence sont celles où la conception a changé, et le côté Fabric n’a ni point de contrôle ni étape MSDTC.
Catégorie Dans cet exemple
Identique sur le principe Télécharger, valider, déposer en staging, calculer, notifier. Les règles métier de usp_LoadSettlement, portées en T-SQL de Warehouse et testées contre les anciennes sorties
Modifié Téléchargement SFTP (Copy activity, connecteur SFTP intégré) ; emplacement d’atterrissage (Files du Lakehouse, chemin daté) ; validation (Get Metadata plus une vérification, au lieu de C#) ; destination (Fabric Warehouse, authentification Entra) ; notifications (activité Outlook ou Teams, plus alertes de supervision)
Supprimé Le composant SFTP tiers, le partage UNC, la transaction MSDTC, les fichiers de point de contrôle, le déplacement vers l’archive (le chemin daté d’atterrissage sert d’archive)
Doit devenir idempotent La procédure de chargement, pour que relancer une date métier donne le même résultat ; le chargement du staging, pour qu’une nouvelle tentative ne duplique pas de lignes ; le journal d’exécution, indexé par exécution et par fichier

Le chargement idempotent remplace à la fois la transaction MSDTC et le point de contrôle. Toutes ses écritures ont lieu dans un seul moteur, donc une transaction du Warehouse suffit, et une réexécution remplace la date métier au lieu de s’y ajouter :

Requête SQL: La conception FabricT-SQL (Fabric Warehouse)
CREATE PROCEDURE etl.load_settlement
    @business_date date,
    @source_file   varchar(200)
AS
BEGIN
    BEGIN TRY
        BEGIN TRANSACTION;

        DELETE FROM dbo.settlement WHERE business_date = @business_date;

        INSERT INTO dbo.settlement (business_date, partner_id, amount, source_file)
        SELECT business_date, partner_id, amount, @source_file
        FROM stg.settlement
        WHERE business_date = @business_date;

        DELETE FROM rpt.daily_settlement WHERE business_date = @business_date;

        INSERT INTO rpt.daily_settlement (business_date, partner_id, total_amount, row_count)
        SELECT business_date, partner_id, SUM(amount), COUNT(*)
        FROM dbo.settlement
        WHERE business_date = @business_date
        GROUP BY business_date, partner_id;

        COMMIT TRANSACTION;
    END TRY
    BEGIN CATCH
        IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION;
        THROW;
    END CATCH;
END;
T-SQL (Fabric Warehouse)30 lignesAffichage en lecture seule. Aucune connexion à une base de données.

Le parcours hybride de ce package déplace d’abord les responsabilités les plus sûres : le téléchargement SFTP et les alertes dans le pipeline, puis la validation, puis le chargement. Chaque étape est une livraison avec sa propre exécution en parallèle.

Comparaison des options :

Invoke SSIS Package Pont via le runtime Azure-SSIS Natif Fabric
Fonctionne aujourd’hui Non : trois blocages de la préversion Oui, avec configuration personnalisée et accès réseau Oui
Effort de réécriture — Faible Moyen à élevé
Plateformes à exploiter — Fabric + ADF + SSIS Fabric seulement
Modèle de reprise — Points de contrôle, comme avant Idempotent par date métier
Données réutilisables dans OneLake — Non Oui : fichiers déposés et tables du Warehouse
Pertinence à long terme — Transitoire État cible

Les zones de migration les plus difficiles

C’est là que les migrations SSIS dérapent. Trouvez-les dans l’inventaire, pas pendant la bascule.

Script Tasks

« Remplacer chaque Script Task par un notebook » est la mauvaise règle. Classez chaque script selon ce qu’il fait, puis choisissez :

Le script… Remplacement habituel
Définit des variables, construit des noms de fichiers ou des dates Une expression de pipeline ou une activité Set Variable
Vérifie l’existence d’un fichier, sa taille ou son horodatage Activité Get Metadata, If Condition
Valide le contenu d’un fichier ou analyse un format inhabituel Un notebook, ou Dataflow Gen2 pour les formes tabulaires
Appelle une API REST Activité Web, Copy activity avec le connecteur REST, ou un notebook
Contient une logique métier en C# T-SQL du Warehouse ou un notebook, réécrit à partir du besoin et testé
Appelle un objet COM, un exécutable local ou l’API Windows Un service hors de Fabric (par exemple Azure Functions), ou une refonte qui supprime la dépendance
Petite logique réutilisable appelée depuis des pipelines User data functions, via l’activité Functions

Réécrivez l’intention, pas le C#. Beaucoup de Script Tasks existent parce que SSIS n’avait pas de moyen intégré de faire ce qu’une activité de pipeline fait aujourd’hui.

Composants personnalisés et tiers

Les adaptateurs tiers (SFTP, SharePoint, REST, bases de données d’éditeurs), les composants de flux de données personnalisés, les gestionnaires de connexions personnalisés et tout ce qui installe des pilotes natifs sur le serveur SSIS bloquent Invoke SSIS Package aujourd’hui. Pour chacun, vérifiez si un connecteur Fabric couvre la même source ; sinon, les options sont un runtime d’intégration Azure-SSIS avec configuration personnalisée, un notebook avec une bibliothèque, ou un service hors de Fabric. Vérifiez aussi les licences : un composant d’éditeur licencié par serveur ne suit pas le package vers un nouveau runtime.

Transactions

Les transactions SSIS avec TransactionOption = Required enrôlent toutes les tâches d’un conteneur dans une même transaction MSDTC, même sur plusieurs connexions. Les pipelines Fabric n’ont rien de comparable : chaque activité valide de son côté, et un échec au milieu d’un pipeline laisse en place le travail des activités précédentes.

Fabric Warehouse prend en charge les transactions multi-instructions, en isolation snapshot, à l’intérieur de l’entrepôt. La refonte consiste donc à placer les écritures qui doivent être atomiques dans une seule procédure, dans un seul moteur (comme dans l’exemple ci-dessus), et à rendre chaque étape entre moteurs idempotente, pour qu’une exécution en échec puisse être relancée au lieu d’être annulée. Dans le Warehouse, le DML verrouille la table entière, et des écritures concurrentes sur la même table peuvent échouer sur des conflits de mise à jour ; concevez donc les chargements qui écrivent dans une même table pour qu’ils ne se chevauchent pas.

Points de contrôle

Les fichiers de point de contrôle permettent à SSIS de reprendre à la tâche en échec. Fabric n’a pas de mécanisme de point de contrôle, et en recréer un avec des indicateurs et des fichiers est fragile. Préférez :

  • Des étapes idempotentes qui peuvent toujours être relancées pour la même fenêtre ou le même fichier.
  • Un état durable dans une table de contrôle ou de watermark, avancé seulement après la réussite du chargement.
  • Une logique de reprise explicite : le pipeline lit l’état et saute les fenêtres déjà chargées.

Les chargements incrémentiels dans Microsoft Fabric (en anglais) détaille l’avancement sûr du watermark et les réexécutions.

Dépendances au système de fichiers

Les chemins locaux, partages UNC, lecteurs mappés et dossiers d’archive supposent un serveur qui n’existe pas dans Fabric. Les fichiers atterrissent dans les Files d’un Lakehouse ou dans ADLS Gen2, sont atteints via une passerelle quand ils doivent rester sur site, et sont archivés par convention de chemin (landing/partner/2026/11/08/) plutôt que déplacés. Vérifiez ce qui lit aussi ces partages : une autre application, une personne, une exportation planifiée. Déplacer les fichiers peut casser des consommateurs extérieurs au parc SSIS.

Chaînes de packages

Les grands arbres d’Execute Package Task racontent en général comment les packages ont été construits au fil des ans, pas comment les données devraient circuler. Dessinez la chaîne, trouvez les vraies dépendances (quelle étape a besoin de quelle sortie), et reconstruisez-la comme un pipeline parent court avec quelques pipelines enfants, ou comme des pipelines indépendants lancés par des planifications et des événements. Recréer un arbre de vingt niveaux de pipelines enfants garde l’ancienne complexité et ajoute le surcoût des exécutions de pipeline.

SQL Agent

La plupart des parcs SSIS sont aussi des parcs SQL Agent, et le job Agent porte souvent un comportement que personne n’a documenté. Pour chaque job qui lance un package, inventoriez :

  • Les étapes du job : les packages sont souvent une étape parmi des étapes T-SQL, des étapes PowerShell et des appels à d’autres jobs.
  • Les planifications : certains jobs ont plusieurs planifications ; certaines planifications lancent plusieurs jobs.
  • Les dépendances : des jobs qui en lancent d’autres ou doivent s’exécuter après la fin d’un autre.
  • Les notifications : opérateurs, courriel en cas d’échec, alertes sur des erreurs précises.
  • La logique de reprise et d’enchaînement : nombre et intervalle des nouvelles tentatives, « en cas d’échec, aller à l’étape N ».
  • Le contexte d’exécution : proxies et identifiants sous lesquels l’étape s’exécute.

Une planification de pipeline remplace le rôle d’orchestration d’un job Agent, pas chacun de ses comportements. Les nouvelles tentatives deviennent des réglages de tentative d’activité, l’enchaînement des étapes devient des conditions de dépendance, les notifications deviennent des activités ou des alertes, et les chaînes de jobs deviennent des pipelines qui appellent des pipelines. Un pipeline peut avoir jusqu’à 20 planifications et peut aussi être lancé par des événements de fichiers, de jobs ou d’espace de travail. Il n’existe pas d’objet de planification unique qui lance plusieurs pipelines : une planification partagée par plusieurs jobs Agent devient plusieurs planifications de pipeline ou un pipeline parent qui appelle les autres.

Rien ne migre automatiquement. Ne désactivez un job Agent que lorsque tout ce qu’il faisait est pris en compte, y compris les étapes qui ne sont pas du SSIS.

Vagues de migration

Migrez le parc par vagues, ordonnées pour que chaque vague apprenne quelque chose à l’équipe avant que la suivante en dépende. L’ordre est une recommandation ; les jalons de validation ne sont pas facultatifs.

  1. Vague 0Inventaire et télémétrieInventaire, notes de complexité, références historiques, liste de retrait, conception du journal d’exécution
  2. jalon
    Vague 1Copie et orchestrationCopies de faible complexité, planifications simples ; valide connexions, passerelles et supervision
  3. jalon
    Vague 2Packages centrés sur SQLETL en Execute SQL et procédures stockées ; valide la compatibilité T-SQL du Warehouse
  4. jalon
    Vague 3Packages riches en transformationsFlux de données reconstruits en T-SQL, Dataflow Gen2 ou notebooks ; valide le rapprochement
  5. jalon
    Vague 4Scripts et composants personnalisésScript Tasks et composants tiers, souvent après une période hybride
  6. jalon
    Vague 5Dépendances opérationnelles complexesChaînes profondes, staging partagé, SLA serrés, fin de mois et consommateurs d’autres équipes
Vagues de migration, avec un jalon entre chacune. Chaque vague suit le même cycle : construire, valider, basculer, stabiliser. Une vague ne commence que lorsque la précédente a franchi son jalon.
Jalon Franchi quand
Après la vague 0 Chaque package a un responsable, une décision (retirer, réhéberger, reconstruire, repenser) et une note de complexité ; la liste de retrait est validée ; le journal d’exécution et les alertes existent dans un espace de travail de développement
Après la vague 1 Connexions, passerelles et authentification fonctionnent dans chaque environnement ; les échecs alertent une personne nommée ; la première bascule et le premier retour arrière ont été répétés
Après la vague 2 Les procédures portées vers Fabric Warehouse produisent des sorties rapprochées ; les incompatibilités T-SQL sont listées avec leurs corrections
Après la vague 3 Les requêtes de rapprochement passent sur plusieurs cycles métier ; durée et consommation de capacité restent dans le budget
Après la vague 4 Chaque composant personnalisé et chaque Script Task a un remplacement ou une décision de réhébergement documentée avec une date de réexamen
Avant la mise hors service Aucun package ni job Agent n’est encore nécessaire ; la fenêtre de retour arrière de la dernière vague est close

Commencez la vague 1 par un seul package pilote : peu risqué mais représentatif, avec une vraie source, une vraie destination et une vraie planification. Faites-lui parcourir tout le cycle, bascule comprise. C’est dans le pilote que vous découvrez les vrais blocages : authentification, réseau, niveaux de protection, lacunes de journalisation.

Dans chaque vague, chaque package suit le même cycle : construire dans un espace de travail de développement relié à Git, valider par des exécutions en parallèle, basculer, stabiliser sur plusieurs cycles métier (fin de mois comprise si elle compte), et seulement ensuite retirer l’ancien chemin.

Validation et bascule en production

« Le package a réussi » ne prouve pas que la migration a réussi. Un pipeline peut réussir et charger les mauvaises lignes. Validez les données et le comportement en cas d’échec, pas le statut de l’exécution.

Ce qu’il faut comparer pendant les exécutions en parallèle

Exécutez l’ancienne et la nouvelle version sur les mêmes entrées, la version Fabric écrivant dans une cible séparée, pendant un nombre convenu d’exécutions qui inclut les jours les plus difficiles (fin de mois, gros fichiers, fichiers en retard).

Contrôle Comment
Nombres de lignes Par table et par fenêtre de chargement, ancien contre Fabric
Totaux métier Sommes des montants, quantités et autres mesures par jour, client, produit ; validées par le responsable métier
Rapprochement des clés Clés métier distinctes, et clés présentes d’un seul côté
Sommes de contrôle Un hachage des colonnes métier par ligne ou par partition, quand le volume le permet ; comparez des ensembles, pas seulement des nombres
NULL, doublons, types NULL contre chaînes vides, traitement des doublons, échelle décimale, précision des dates et heures, longueur et classement des chaînes
Fichiers produits Nombre, noms, tailles, encodages, fins de ligne
Données arrivées en retard Lignes qui arrivent après l’avancement du watermark
Durée et capacité Par rapport au SLA les jours les plus lents ; consommation de CU, temps d’activité SSIS compris pour les packages réhébergés
Rapports en aval Les responsables des rapports confirment les chiffres, pas seulement les ingénieurs

Conservez les requêtes de comparaison. Elles deviennent les tests de non-régression de la prochaine modification.

Tests d’échec et de réexécution

Testez les cas d’échec avant la bascule, parce que la production le fera :

  • Relancez deux fois la même fenêtre. Le résultat ne doit pas changer.
  • Interrompez une exécution à mi-parcours et relancez-la. Ni doublons, ni trous.
  • Relancez une activité en échec par son réglage de nouvelle tentative. L’étape relancée doit être idempotente.
  • Fournissez un mauvais fichier : fichier manquant, en-tête erroné, ligne de fin tronquée. Le pipeline doit échouer clairement et alerter quelqu’un.
  • Cassez une dépendance : arrêtez la passerelle, laissez expirer un identifiant. L’échec doit être visible dans la supervision, pas seulement dans l’historique des exécutions.

Go/no-go et retour arrière

Décidez avant la bascule, par écrit :

Question Réponse avant la bascule
Qui décide du go, du no-go et du retour arrière ? Un responsable nommé pour le package et un ingénieur d’astreinte nommé pour les premières exécutions
Qu’est-ce qui déclenche un retour arrière ? Par exemple : un échec de rapprochement sur les totaux métier, un SLA manqué, ou un échec sans correctif dans la fenêtre métier
Combien de temps dure la fenêtre de retour arrière ? Le nombre d’exécutions ou de cycles métier pendant lesquels l’ancien chemin reste prêt
Que signifie un retour arrière ? Désactiver la planification Fabric, réactiver le job Agent, et réparer ou recharger la fenêtre concernée dans la cible
Qui assure le support ensuite ? L’équipe propriétaire des pipelines Fabric, avec accès à la supervision et au runbook

Étapes de bascule

  1. Gelez les modifications du package pendant les exécutions en parallèle.
  2. Documentez la planification actuelle : horaires, dépendances, notifications, définition du job Agent.
  3. Exécutez en parallèle et comparez avec les contrôles ci-dessus jusqu’à ce que les résultats concordent, ou que chaque écart restant soit expliqué et accepté par le responsable.
  4. Désactivez l’ancien planificateur pour ce package (le job ou la planification Agent, pas le package lui-même).
  5. Activez la planification Fabric vers la vraie cible.
  6. Surveillez de près les premières exécutions, avec une personne nommée d’astreinte.
  7. Gardez le chemin de retour arrière pendant la fenêtre convenue : l’ancien job est désactivé, pas supprimé ; l’ancienne cible et le package existent toujours.
  8. Retirez l’ancienne infrastructure plus tard, après la période de stabilisation, jamais le jour de la bascule.

Supervision après la bascule

Déplacer l’orchestration sans déplacer la supervision est une façon courante de perdre en visibilité. Fabric vous donne les exécutions de pipeline et le hub de supervision (statut, durée et erreurs par activité) et, pour les packages réhébergés, les journaux SSIS dans OneLake. Ajoutez :

  • Un journal d’exécution avec une ligne par exécution et par étape : ID d’exécution, package ou pipeline, fenêtre ou fichier, lignes lues, écrites et rejetées, durée, statut, raison de l’échec, nombre de tentatives. Concevoir un journal d’exécution pour les pipelines de données en détaille la conception.
  • Des contrôles de SLA : les données sont-elles arrivées quand on en avait besoin, et pas seulement l’exécution a-t-elle réussi.
  • Un rapprochement pour les chargements critiques après chaque exécution, pas seulement pendant la migration.
  • Des alertes sur les échecs et les retards, vers une personne ou un canal réellement surveillé.

Superviser les pipelines et notebooks Microsoft Fabric couvre le côté Fabric, et la fiche de débogage des pipelines (en anglais) et Déboguer les notebooks et pipelines Fabric (en anglais) aident pour les premiers échecs. Si les chargements migrés ralentissent d’autres charges, le runbook de saturation de capacité (en anglais) est la procédure à suivre.

CI/CD et gestion de versions

Les projets SSIS vivaient en général dans le contrôle de version comme projets Visual Studio, tandis que le déploiement se faisait à la main. Fabric change l’endroit où vivent les artefacts :

  • Les packages sont des fichiers. Gardez le projet SSIS, chaque .dtsx et .dtsConfig, dans Git comme source de vérité.
  • Les Files du Lakehouse ne sont pas dans Git. L’intégration Git et les pipelines de déploiement de Fabric suivent les métadonnées du Lakehouse, pas le contenu de Files. Téléversez les packages réhébergés dans le Lakehouse de chaque environnement par une étape de livraison scriptée et reproductible.
  • Les pipelines sont des éléments Fabric. Pipelines, notebooks et objets du Warehouse se relient à Git et passent entre espaces de travail de développement, de test et de production. L’intégration Git dans Microsoft Fabric et le CI/CD avec fabric-cicd couvrent la mise en place.
  • Vérifiez les références d’environnement après le déploiement. Utilisez des paramètres et des bibliothèques de variables pour les différences d’environnement, et vérifiez connexions, chemins de package et références de Lakehouse après chaque promotion.
  • Pas de correctifs réservés à la production. Ne corrigez jamais un package en modifiant la copie dans le Lakehouse de production ; la livraison suivante l’écrase.

Anti-patterns de migration

  • Convertir package par package. Vous reproduisez la structure SSIS, y compris les parties qui n’existaient qu’à cause de SSIS.
  • Un pipeline Fabric par package SSIS, sans réexaminer les périmètres. Les périmètres des packages reflètent l’historique, pas le flux de données.
  • Déplacer le code des Script Tasks à l’aveugle. Classez ce que fait chaque script ; beaucoup n’ont besoin d’aucun code.
  • Ignorer le comportement de reprise. Sans points de contrôle ni idempotence, la première exécution en échec duplique ou perd des données.
  • Ignorer la journalisation opérationnelle. Personne ne sait où regarder au premier échec.
  • Ne tester que les exécutions réussies. La production échoue ; réexécutions, nouvelles tentatives et mauvais fichiers doivent être testés.
  • Supposer que Spark est nécessaire pour chaque transformation, ou utiliser des notebooks pour tout. La logique ensembliste est souvent plus simple et moins chère en T-SQL de Warehouse ; une mise en forme légère convient à Dataflow Gen2.
  • Conserver des couches de staging obsolètes uniquement parce que SSIS les utilisait.
  • Supposer qu’Invoke SSIS Package ou une passerelle règle la connectivité locale. La préversion ne peut pas atteindre les systèmes locaux ou en réseau privé.
  • Ignorer les niveaux de protection et les fichiers .dtsConfig. Le package ne se déchiffre pas, ou s’exécute contre le mauvais serveur.
  • Supprimer l’ancien job le jour de la bascule. Il n’y a plus de retour arrière.
  • Tout réécrire d’un coup. Les packages risqués sont bâclés à la fin.

Recommandation

Commencez par l’inventaire, pas par l’outil. Évaluez chaque package, retirez ce dont personne n’a besoin, pilotez-en un, et laissez chaque package restant mériter sa décision :

  • Retirez les packages sans consommateur, avec la validation du responsable.
  • Réhébergez les packages qui fonctionnent et passent les contrôles de la préversion, ou qui ont un blocage sans remplacement pour l’instant, et placez-les dans le backlog de modernisation avec une date de réexamen.
  • Reconstruisez les packages dont la logique est saine, avec des pipelines Fabric, du T-SQL de Warehouse et des notebooks, souvent après une courte période hybride.
  • Repensez les packages dont la structure est le problème, autour de OneLake, des chargements incrémentiels, d’étapes idempotentes et d’un journal d’exécution unique.

Considérez l’activité Invoke SSIS Package pour ce qu’elle est aujourd’hui : un moyen utile, en préversion, de placer des packages standard et accessibles depuis le cloud sous l’orchestration de Fabric. C’est un pont vers la plateforme, pas la destination.

À lire ensuite

Sources

Le comportement documenté par Microsoft dans cet article provient de ces pages Microsoft Learn :

Le cadre de décision, la notation de complexité, l’ordre des vagues, la conception de l’exemple, les jalons et les anti-patterns relèvent des conseils de migration de Javi Builds, pas de la documentation Microsoft. Le script d’inventaire a été testé sur des packages d’exemple au format SQL Server 2012 et versions ultérieures, pas sur un parc de production.

Comportement de Fabric vérifié sur Microsoft Learn en novembre 2026. L’activité Invoke SSIS Package est en préversion ; revérifiez ses limites avant de planifier un travail de production.

Étiquettes

  • Microsoft Fabric
  • SSIS
  • SQL Server
  • Pipelines de données
  • Architecture de données