Microsoft Fabric

Activité Invoke Pipeline de Microsoft Fabric : créer des pipelines modulaires et réutilisables

Utilisez l’activité Invoke Pipeline de Microsoft Fabric pour composer des pipelines parents et enfants paramétrés entre espaces de travail, avec connexions sécurisées et supervision pratique.

Par JaviPublié 10 min de lectureIntermédiaire

Un pipeline qui ingère, valide, transforme, publie, notifie et journalise tout sur un seul canevas peut fonctionner au début. En grandissant, il devient difficile à réutiliser et à tester, son orchestration devient moins lisible et chaque modification élargit son rayon d’impact.

L’activité Invoke Pipeline donne une frontière de composition aux pipelines Fabric. Un parent décide quoi exécuter et quand ; un enfant prend en charge une unité de travail ciblée. Cet article construit ce modèle avec des paramètres, explique les choix de connexion et d’identité, puis montre comment superviser l’exécution complète.

Ce que fait Invoke Pipeline

Invoke Pipeline est une activité de flux de contrôle. Elle démarre un autre pipeline et peut transmettre des valeurs à ses paramètres.

  1. Pipeline parent / orchestrateur
  2. Invoke Pipeline
  3. Pipeline enfant réutilisable
Composition de pipelines parent et enfant

L’activité actuelle peut cibler un pipeline Fabric dans le même espace de travail ou dans un autre, ainsi qu’un pipeline Azure Data Factory ou Azure Synapse.

Chaque activité utilise un objet de connexion conservé dans le magasin sécurisé d’informations d’identification Fabric. Pour une cible Fabric, sélectionnez la connexion, l’espace de travail cible et le pipeline. Pour ADF ou Synapse, sélectionnez le type de source, sa connexion enregistrée et le nom du pipeline.

Microsoft documente Invoke Pipeline et Invoke Pipeline (Legacy). L’activité historique ne peut appeler que des pipelines Fabric de l’espace de travail du parent, et sa supervision s’arrête au parent. L’activité actuelle ajoute les cibles inter-espaces et multiplateformes ainsi que la supervision des enfants. Pour une nouvelle conception, privilégiez normalement l’activité actuelle.

Pipeline parent et pipeline enfant

Utilisez un seul petit exemple tout au long de l’article, construit dans un espace de démonstration tel que Javi Builds Fabric Demo. PL_Sales_Orchestrator est le parent. Il invoque PL_Load_Sales_Daily, attend le résultat, puis seulement ensuite poursuit la suite du flux.

  1. PL_Sales_Orchestrator
  2. Invoke Pipeline
  3. PL_Load_Sales_Daily
  4. Attendre la fin
  5. Poursuivre le flux
Pipeline de ventes parent et enfant

Le parent possède la planification, le séquencement global et les notifications. L’enfant possède la validation et le traitement idempotent d’une date métier et d’une région. Il pourra ensuite être réutilisé dans une reprise, une réexécution de support ou le Lab 02 — Parameterized Pipelines and Incremental Processing, sans dupliquer la logique.

Paramètre Type Exemple Rôle
p_date String 2026-10-19 Date métier à charger
p_region String US Région à traiter

Transmettre explicitement la date métier rend les réexécutions prévisibles : relancer 2026-10-19 recharge cette date, et non « aujourd’hui » au moment où l’enfant démarre.

Ajouter l’activité Invoke Pipeline actuelle

Créez PL_Sales_Orchestrator, ouvrez le volet Activities et ajoutez l’activité Invoke Pipeline actuelle, et non Invoke Pipeline (Legacy). Nommez-la Invoke_PL_Load_Sales_Daily et reliez-la à l’endroit où le chargement réutilisable doit s’exécuter : après les étapes de préparation et avant le travail qui dépend des données chargées.

Configurer le pipeline cible

Créez PL_Load_Sales_Daily dans le même espace de démonstration, ou dans un autre espace de démonstration sûr pour tester un appel inter-espaces. Dans les paramètres d’Invoke Pipeline, définissez le type de cible sur Fabric, choisissez une connexion sûre, sélectionnez l’espace cible si nécessaire, sélectionnez PL_Load_Sales_Daily et laissez Wait on completion activé.

Un appel dans le même espace reste simple à configurer. Un appel inter-espaces exige une connexion prise en charge et une identité autorisée sur l’espace cible ; les choix d’identité sont détaillés plus bas, avec les considérations de production.

Transmettre les paramètres du parent à l’enfant

