Parcourir les aide-mémoire · Microsoft Fabric

Technologie: Microsoft FabricCatégorie: DépannageNiveau: IntermédiaireMis à jour

Déboguer les pipelines Fabric

Diagnostiquer 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é.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Partir de l’exécution du pipeline, puis descendre jusqu’à l’activité
  5. 2. Trouver le premier véritable échec, pas chaque échec en aval
  6. 3. Enregistrer les entrées de l’activité avant de modifier quoi que ce soit
  7. 4. Paramétrer les notebooks de manière délibérée
  8. 5. Valider les paramètres de date avant de les utiliser
  9. 6. Vérifier l’existence de la source avant tout traitement coûteux
  10. 7. Ajouter un contexte d’exécution explicite au notebook
  11. 8. Ajouter un identifiant d’exécution du pipeline ou un identifiant de lot aux écritures
  12. 9. Rendre les erreurs du notebook explicites
  13. 10. Distinguer les erreurs transitoires des erreurs déterministes
  14. 11. Configurer les nouvelles tentatives des activités de manière sélective
  15. 12. Utiliser les nouvelles tentatives conditionnelles lorsqu’elles sont prises en charge
  16. 13. Ne pas relancer automatiquement les échecs d’authentification
  17. 14. Confirmer l’identité sous laquelle s’exécute le notebook
  18. 15. Comparer l’exécution interactive du notebook et l’exécution par le pipeline
  19. 16. Valider le Lakehouse par défaut
  20. 17. Déboguer le démarrage de l’activité Notebook séparément du code du notebook
  21. 18. Examiner les échecs d’étapes / de tâches Spark pour les erreurs de notebook
  22. 19. Surveiller les conflits de concurrence Delta
  23. 20. Vérifier si l’exécution en échec a écrit partiellement des données
  24. 21. Concevoir des activités idempotentes
  25. 22. Rechercher les lots en double avant de relancer
  26. 23. Utiliser une table de contrôle pour l’état opérationnel
  27. 24. Éviter les ajouts aveugles concurrents dans le même journal d’exécution sans conception adaptée
  28. 25. Faire échouer un pipeline lorsque la validation métier échoue
  29. 26. Ne pas coder en dur les chemins propres à un environnement
  30. 27. Déboguer les échecs de l’activité Copy couche par couche
  31. 28. Valider le nombre de lignes de la source et de la destination lorsqu’il est disponible
  32. 29. Déboguer séparément les échecs de l’activité de procédure stockée
  33. 30. Définir délibérément le délai d’expiration de l’activité
  34. 31. Distinguer un dépassement de délai d’une régression de performance
  35. 32. Utiliser les conditions de dépendance de manière réfléchie
  36. 33. Préserver l’erreur d’origine lors de l’ajout d’une gestion des échecs
  37. 34. Ne transmettre aux alertes que le contexte d’erreur nécessaire
  38. 35. Utiliser Secure Input / Secure Output pour les activités sensibles
  39. 36. Utiliser la supervision de l’espace de travail pour analyser les échecs récurrents
  40. 37. Interroger les exécutions d’activités de pipeline en échec
  41. 38. Synthétiser les échecs par activité
  42. 39. Suivre les régressions de durée
  43. 40. Relancer le plus petit périmètre sûr
  44. Interpréter le résultat
  45. Points à vérifier
  46. L’échec survient immédiatement
  47. L’échec survient après une longue exécution
  48. Seule l’exécution par le pipeline échoue
  49. L’échec disparaît après une nouvelle tentative
  50. La relance réussit mais les données sont dupliquées
  51. Plusieurs activités en aval échouent ou sont ignorées
  52. Notes de production
  53. La plupart des nouvelles tentatives d’activité doivent cibler les erreurs transitoires
  54. Le contexte d’exécution de l’activité Notebook est important
  55. Les exécutions de pipeline ne forment pas une transaction distribuée unique
  56. La journalisation doit être durable
  57. Workspace Monitoring peut centraliser l’historique des pipelines
  58. Les alertes doivent être exploitables
  59. Les nouvelles tentatives consomment du temps et de la capacité
  60. Erreurs fréquentes
  61. 1. Relancer immédiatement l’ensemble du pipeline
  62. 2. Relancer chaque échec
  63. 3. Masquer les exceptions du notebook
  64. 4. Déboguer les activités ignorées
  65. 5. Supposer que l’identité interactive est la même que celle du pipeline
  66. 6. Augmenter le délai d’expiration au lieu d’analyser la régression
  67. 7. Ajout aveugle lors d’une relance
  68. 8. Ajouter des nouvelles tentatives avant de sécuriser les écritures
  69. 9. Journaliser des secrets pour déboguer
  70. 10. Considérer qu’une relance réussie prouve que le problème est résolu
  71. Étape suivante
  72. Pour aller plus loin

