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