Définissez p_date et p_region sur PL_Load_Sales_Daily. Validez leur format et leurs valeurs autorisées, mappez-les dans l’activité enfant qui réalise le chargement, et testez l’enfant directement avec 2026-10-19 et US avant de l’invoquer depuis le parent.

  1. Ajoutez les deux paramètres enfants avec des valeurs par défaut de démonstration.
  2. Mappez-les dans l’activité Notebook, Copy ou Stored Procedure qui réalise le chargement.
  3. Validez le format de date et la liste autorisée de régions avant toute écriture.
  4. Rendez le chargement idempotent pour qu’une relance converge vers le même résultat.
  5. Écrivez l’ID d’exécution enfant, les valeurs des paramètres, le statut et des comptages sûrs dans le journal d’exécution.

Pour un notebook enfant :

Paramètre de base Valeur dynamique
p_date @pipeline().parameters.p_date
p_region @pipeline().parameters.p_region

L’enfant reste ainsi testable seul, avant toute intervention du parent.

Mapper les valeurs du parent

Donnez à PL_Sales_Orchestrator ses propres paramètres p_date et p_region, puis mappez chaque paramètre enfant dans les paramètres d’Invoke Pipeline :

Paramètre enfant Valeur du parent
p_date @pipeline().parameters.p_date
p_region @pipeline().parameters.p_region

Les expressions dynamiques permettent à un même parent de traiter n’importe quelle date et région. Une valeur statique comme US reste valable si un parent ne traite jamais qu’une seule région, mais elle fige cette décision dans l’orchestration.

Exécutez le parent avec 2026-10-19 et US, vérifiez les valeurs reçues par l’enfant, puis testez une date ou une région invalide pour confirmer que la validation échoue proprement.

waitOnCompletion définit le contrat de dépendance

Avec waitOnCompletion à true — valeur par défaut documentée dans la définition du pipeline — l’activité reste active jusqu’à la fin de l’enfant. Une dépendance de succès signifie donc « l’enfant a réussi ». C’est le choix adapté avant une publication, un contrôle qualité ou une notification dépendante du résultat.

Avec false, le parent continue dès la soumission de l’enfant. Les activités suivantes peuvent s’exécuter en parallèle et ne doivent pas interpréter cette soumission comme une réussite du traitement.

  1. Invoquer le pipeline enfant
    • waitOnCompletion = true
      • Attendre le résultat enfant
      • Publier ou notifier
    • waitOnCompletion = false
      • Continuer après la soumission
      • Travail parallèle indépendant
Choisir explicitement le comportement d’attente

Le mode « soumettre et continuer » n’est utile que si le travail suivant est réellement indépendant et qu’un autre mécanisme détecte les échecs de l’enfant. Ce n’est pas un raccourci pour une dépendance qui existe toujours.

Au niveau de la définition, Microsoft documente actuellement le type moderne ExecutePipeline ; InvokePipeline est le type obsolète. Un fragment simplifié ressemble à ceci :

{
  "name": "Invoke_PL_Load_Sales_Daily",
  "type": "ExecutePipeline",
  "typeProperties": {
    "pipeline": {
      "referenceName": "PL_Load_Sales_Daily",
      "type": "PipelineReference"
    },
    "parameters": {
      "p_date": "@pipeline().parameters.p_date",
      "p_region": "@pipeline().parameters.p_region"
    },
    "waitOnCompletion": true
  }
}

Il s’agit d’un fragment explicatif, pas d’un fichier de déploiement portable : un export peut aussi contenir stratégies, connexions et identifiants propres à l’environnement.

Exécuter et superviser toute la chaîne

Utilisez l’onglet Output pour l’exécution immédiate, puis la supervision et l’historique Fabric pour l’analyse. L’activité actuelle permet d’ouvrir les exécutions enfants, ce qui est essentiel quand le parent indique seulement qu’une étape invoquée a échoué.

Pour une exécution réussie, vérifiez que PL_Sales_Orchestrator affiche l’activité Invoke_PL_Load_Sales_Daily, que l’exécution enfant PL_Load_Sales_Daily a reçu 2026-10-19 et US, et que le statut et la durée sont plausibles aux deux niveaux. Pour aller plus loin, lisez Superviser les pipelines et notebooks Fabric et Concevoir un journal d’exécution pour les pipelines de données.

Conservez dans un journal durable : ID parent et enfant, noms des pipelines, cible, valeurs de p_date et p_region, horodatages, statut, erreur sûre, comptages et watermark. Ne journalisez jamais de secret. Activez les entrées/sorties sécurisées si nécessaire. Une valeur de corrélation transmise du parent à l’enfant rend toute l’opération recherchable.

Gérer les échecs de l’enfant

Avec waitOnCompletion = true, un échec de l’enfant concerne directement l’activité parente, puisque le parent attend le résultat. Inspectez d’abord l’activité Invoke Pipeline en échec, puis ouvrez l’exécution enfant pour trouver l’activité et l’erreur à l’origine de l’échec. Vérifiez les deux niveaux : le parent donne le contexte d’orchestration, l’enfant contient le détail du traitement.