Problème

Un pipeline Microsoft Fabric échoue, se bloque, multiplie les nouvelles tentatives ou produit un résultat incorrect.

L’échec peut provenir de différentes couches :

  • orchestration du pipeline
  • activité Notebook
  • activité Copy
  • activité de procédure stockée
  • activité Dataflow
  • identifiants ou identité de l’espace de travail
  • paramètres
  • démarrage ou exécution de Spark
  • connectivité à la source
  • conflits d’écriture sur la destination
  • dérive de schéma
  • logique de dépendance en aval

L’objectif est d’identifier quelle couche a échoué et si l’échec est transitoire ou déterministe avant de relancer quoi que ce soit.

Une démarche de débogage sûre en production doit répondre à ces questions :

  • Quelle activité a échoué en premier ?
  • Qu’a reçu cette activité en entrée ?
  • Sous quelle identité s’est-elle exécutée ?
  • L’erreur était-elle transitoire ?
  • L’activité en échec a-t-elle écrit partiellement des données ?
  • Peut-on relancer l’activité sans risque ?
  • La nouvelle tentative doit-elle être automatique ou nécessiter une intervention ?

Réponse rapide

Suivez cette séquence :

1. Ouvrir l’exécution de pipeline en échec
2. Identifier la première activité en échec
3. Lire l’erreur de l’activité, pas seulement le statut du pipeline
4. Relever l’ID d’exécution, le nom de l’activité, l’heure de début/fin et les paramètres d’entrée
5. Classer l’erreur :
   - transitoire
   - authentification/autorisation
   - paramètre/configuration
   - données/schéma
   - notebook/Spark
   - destination/conflit d’écriture
6. Vérifier si l’activité a validé partiellement des données
7. Corriger la cause racine
8. Ne relancer que si l’activité est idempotente ou récupérable sans risque
9. N’ajouter de nouvelles tentatives ciblées que pour les échecs transitoires
10. Persister les métadonnées opérationnelles pour faciliter le prochain incident

Ne commencez pas par :

« Relancer tout le pipeline. »

tant que vous ne savez pas si les activités précédentes ont déjà écrit des données.

Code / commandes

1. Partir de l’exécution du pipeline, puis descendre jusqu’à l’activité

Dans Fabric, utilisez l’historique des exécutions du pipeline / la vue Output (sortie) pour identifier :

Exécution du pipeline
  ↓
Activité en échec
  ↓
Entrée de l’activité
  ↓
Sortie/erreur de l’activité

Relevez au minimum :

nom du pipeline
ID d’exécution du pipeline
nom de l’activité
type d’activité
heure de début
heure de fin
durée
statut
code d’erreur
message d’erreur

Le statut au niveau du pipeline vous indique **qu’**un élément a échoué.

La sortie de l’activité vous indique généralement ce qui a échoué.


2. Trouver le premier véritable échec, pas chaque échec en aval

Un pipeline peut afficher plusieurs activités en échec ou ignorées parce qu’une seule dépendance en amont a échoué.

Exemple :

Copy_Raw_Data         Succeeded
Transform_Notebook    Failed
Publish_Warehouse     Skipped
Send_Success_Email    Skipped

La cible du débogage est :

Transform_Notebook

et non les activités en aval ignorées.

Identifiez toujours le premier échec dans la chaîne de dépendances.


3. Enregistrer les entrées de l’activité avant de modifier quoi que ce soit

Pour une activité en échec, relevez les valeurs effectives qui lui ont été transmises.

Exemples :

source_path
target_table
start_date
end_date
environment
workspace
lakehouse
batch_id
run_id

Les bogues de paramètres ressemblent souvent à des problèmes de données ou de connectivité.

Un notebook peut être correct mais recevoir :

2026/13/01

au lieu de :

2026-10-01

ou pointer vers le mauvais Lakehouse.


4. Paramétrer les notebooks de manière délibérée

