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.
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
.dtsxvers 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 :
- Package SSIS + job AgentUn seul .dtsx porte toutes les responsabilités
- orchestrationCorrespondance prochePipeline Data FactoryFlux de contrôle, dépendances, planifications, nouvelles tentatives
- ingestionCorrespondance procheCopy activity · Copy jobDe la source vers OneLake ou le Warehouse, avec un mappage léger
- transformationCorrespondance partielleT-SQL · notebook · Dataflow Gen2Choisi selon le type de logique et le volume, pas selon le composant
- étatRefonte nécessaireWatermarks · journal d’exécutionRemplace les points de contrôle, la logique de reprise et les tables de log des packages
- erreursCorrespondance partielleChemins d’échec · alertesRemplace les gestionnaires d’événements, les opérateurs et les tâches Send Mail
- configurationCorrespondance partielleConnexions · bibliothèques de variablesRemplace les gestionnaires de connexions, les configurations et les environnements
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 :
- 1RéhébergerLe package tourne toujours dans SSIS ; Fabric le planifie et le supervise
- déplacer une responsabilité2HybrideFabric copie les données et gère les alertes ; SSIS garde la transformation risquée
- remplacer le reste3Reconstruire ou repenserPipeline, T-SQL ou notebooks natifs de Fabric ; runtime SSIS retiré
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 :
-- 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;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 :
- Téléversez le package dans OneLake. Placez le
.dtsx, et son.dtsConfigs’il en a un, dans un dossier Files d’un Lakehouse commeFiles/ssis-packages/, avec Upload → Upload files ou l’explorateur de fichiers OneLake. - Ajoutez l’activité. Dans un pipeline Fabric, cherchez Invoke SSIS Package dans le volet Activities.
- Choisissez le package. Dans l’onglet Settings, sélectionnez Browse à côté de Package path.
- Ajoutez la configuration, le cas échéant. Sélectionnez le
.dtsConfigdans Configuration path (facultatif). - 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. - 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.
- 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
.dtsxpuis 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 INTOdepuis 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 :
- Une tâche SFTP tierce télécharge le fichier du jour vers un partage UNC,
\\<file-share>\inbound\. - 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.
- Dans un Sequence Container avec
TransactionOption = Required(MSDTC), une Execute SQL Task videstg.Settlement, et un Data Flow (Flat File Source → Derived Column → Data Conversion → Lookup → OLE DB Destination) la charge. - Une Execute SQL Task exécute
etl.usp_LoadSettlement, qui fusionne le staging dansdbo.Settlementet recalculerpt.DailySettlementsur un SQL Server local. - Une File System Task déplace le fichier vers un dossier d’archive.
- Une Send Mail Task prévient l’équipe finance que les totaux sont prêts ; un gestionnaire d’événements
OnErrorenvoie un courriel au support. - 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
- SQL Agent à 06:00
- Tâche tierceSFTP vers partage UNC
- Validation par Script Task
- Transaction MSDTCVidage + flux de données
- usp_LoadSettlement
- Archivage, Send Mail
- SuppriméReprise par point de contrôle
- Microsoft FabricUn pipeline, l’état dans des tables
- Planification ou déclencheur
- ModifiéCopy activity depuis SFTPDépose dans les Files du Lakehouse sous un chemin daté
- ValiderGet Metadata plus un Lookup ou une vérification en notebook
- Charger le stagingCopy activity ou COPY INTO dans le Warehouse
- Doit être idempotentProcédure de chargement idempotenteRemplace une date métier dans une seule transaction
- Ligne de journal d’exécutionFichier, lignes, totaux, statut
- Alerte sur échec ou retard
| 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 :
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;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.
- Vague 0Inventaire et télémétrieInventaire, notes de complexité, références historiques, liste de retrait, conception du journal d’exécution
- jalonVague 1Copie et orchestrationCopies de faible complexité, planifications simples ; valide connexions, passerelles et supervision
- jalonVague 2Packages centrés sur SQLETL en Execute SQL et procédures stockées ; valide la compatibilité T-SQL du Warehouse
- jalonVague 3Packages riches en transformationsFlux de données reconstruits en T-SQL, Dataflow Gen2 ou notebooks ; valide le rapprochement
- jalonVague 4Scripts et composants personnalisésScript Tasks et composants tiers, souvent après une période hybride
- jalonVague 5Dépendances opérationnelles complexesChaînes profondes, staging partagé, SLA serrés, fin de mois et consommateurs d’autres équipes
| 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
- Gelez les modifications du package pendant les exécutions en parallèle.
- Documentez la planification actuelle : horaires, dépendances, notifications, définition du job Agent.
- 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.
- Désactivez l’ancien planificateur pour ce package (le job ou la planification Agent, pas le package lui-même).
- Activez la planification Fabric vers la vraie cible.
- Surveillez de près les premières exécutions, avec une personne nommée d’astreinte.
- 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.
- 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
.dtsxet.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
- De SQL Server à Microsoft Fabric : quel concept correspond à quoi ? : le modèle mental plus large pour les équipes SQL Server.
- Pipelines vs notebooks dans Microsoft Fabric (en anglais) : quel outil Fabric convient à chaque partie d’une charge migrée.
- L’activité Invoke Pipeline de Microsoft Fabric : pipelines enfants, et appel de pipelines ADF depuis Fabric.
- Les chargements incrémentiels dans Microsoft Fabric (en anglais) : watermarks,
MERGEet réexécutions sûres au lieu de rechargements complets. - Créer votre premier Lakehouse Fabric (en anglais) et Créer votre premier Fabric Warehouse en T-SQL (en anglais) : là où atterrissent les données migrées.
- Concevoir un journal d’exécution pour les pipelines de données : l’exploitation après la bascule.
Sources
Le comportement documenté par Microsoft dans cet article provient de ces pages Microsoft Learn :
- Invoke SSIS Package : utiliser l’activité Invoke SSIS Package dans un pipeline (préversion) (déroulement, limites, runtime, tarification), résoudre les problèmes de l’activité Invoke SSIS Package, intégrer SSIS à une base de données SQL dans Fabric, intégrer SSIS à Fabric Data Warehouse
- Mise à niveau et runtimes : planifier la mise à niveau d’Azure Data Factory vers Fabric Data Factory, bonnes pratiques de mise à niveau, différences entre Data Factory dans Fabric et dans Azure, accéder aux sources de données locales dans Data Factory
- Pipelines : vue d’ensemble des pipelines, vue d’ensemble des activités (nouvelles tentatives et délai d’expiration), exécuter, planifier ou déclencher un pipeline par des événements (planifications multiples, déclencheurs d’événements), activité Invoke pipeline, activité Functions, activité Office 365 Outlook, intégration des bibliothèques de variables aux pipelines
- Déplacement et transformation des données : Copy activity, vue d’ensemble des connecteurs, connecteur SFTP, Dataflow Gen2
- Warehouse : surface T-SQL, transactions dans Fabric Data Warehouse
- Catalogue SSIS : catalog.executions (base de données SSISDB)
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.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Continuer à apprendre
- Aide-mémoireDéboguer les pipelines FabricDiagnostiquer les échecs de pipelines Microsoft Fabric en isolant l’activité en échec, en distinguant les erreurs transitoires des erreurs déterministes, en validant les paramètres et les identités, et en utilisant les nouvelles tentatives, la journalisation et des relances maîtrisées en toute sécurité.Ouvrir l’aide-mémoire
- ArticleParamètres des notebooks Microsoft Fabric : modèles pratiques pour des pipelines réutilisablesFaites servir un même notebook Fabric à de nombreuses exécutions : cellule de paramètres, paramètres de base du pipeline, validation, fenêtres de dates, environnements, secrets, journalisation sûre et tests.Lire l’article
Que devrais-je créer ensuite ?
Je développe Javi Builds autour des problèmes concrets rencontrés par les data engineers. Dites-moi quel sujet vous aimeriez voir ensuite.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.