Avec waitOnCompletion = false, le parent continue après la soumission et n’attend pas le résultat final de l’enfant. Un chemin de supervision ou d’alerte distinct doit donc détecter les échecs de l’enfant. Ne placez aucun travail dépendant du résultat après une invocation de type « soumettre et continuer ».

Choisir l’identité de connexion

Authentification Bon usage Point d’attention
Organizational account Développement interactif et premiers tests Dépend d’une personne et du cycle de vie de son jeton
Service principal Automatisation non interactive avec identité d’application Paramètres du locataire, secrets/certificats et autorisations
Workspace Identity Identité de charge alignée sur l’espace appelant À créer chez l’appelant et à autoriser sur la cible

Pour Workspace Identity, Microsoft exige actuellement une identité dans le même espace de travail que le pipeline appelant, le paramètre locataire Service principals can call Fabric public APIs et un accès suffisant à la cible. Pour un appel inter-espaces, accordez à cette identité l’accès à l’espace cible ; Contributor suffit selon Microsoft dans la plupart des scénarios. Appliquez le moindre privilège.

La prise en charge générale de Workspace Identity par des connecteurs Data Factory ne donne pas automatiquement le droit d’invoquer un pipeline : l’autorisation sur l’espace cible reste nécessaire.

Modèles de production et pièges

Inscrivez ce modèle dans une architecture Microsoft Fabric réfléchie et promouvez-le avec une intégration Git Fabric revue et le CI/CD avec fabric-cicd. Le lab Fabric d’analyse des ventes de bout en bout permet de pratiquer l’espace de travail, les pipelines et la supervision avec des données synthétiques.

Gardez chaque enfant cohérent. « Charger un jeu de données borné » est une bonne responsabilité ; « faire tout ce que demande le parent » déplace seulement le monolithe. Versionnez prudemment le contrat de paramètres et évitez les longues chaînes parent → enfant → petit-enfant.

  • validez les paramètres dans l’enfant ;
  • transmettez le temps métier explicitement ;
  • ne relancez que les traitements transitoires et idempotents ;
  • testez l’enfant seul, puis le contrat parent-enfant ;
  • externalisez identifiants d’espace, connexions et identités par environnement ;
  • n’utilisez waitOnCompletion = false qu’avec une supervision asynchrone explicite.

Fabric et Azure Data Factory

Le modèle est familier aux ingénieurs ADF, mais Fabric utilise des objets de connexion plutôt que des services liés ADF et n’emploie pas les artefacts Dataset de la même manière. Fabric utilise Save et Run, s’intègre aux espaces Fabric et à OneLake, et propose l’expérience Invoke Pipeline multiplateforme. Dans ADF, l’activité équivalente s’appelle Execute Pipeline.

Ne supposez pas qu’une définition ADF exportée puisse être collée sans adaptation dans Fabric. Les expressions sont proches, mais connexions, références, déploiement et supervision suivent le modèle Fabric.

Liste de contrôle

  • responsabilité unique de l’enfant ;
  • noms, types et bornes des paramètres documentés ;
  • relances idempotentes ;
  • identité de production non personnelle ;
  • autorisations inter-espaces explicites ;
  • comportement d’attente cohérent avec les dépendances ;
  • corrélation parent-enfant ;
  • erreurs visibles dans la supervision et les journaux ;
  • enfant testable sans le parent.

Quand utiliser Invoke Pipeline

Utilisez Invoke Pipeline lorsqu’une unité de travail mérite sa propre frontière :

  • le même chargement sert plusieurs parents, par exemple une planification quotidienne, une reprise et une réexécution de support ;
  • l’enfant doit être testé, possédé ou modifié indépendamment de l’orchestration ;
  • le travail se trouve dans un autre espace Fabric, ou dans Azure Data Factory ou Azure Synapse.

Gardez les activités dans un seul pipeline lorsqu’elles n’ont de sens qu’ensemble et que rien d’autre ne les appellera. Un pipeline enfant ajoute un contrat de paramètres, une connexion et une seconde exécution à superviser : ce coût se justifie pour la réutilisation et une responsabilité claire, pas pour chaque groupe d’activités.

Invoke Pipeline est surtout une frontière d’architecture. Un parent mince, un contrat stable et un enfant observable transforment un ensemble croissant de pipelines en composants réutilisables.

Prochaines étapes

  1. Superviser les pipelines et notebooks Fabric — suivre les exécutions parent et enfant en production.
  2. Concevoir un journal d’exécution pour les pipelines de données — conserver durablement ID d’exécution, paramètres et résultats.
  3. CI/CD Microsoft Fabric avec fabric-cicd et intégration Git Fabric — promouvoir ensemble pipelines parent et enfant entre environnements.
  4. Hub Microsoft Fabric — le parcours d’apprentissage complet.

Sources et lectures complémentaires

Étiquettes

  • Microsoft Fabric
  • Pipelines de données
  • Design patterns