Une activité Notebook de Fabric peut transmettre des paramètres à un notebook.

Dans le notebook, définissez explicitement les paramètres dans la cellule de paramètres prévue à cet effet.

Exemple :

source_table = "bronze_sales"
target_table = "silver_sales"
run_date = "2026-10-04"

Puis validez-les dès le début :

required = {
    "source_table": source_table,
    "target_table": target_table,
    "run_date": run_date,
}

for name, value in required.items():
    if value in (None, ""):
        raise ValueError(
            f"Missing required parameter: {name}"
        )

Échouez tôt avec un message clair plutôt que de laisser se produire un échec vague plus loin en aval.


5. Valider les paramètres de date avant de les utiliser

from datetime import datetime

try:
    parsed_run_date = datetime.strptime(
        run_date,
        "%Y-%m-%d",
    ).date()
except ValueError as exc:
    raise ValueError(
        f"run_date must be YYYY-MM-DD; got {run_date!r}"
    ) from exc

Ne laissez pas des dates mal formées échouer plus tard dans des filtres Spark ou des chemins de fichiers.


6. Vérifier l’existence de la source avant tout traitement coûteux

Exemple avec des tables Spark :

if not spark.catalog.tableExists(source_table):
    raise RuntimeError(
        f"Source table does not exist: {source_table}"
    )

Pour les charges de travail basées sur des fichiers, validez le chemin source ou la partition attendue avant de lancer une transformation volumineuse.

Échouer rapidement fournit un signal opérationnel plus clair.


7. Ajouter un contexte d’exécution explicite au notebook

Au début d’un notebook de production :

print(
    {
        "source_table": source_table,
        "target_table": target_table,
        "run_date": run_date,
    }
)

N’affichez pas :

  • de mots de passe
  • de jetons d’accès
  • de chaînes de connexion contenant des secrets
  • de contenus confidentiels

Les journaux opérationnels doivent faciliter le débogage sans divulguer d’identifiants.


8. Ajouter un identifiant d’exécution du pipeline ou un identifiant de lot aux écritures

Si le pipeline transmet un identifiant d’exécution :

from pyspark.sql import functions as F

output = (
    output
    .withColumn(
        "pipeline_run_id",
        F.lit(pipeline_run_id),
    )
    .withColumn(
        "ingested_at_utc",
        F.current_timestamp(),
    )
)

Cela permet de répondre à la question :

Quelle exécution du pipeline a écrit cette ligne ?

Cela aide aussi à détecter les lots rejoués et les relances partielles.


9. Rendre les erreurs du notebook explicites

À éviter :

try:
    do_work()
except Exception:
    print("something failed")

Cela peut masquer l’échec à l’orchestrateur.

Mieux :

try:
    do_work()
except Exception as exc:
    print(
        f"Notebook failed: {type(exc).__name__}: {exc}"
    )
    raise

Laissez l’activité Notebook échouer lorsque la transformation a réellement échoué.

Un pipeline qui signale un succès avec des données incomplètes est pire qu’un échec visible.


10. Distinguer les erreurs transitoires des erreurs déterministes

Exemples d’erreurs transitoires :

indisponibilité temporaire du service
limitation de débit (throttling) HTTP 429
dépassement de délai réseau
défaillance temporaire du point de terminaison
contention temporaire des ressources

Exemples d’erreurs déterministes :

nom de colonne erroné
SQL invalide
table manquante
autorisation refusée
paramètre incorrect
incompatibilité de schéma
clés métier en double
identifiants invalides

Relancez les problèmes transitoires.

Corrigez les problèmes déterministes.

N’utilisez pas les nouvelles tentatives pour masquer une logique défaillante.


11. Configurer les nouvelles tentatives des activités de manière sélective

La plupart des activités de pipeline de Fabric Data Factory prennent en charge les nouvelles tentatives.

Utilisez les paramètres de nouvelle tentative au niveau de l’activité pour les échecs susceptibles de se résoudre d’eux-mêmes.

Schématiquement :

Activity
→ General
→ Enable retries
→ Retry count
→ Retry interval

Pour des problèmes transitoires brefs, un délai fixe peut convenir.

En cas de limitation de débit (throttling) ou de services externes instables, un délai croissant peut réduire la pression répétée.

Ne définissez pas de nombre élevé de nouvelles tentatives par défaut.


12. Utiliser les nouvelles tentatives conditionnelles lorsqu’elles sont prises en charge

Fabric prend en charge des conditions de nouvelle tentative pour certains types d’activités.

Les critères habituels incluent :

code d’erreur
message d’erreur
type d’échec

Exemple de politique :

Relancer :
HTTP 429
erreur système temporaire
dépassement du délai de connexion

Ne pas relancer :
échec d’authentification
schéma incorrect
SQL invalide
objet source manquant

La disponibilité des nouvelles tentatives conditionnelles dépend de la fonctionnalité et de l’activité ; vérifiez donc leur prise en charge pour l’activité utilisée.


13. Ne pas relancer automatiquement les échecs d’authentification

Exemple :

401
403
identifiant invalide
autorisation refusée

Des nouvelles tentatives répétées ne corrigent généralement pas :

  • un secret expiré
  • un rôle manquant
  • une autorisation incorrecte sur l’espace de travail
  • une mauvaise identité

Arrêtez les nouvelles tentatives et corrigez les accès.


14. Confirmer l’identité sous laquelle s’exécute le notebook

Le contexte d’exécution du notebook est important.

Selon la manière dont l’exécution est déclenchée, l’identité peut différer.

Pour les notebooks déclenchés par un pipeline, validez le contexte d’authentification / de sécurité effectif du pipeline avant de supposer que le notebook s’exécute sous l’identité de son propriétaire.

Lorsqu’un notebook fonctionne en interactif mais échoue dans un pipeline, vérifiez :

identité
accès à l’espace de travail
accès au Lakehouse
autorisations sur les données externes
autorisations d’API

avant de modifier le code du notebook.


15. Comparer l’exécution interactive du notebook et l’exécution par le pipeline

Si :

Le notebook réussit en interactif
L’activité Notebook du pipeline échoue

comparez :

identité
paramètres
Lakehouse par défaut
Environment
configuration Spark
mode de session
espace de travail
identifiants de la source

Le code peut être identique alors que le contexte d’exécution ne l’est pas.


16. Valider le Lakehouse par défaut

Un notebook peut échouer s’il attend des tables d’un Lakehouse alors que l’activité / la session en utilise un autre.

Au démarrage du notebook, journalisez ou validez l’espace de noms de tables attendu.

Privilégiez des références explicites aux tables / chemins pour les charges de travail critiques couvrant plusieurs Lakehouses lorsque l’ambiguïté serait dangereuse.

Ne supposez pas que l’attachement du notebook en mode interactif correspond exactement au contexte d’exécution du pipeline.


17. Déboguer le démarrage de l’activité Notebook séparément du code du notebook

Une activité Notebook peut échouer avant que tout travail Spark utile ne commence.

Distinguez :

acquisition de la session
démarrage de Spark
initialisation de l’environnement
installation des bibliothèques
exécution du code du notebook

Si l’échec survient avant la première ligne de journal attendue, examinez la configuration de la session, de l’environnement ou de la plateforme plutôt que la transformation.


18. Examiner les échecs d’étapes / de tâches Spark pour les erreurs de notebook

Si l’activité Notebook a échoué pendant le travail Spark, examinez :

étape en échec
tâche en échec
erreur d’exécuteur
erreur de shuffle
conflit Delta
dépassement de mémoire
exception d’analyse des données

L’erreur du pipeline n’est souvent que l’enveloppe extérieure.

Les détails du job Spark contiennent la cause liée à l’exécution distribuée.


19. Surveiller les conflits de concurrence Delta

Exemple de scénario :

Notebook A → MERGE sur la table cible
Notebook B → MERGE sur la même table cible

au même moment.

Les symptômes peuvent inclure des erreurs de conflit de transaction concurrente / d’écriture.

Ne résolvez pas ce problème en augmentant indéfiniment les nouvelles tentatives du pipeline.

Envisagez :

ajout dans une zone de staging
→ sérialiser/réconcilier les MERGE

ou isolez les écritures par partition / domaine métier lorsque c’est sans risque.


20. Vérifier si l’exécution en échec a écrit partiellement des données

Avant de relancer, posez-vous ces questions :

Les activités précédentes ont-elles réussi ?
Cette activité a-t-elle validé quelque chose ?
La cible contenait-elle déjà le lot ?

Pour les écritures Delta, une transaction Delta en échec ne valide pas partiellement cette transaction, mais des activités antérieures réussies peuvent déjà avoir validé des données.

Le pipeline dans son ensemble n’est pas une transaction globale.


21. Concevoir des activités idempotentes

Une relance sûre doit produire le même résultat logique.

Exemples :

MERGE par clé métier
remplacement d’une partition connue
ajout avec protection contre le rejeu des lots
écriture en staging puis promotion

Modèle de relance non sûr :

ajout aveugle

lorsque le même lot source peut être traité deux fois.


22. Rechercher les lots en double avant de relancer

Si vous persistez des métadonnées de lot :

existing = (
    spark.table("pipeline_execution_log")
    .filter(
        F.col("batch_id") == batch_id
    )
)

if existing.count() > 0:
    raise RuntimeError(
        f"Batch already processed: {batch_id}"
    )

Dans une véritable conception de production, évitez les vérifications coûteuses par count() lorsqu’une recherche par clé ou une conception à base de table de contrôle plus efficace existe.

L’objectif est de rendre l’état de rejeu explicite.


23. Utiliser une table de contrôle pour l’état opérationnel

Exemple de schéma logique :

pipeline_execution_log
----------------------
pipeline_name
pipeline_run_id
batch_id
activity_name
status
started_at
completed_at
rows_read
rows_written
error_type
error_message

Utilisez-la pour répondre aux questions suivantes :

Ce lot a-t-il déjà été traité ?
Où la dernière exécution s’est-elle arrêtée ?
Combien de lignes ont été écrites ?
Quelle activité a échoué ?

Évitez de stocker des secrets ou d’énormes traces de pile directement dans les tables opérationnelles.


24. Éviter les ajouts aveugles concurrents dans le même journal d’exécution sans conception adaptée

Un journal d’exécution peut lui-même devenir un point chaud de concurrence.

Si plusieurs notebooks y écrivent simultanément, concevez la couche de journalisation pour la concurrence.

Approches possibles :

ajout seul (append-only) par activité
clé unique exécution/activité
merge/upsert contrôlé
service/table de journalisation centralisé(e)

Ne laissez pas l’observabilité devenir le point de défaillance.


25. Faire échouer un pipeline lorsque la validation métier échoue

Exemple :

bad_rows = (
    output
    .filter(
        F.col("merchant_id").isNull()
    )
)

bad_count = bad_rows.count()

if bad_count > 0:
    raise RuntimeError(
        f"Validation failed: {bad_count} rows have null merchant_id"
    )

Un job Spark techniquement réussi peut tout de même produire des données métier invalides.

Le succès opérationnel doit inclure des contrôles de qualité lorsque c’est nécessaire.


26. Ne pas coder en dur les chemins propres à un environnement

À éviter :

source = "abfss://prod@..."

dans chaque notebook.

Privilégiez des paramètres ou une configuration par environnement :

source_path = source_path_param

Cela réduit :

  • les accès accidentels à la production
  • la dérive entre déploiements
  • les modifications de code entre environnements

27. Déboguer les échecs de l’activité Copy couche par couche

Pour l’activité Copy, classez l’erreur :

Connexion à la source
Requête source
Authentification
Réseau/connectivité
Mappage de schéma
Sérialisation
Connexion au sink
Contrainte/écriture sur le sink
Débit/limitation (throttling)

Ne traitez pas chaque échec de Copy comme un problème de connectivité.

Vérifiez si la lecture de la source a réellement réussi avant d’examiner la destination (sink).


28. Valider le nombre de lignes de la source et de la destination lorsqu’il est disponible

Enregistrez :

lignes lues
lignes écrites
lignes ignorées/rejetées

Si :

lignes lues = 10,000,000
lignes écrites = 0

la source n’est probablement pas en cause.

Si :

lignes lues = 0

concentrez-vous d’abord sur l’amont.


29. Déboguer séparément les échecs de l’activité de procédure stockée

Une activité Stored Procedure peut échouer pour les raisons suivantes :

connexion/authentification
procédure manquante
paramètre invalide
exception SQL
transaction/interblocage
dépassement de délai
validation métier

Relevez le numéro / message d’erreur SQL lorsqu’il est disponible.

Ne relancez pas automatiquement les erreurs de logique.

Pour les interblocages (deadlocks) ou les échecs de connexion transitoires, des nouvelles tentatives ciblées peuvent être raisonnables.


30. Définir délibérément le délai d’expiration de l’activité

Les activités Fabric prennent en charge la configuration d’un délai d’expiration (timeout).

Un délai d’expiration doit représenter :

la durée la plus longue pendant laquelle l’activité peut consommer des ressources avant d’être considérée comme anormale

Ne définissez pas un délai d’expiration extrêmement élevé simplement pour éviter les échecs.

Un délai d’expiration peut révéler :

  • des appels externes bloqués
  • des jobs Spark incontrôlés
  • du SQL bloqué
  • des augmentations de volume inattendues

Appuyez-vous sur les durées historiques pour choisir une limite opérationnelle défendable.


31. Distinguer un dépassement de délai d’une régression de performance

Si un notebook prend habituellement :

20 minutes

et atteint désormais un :

délai d’expiration de 2 heures

ne vous contentez pas d’augmenter le délai d’expiration.

Examinez :

volume d’entrée
plan Spark
shuffle
déséquilibre (skew)
capacité
latence de la source
concurrence

Augmenter le délai d’expiration peut masquer une véritable régression.


32. Utiliser les conditions de dépendance de manière réfléchie

Logique d’orchestration typique :

On success
On failure
On completion

Concevez explicitement les chemins d’échec.

Exemple :

Transform
  ├─ succès → Publish
  └─ échec → Log Failure

Ne laissez pas une activité de diagnostic / notification transformer par inadvertance le résultat logique du pipeline en succès.


33. Préserver l’erreur d’origine lors de l’ajout d’une gestion des échecs

La logique de gestion des échecs doit enregistrer l’erreur ou alerter à son sujet, mais l’activité métier d’origine en échec doit rester visible.

Évitez les schémas où :

L’activité échoue
→ la journalisation réussit
→ le pipeline semble avoir réussi

sauf si c’est intentionnellement le contrat prévu.


34. Ne transmettre aux alertes que le contexte d’erreur nécessaire

Champs d’alerte utiles :

nom du pipeline
ID d’exécution
activité
environnement
type d’échec
code d’erreur
message d’erreur court
lien/contexte de supervision

Évitez d’envoyer :

  • des identifiants
  • des jetons
  • des contenus sensibles complets
  • de gros échantillons de données

35. Utiliser Secure Input / Secure Output pour les activités sensibles

Les paramètres des activités Fabric permettent de masquer les entrées / sorties sensibles dans les journaux d’exécution.

Utilisez les contrôles de journalisation sécurisée lorsque le contenu des activités peut inclure des valeurs confidentielles.

Cela réduit le niveau de détail disponible pour l’observabilité ; associez-le donc à des identifiants opérationnels sans risque.


36. Utiliser la supervision de l’espace de travail pour analyser les échecs récurrents

Lorsque Fabric Workspace Monitoring est activé, les journaux des pipelines et des activités peuvent être analysés de manière centralisée.

Les événements au niveau du pipeline peuvent être interrogés depuis l’eventhouse de supervision.

Exemple de modèle KQL :

ItemJobEventLogs
| where ItemKind == "Pipeline"
| summarize Runs = count() by JobStatus

Utilisez les journaux au niveau des activités pour une investigation plus approfondie lorsqu’ils sont disponibles.

Une supervision centralisée est plus utile que l’ouverture manuelle de chaque exécution lorsque les échecs se répètent.


37. Interroger les exécutions d’activités de pipeline en échec

Un modèle pratique au niveau des activités est :

FabricDataPipelinesActivityRunsLogs
| where ActivityStatus == "Failed"
| project
    PipelineName,
    PipelineRunId,
    ActivityName,
    ActivityType,
    ActivityStartTime,
    ActivityEndTime,
    FailureType
| order by ActivityStartTime desc

La disponibilité des colonnes peut varier selon le schéma / la version de la supervision ; examinez donc le schéma réel de la table dans votre espace de travail.

Utilisez cette requête pour identifier :

  • les récidivistes
  • les grappes d’échecs
  • les types d’activités en échec
  • les tendances temporelles

38. Synthétiser les échecs par activité

FabricDataPipelinesActivityRunsLogs
| where ActivityStatus == "Failed"
| summarize Failures = count()
    by PipelineName, ActivityName, ActivityType
| order by Failures desc

Cela transforme l’historique opérationnel en outil de priorisation.

Un pipeline qui a échoué une fois à cause d’une panne temporaire est différent d’une activité qui échoue tous les jours.


39. Suivre les régressions de durée

Exemple de principe :

FabricDataPipelinesActivityRunsLogs
| where ActivityStatus == "Succeeded"
| summarize
    AvgDurationMs = avg(DurationMs),
    MaxDurationMs = max(DurationMs)
    by PipelineName, ActivityName

Utilisez les noms de champs réellement disponibles dans votre table de supervision.

N’inventez pas de seuils de performance universels.

Comparez chaque activité à sa propre référence historique.


40. Relancer le plus petit périmètre sûr

Après avoir corrigé la cause racine, privilégiez :

relancer l’activité en échec / la branche en échec

lorsque la plateforme / le workflow le permet en toute sécurité et que les sorties en amont sont valides.

Sinon, ne relancez l’ensemble du pipeline que lorsque :

  • les activités précédentes sont idempotentes
  • les doublons sont évités
  • l’état partiel est compris

Le périmètre de relance le plus sûr dépend de la conception du pipeline.

Interpréter le résultat

Signal Piste probable
Le notebook fonctionne en interactif, échoue dans le pipeline Identité / paramètres / environnement / contexte Lakehouse
HTTP 429 / défaillance temporaire du service Candidat à une nouvelle tentative pour erreur transitoire
401 / 403 Authentification ou autorisation
Colonne invalide / incompatibilité de schéma Problème déterministe de données ou de code
Échec d’une étape Spark Problème d’exécution distribuée du notebook
Conflit Delta Problème d’écriture / de MERGE concurrents
Délai d’expiration dépassé Problème de performance, de blocage, de dépendance ou de ressources
L’amont a réussi, l’aval est ignoré Comportement des dépendances, pas plusieurs échecs indépendants
La relance crée des doublons Conception d’écriture non idempotente
Échec répété de la même activité Problème structurel, pas incident aléatoire

Points à vérifier

L’échec survient immédiatement

Causes probables :

  • paramètre invalide
  • objet manquant
  • autorisation
  • configuration
  • chemin incorrect
  • syntaxe

Vérifiez la configuration avant la performance.

L’échec survient après une longue exécution

Causes probables :

  • échec d’une étape Spark
  • dépassement du délai d’expiration
  • conflit d’écriture
  • pression mémoire
  • instabilité de la source / de la destination
  • cas limite lié à un gros volume

Examinez la télémétrie d’exécution.

Seule l’exécution par le pipeline échoue

Comparez le contexte d’exécution du pipeline à l’exécution interactive.

En particulier :

  • identité
  • paramètres
  • Lakehouse par défaut
  • espace de travail
  • Environment
  • autorisations externes

L’échec disparaît après une nouvelle tentative

Cela conforte l’hypothèse d’un échec transitoire.

Examinez tout de même la fréquence.

Si des nouvelles tentatives sont constamment nécessaires, la dépendance est peut-être défaillante ou surchargée.

La relance réussit mais les données sont dupliquées

La politique de nouvelle tentative / de relance n’est pas sûre.

Corrigez l’idempotence avant d’augmenter le nombre de nouvelles tentatives.

Plusieurs activités en aval échouent ou sont ignorées

Remontez le graphe de dépendances jusqu’au premier véritable échec.

Ne déboguez pas chaque symptôme en aval indépendamment.

Notes de production

La plupart des nouvelles tentatives d’activité doivent cibler les erreurs transitoires

Fabric Data Factory prend en charge les nouvelles tentatives d’activité et les intervalles entre tentatives.

Les capacités actuelles incluent également un délai croissant et des nouvelles tentatives conditionnelles pour certains types d’activités.

Utilisez ces fonctionnalités pour les défaillances récupérables d’infrastructure / de service, pas pour les erreurs de code déterministes.

Le contexte d’exécution de l’activité Notebook est important

L’exécution d’un notebook déclenchée par un pipeline peut utiliser un contexte de sécurité différent de celui d’une exécution interactive.

Un notebook qui fonctionne manuellement peut donc échouer depuis le pipeline parce que les conditions d’accès diffèrent.

Les exécutions de pipeline ne forment pas une transaction distribuée unique

Une activité peut réussir et valider ses données avant qu’une activité ultérieure n’échoue.

La sûreté des relances doit être conçue activité par activité.

La journalisation doit être durable

La sortie print d’un notebook est utile pour un diagnostic immédiat.

Pour l’exploitation, persistez :

  • les identifiants d’exécution
  • les identifiants de lot
  • les nombres de lignes
  • le statut
  • les horodatages
  • des métadonnées d’erreur sans risque

afin de pouvoir comparer les incidents dans le temps.

Workspace Monitoring peut centraliser l’historique des pipelines

Fabric Workspace Monitoring peut exposer les journaux d’exécution au niveau des pipelines et des activités via une eventhouse / base de données KQL de supervision.

C’est bien plus adapté à l’analyse opérationnelle récurrente que l’ouverture manuelle de chaque page d’exécution.

Les alertes doivent être exploitables

Fabric prend en charge des modèles d’alerte au niveau des pipelines / activités.

Alertez sur les échecs qui nécessitent une intervention, pas sur chaque événement transitoire qui se résout de lui-même dans le cadre de la politique de nouvelles tentatives prévue.

Les nouvelles tentatives consomment du temps et de la capacité

Une nouvelle tentative n’est pas gratuite.

Des nouvelles tentatives excessives peuvent :

  • augmenter la latence du pipeline
  • augmenter la consommation de capacité
  • augmenter la charge sur une dépendance déjà défaillante
  • dupliquer le travail si les écritures ne sont pas idempotentes

Choisissez le nombre de nouvelles tentatives de manière réfléchie.

Erreurs fréquentes

1. Relancer immédiatement l’ensemble du pipeline

Des activités précédentes peuvent déjà avoir validé des données.

Vérifiez d’abord l’état partiel.

2. Relancer chaque échec

Les problèmes d’authentification, le SQL incorrect, un schéma invalide et des paramètres erronés ne s’arrangeront pas parce que vous avez attendu 30 secondes.

3. Masquer les exceptions du notebook

Afficher une erreur sans la relever à nouveau peut faire paraître le notebook réussi.

Échouez de manière visible lorsque la charge de travail a échoué.

4. Déboguer les activités ignorées

Les activités en aval ignorées sont généralement des conséquences.

Trouvez le premier échec réel.

5. Supposer que l’identité interactive est la même que celle du pipeline

Le contexte d’exécution peut différer.

Comparez toujours l’identité et les autorisations.

6. Augmenter le délai d’expiration au lieu d’analyser la régression

Une activité beaucoup plus lente peut révéler une croissance du volume, un déséquilibre (skew), des blocages ou une pression sur les ressources.

7. Ajout aveugle lors d’une relance

C’est une manière courante de créer des données en double.

Concevez l’idempotence.

8. Ajouter des nouvelles tentatives avant de sécuriser les écritures

Les nouvelles tentatives automatiques sont dangereuses lorsque l’activité peut écrire des données non idempotentes partiellement ou à plusieurs reprises.

9. Journaliser des secrets pour déboguer

N’exposez jamais d’identifiants ni de jetons dans la sortie du pipeline.

Utilisez les contrôles d’entrée / sortie sécurisées lorsque c’est approprié.

10. Considérer qu’une relance réussie prouve que le problème est résolu

Une relance réussie suggère un caractère transitoire, mais n’explique pas les échecs répétés.

Suivez l’évolution de l’échec dans le temps.

Étape suivante

Utilisez le type d’échec pour choisir l’action suivante.

  • 429 / erreur temporaire du service → ajoutez une nouvelle tentative ciblée avec un délai / backoff approprié.
  • 401 / 403 → corrigez l’identité et les autorisations ; ne continuez pas à relancer.
  • Le notebook ne fonctionne qu’en interactif → comparez l’identité du pipeline, les paramètres, le Lakehouse et l’Environment.
  • Une étape Spark échoue → examinez les diagnostics du job / de l’étape / de la tâche Spark.
  • Conflits d’écriture Delta → réduisez les écritures concurrentes ou passez par une zone de staging puis réconciliez.
  • Erreur de schéma / de données → validez les entrées avant tout traitement coûteux et échouez tôt.
  • Délai d’expiration dépassé → comparez la durée d’exécution à la référence historique avant d’augmenter la limite.
  • La relance duplique les données → reconcevez l’activité pour la rendre idempotente.
  • L’échec se répète → passez du débogage ponctuel à Workspace Monitoring et à l’analyse des tendances.
  • Le pipeline réussit mais les données sont fausses → ajoutez une validation de la qualité métier, pas seulement des contrôles de succès technique.

← Tous les aide-mémoire