DevOps et observabilité
Superviser les pipelines et notebooks Microsoft Fabric en production
Comment superviser les pipelines et notebooks Fabric assez bien pour détecter échecs, lenteurs, nouvelles tentatives, pression sur la capacité et données incorrectes avant les utilisateurs, grâce à la corrélation des exécutions, aux journaux d’exécution, aux références de durée et aux alertes.
Dans cet article
Un pipeline vert est le statut le plus trompeur d’une plateforme de données. Il vous dit que chaque activité s’est terminée sans erreur. Il ne vous dit pas que les bonnes lignes sont arrivées, que le watermark a avancé, que l’exécution a pris un temps normal, ni que le rapport de 6 h affichera les chiffres d’hier et non ceux de la semaine dernière.
La plupart des équipes Fabric commencent avec le hub de supervision et un e-mail d’échec. Cela attrape les problèmes bruyants : une connexion cassée, une exception dans un notebook, un dépassement de délai. Les problèmes coûteux sont silencieux. Un notebook qui réussit avec zéro ligne parce que le chemin source a changé. Un chargement qui prend 40 minutes au lieu de 10 parce qu’il partage désormais la capacité avec une nouvelle charge. Une nouvelle tentative qui ajoute discrètement deux fois la même fenêtre. Ce sont les utilisateurs qui les découvrent, généralement en réunion.
Ce guide explique comment superviser les pipelines et notebooks Fabric assez bien pour trouver ces problèmes en premier. Il s’organise autour de quatre questions auxquelles chaque exécution de production doit répondre :
- La charge s’est-elle exécutée ? A-t-elle été déclenchée, a-t-elle démarré, a-t-elle démarré à l’heure ?
- S’est-elle terminée avec succès ? Chaque activité, y compris les nouvelles tentatives, les pipelines enfants et les notebooks qu’ils appellent.
- A-t-elle produit les données attendues ? Nombres de lignes, clés, totaux, fraîcheur, watermarks.
- A-t-elle consommé un temps et une capacité acceptables ? Par rapport à son propre historique, pas à un chiffre deviné par quelqu’un.
Fabric répond bien aux deux premières sans configuration. Les deux dernières demandent un peu d’ingénierie délibérée : des paramètres, un journal d’exécution, des contrôles de validation et une référence. C’est cette ingénierie que couvre cet article.
Le comportement des produits a été vérifié sur Microsoft Learn en octobre 2026. Plusieurs fonctionnalités de supervision, dont le nouveau hub de supervision, étaient alors en préversion et sont signalées comme telles.
Aucun écran ne répond à toutes les questions
Dans Fabric, la supervision se présente en couches, et chacune répond à des questions différentes :
| Couche | Ce qu’elle vous donne | Ce qu’elle ne peut pas vous dire |
|---|---|---|
| Hub de supervision et historique des exécutions de pipeline | Statut, durée, exécutions d’activités avec entrées, sorties et erreurs, relations entre exécutions en amont et en aval, réexécutions | Si les données sont correctes ; l’historique au-delà de la rétention de la plateforme ; votre contexte métier |
| Détails de l’application Spark (depuis une exécution de notebook) | Session, étapes, exécuteurs et journaux d’une exécution de notebook | À quelle exécution de pipeline et à quelle fenêtre métier appartenait le notebook, sauf si vous les lui transmettez |
| Supervision de l’espace de travail (workspace monitoring) | Journaux des jobs et des activités stockés dans un Eventhouse et interrogeables en KQL dans tout l’espace de travail | Les nombres de lignes, watermarks et résultats de validation produits par votre code |
| Votre journal d’exécution | Éléments métier : fenêtres, nombres de lignes, watermarks, résultats de validation, corrélation entre exécutions | Le fonctionnement interne de la plateforme ; tout ce que vous n’avez pas journalisé |
| Application Capacity Metrics | Quelles opérations ont consommé la capacité, lissage, limitation | Pourquoi un job précis a fait ce qu’il a fait |
| Alertes (alertes de pipeline, Activator, activités Teams ou Outlook, outils externes) | Une notification quand quelque chose franchit une limite | Tout ce pour quoi vous n’avez pas défini de règle |
Un incident de production touche généralement trois de ces couches. Le reste de cet article sert à les relier entre elles.
Que superviser
| Signal | Pourquoi c’est important | Où l’obtenir | Ce qui doit déclencher une alerte |
|---|---|---|---|
| Statut de l’exécution du pipeline | Le premier signe d’une panne | Hub de supervision, supervision de l’espace de travail, alertes de pipeline | Échec d’un pipeline de production |
| Démarrage manqué ou en retard | Une planification qui ne s’est pas déclenchée ressemble à « aucun échec » | Liste des exécutions attendues comparée aux exécutions réelles ; journal d’exécution | Exécution attendue absente après sa fenêtre |
| Durée du pipeline | Les ralentissements précèdent les échecs et les SLA manqués | Historique des exécutions, supervision de l’espace de travail, journal d’exécution | Durée très éloignée de la référence propre à la charge |
| Activité en échec et erreur | Indique où regarder en premier | Exécutions d’activités dans la vue détaillée de l’exécution | Incluse dans l’alerte d’échec |
| Nombre de nouvelles tentatives | Instabilité cachée ; les nouvelles tentatives peuvent aussi dupliquer le travail | Exécutions d’activités ; retry_count dans le journal d’exécution |
Nouvelles tentatives répétées, ou en hausse au fil du temps |
| Paramètres (date, fenêtre, environnement) | La plupart des incidents de « données fausses » viennent d’entrées fausses | Entrée de l’activité ; journal d’exécution | Paramètres hors des valeurs attendues |
| Exécutions en amont et en aval | L’échec d’un enfant remonte sous la forme d’une erreur vague chez le parent | Colonnes amont/aval du hub de supervision | Fait partie de l’investigation de l’échec |
| Statut de sortie et exception du notebook | Le notebook sait pourquoi il a échoué ; le pipeline sait seulement qu’il a échoué | Exécution du notebook, journaux Spark, journal d’exécution | Échec d’un notebook dans une exécution de production |
| Lignes lues, écrites et rejetées | Des nombres nuls ou inhabituels sont l’échec silencieux le plus courant | Journal d’exécution (à partir des métriques d’opération Delta) | Zéro ligne là où des données sont attendues ; nombres très éloignés de la référence |
| Fenêtre source et watermark | L’exactitude incrémentielle en dépend | Journal d’exécution, table de watermarks | Données écrites mais watermark non avancé, ou l’inverse |
| Clés en double et valeurs nulles | Corruption silencieuse des données | Étape de validation | Toute clé métier en double ; taux de nulls au-delà d’une limite convenue |
| Totaux de rapprochement | Prouvent que source et cible concordent | Étape de validation | Écart au-delà d’une tolérance convenue |
| Fraîcheur | Les utilisateurs veulent savoir quand les données étaient correctes, pas quand un job a tourné | Horodatage métier maximal par table ; journal d’exécution | Données plus anciennes que la fraîcheur convenue |
| Fichiers découverts, traités, en échec | L’ingestion de fichiers échoue fichier par fichier | Table des fichiers traités ; journal d’exécution | Fichiers en échec ou non traités après leur fenêtre |
| Délai de démarrage ou de file d’attente | Problèmes de capacité ou de session Spark, pas de code | Détails de l’application Spark ; séparation démarrage/traitement dans le journal | Démarrage durablement très au-dessus de la normale |
| Pression sur la capacité | La limitation ralentit ou rejette tout ce qui tourne sur la capacité | Application Capacity Metrics ; événements de capacité | Limitation qui affecte une charge critique |
Le tableau ne contient volontairement aucun seuil. Une durée « normale » pour un chargement nocturne et pour un micro-lot de cinq minutes diffère de plusieurs ordres de grandeur. Les seuils viennent de l’historique propre à chaque charge, comme l’explique la section sur les références de durée.
La supervision intégrée des pipelines
Data Factory dans Fabric vous donne une base solide sans aucun développement.
Hub de supervision. Au moment de la rédaction, il existe deux expériences : le hub de supervision établi, que Microsoft appelle désormais l’expérience héritée, et un nouveau hub de supervision en préversion, qui ajoute des vues de santé des pipelines entre espaces de travail et la gestion des alertes. Les deux permettent de :
- Retrouver les exécutions de pipeline par nom, statut, heure de début, auteur de la soumission et emplacement.
- Ouvrir la vue détaillée d’une exécution : le schéma du pipeline, l’ID d’exécution, le statut, les erreurs et chaque exécution d’activité.
- Ouvrir l’entrée et la sortie d’une activité pour voir les paramètres reçus et ce qu’elle a renvoyé, ainsi que ses détails de performance (dont la décomposition de la durée des activités Copy).
- Voir les exécutions en amont et en aval, c’est-à-dire quelle exécution a déclenché celle-ci et lesquelles elle a déclenchées. Activez ces colonnes pour suivre une chaîne Invoke pipeline.
- Utiliser la vue Gantt pour comparer les durées entre exécutions et repérer les chevauchements.
- Réexécuter un pipeline : l’exécution complète, à partir de l’activité en échec, ou à partir d’une activité choisie.
- Exporter les exécutions d’activités au format CSV.
Supervision de l’espace de travail. Lorsqu’elle est activée pour un espace de travail, Fabric écrit les journaux d’exécution des jobs dans un Eventhouse de supervision, dont une table ItemJobEventLogs avec le nom de l’élément, le statut du job, les heures de début et de fin et la durée. L’historique des exécutions devient alors interrogeable, représentable en graphiques et exploitable pour des alertes sur tous les pipelines de l’espace de travail :
// Pipeline duration per day over two weeks, from workspace monitoring
ItemJobEventLogs
| where ItemKind == "Data Pipeline" and JobStatus == "Completed"
| where JobStartTime > ago(14d)
| summarize runs = count(),
p50_minutes = percentile(DurationMs, 50) / 60000.0,
p90_minutes = percentile(DurationMs, 90) / 60000.0
by ItemName, bin(JobStartTime, 1d)
| order by ItemName asc, JobStartTime asc
Vérifiez les valeurs exactes des colonnes dans votre propre Eventhouse de supervision avant de bâtir dessus : le schéma est documenté par Microsoft, mais les types d’éléments et les statuts sont faciles à mal orthographier.
Ce que la couche intégrée ne fait pas, c’est connaître vos données. Elle peut vous dire que nb_silver_orders a réussi en quatre minutes. Elle ne peut pas vous dire qu’il a fusionné zéro ligne parce que le paramètre de fenêtre était décalé d’un jour.
Supervision des notebooks : capturer plus que « réussi »
Le statut d’une activité notebook est binaire. Les questions que vous poserez pendant un incident ne le sont pas :
- De quelle exécution s’agissait-il ? L’ID d’exécution du notebook, plus l’exécution de pipeline qui l’a appelé.
- Que lui demandait-on ? Date métier, fenêtre source, environnement, table cible.
- Qu’a-t-il réellement fait ? Lignes lues, écrites, rejetées ; tables touchées ; emplacement de sortie.
- Combien de temps chaque partie a-t-elle pris ? Attente et démarrage, traitement, écriture finale.
- S’il a échoué, pourquoi ? Le type et le message de l’exception, expurgés.
Fabric peut vous dire une partie de tout cela. Les détails de l’application Spark montrent les étapes, les exécuteurs et les journaux. notebookutils.runtime.context indique le nom du notebook, l’espace de travail, le Lakehouse par défaut, si l’exécution est faite pour un pipeline et l’ID du job Livy de l’activité en cours. Ce que le notebook ne sait pas par lui-même, c’est quelle exécution de pipeline l’a lancé : le contexte d’exécution ne contient des ID d’exécution que pour les exécutions de référence de notebooks. Transmettez donc l’identité du pipeline.
Dans les paramètres de base de l’activité notebook :
| Paramètre | Valeur |
|---|---|
pipeline_run_id |
@pipeline().RunId |
parent_pipeline_run_id |
@pipeline()?.TriggeredByPipelineRunId (null sauf si le pipeline a été invoqué par un pipeline parent) |
pipeline_name |
@pipeline().PipelineName |
trigger_time |
@pipeline().TriggerTime |
window_start, window_end |
la fenêtre de traitement calculée par le pipeline |
Le notebook les déclare dans sa cellule de paramètres, avec des valeurs par défaut sûres pour les exécutions interactives. Les paramètres des notebooks décrivent ce modèle, validation comprise, et l’activité Invoke Pipeline la transmission de valeurs d’un pipeline parent à un pipeline enfant.
Utiliser le journal d’exécution pour ce que Fabric ne voit pas
Le journal d’exécution est la table qu’écrit votre code : une ligne par tentative, écrite au début et finalisée à la fin. C’est là que la supervision répond aux questions trois et quatre. Cet article reprend les noms de champs de ce modèle plutôt que d’en inventer de nouveaux :
| Champ | Usage pour la supervision |
|---|---|
execution_id |
Un par tentative ; une nouvelle tentative en reçoit un nouveau |
parent_execution_id |
L’exécution de pipeline appelante, pour rattacher une ligne de notebook à son pipeline |
correlation_id |
L’opération métier à travers les services, par exemple un chargement quotidien |
pipeline_name, notebook_name, environment |
Ce qui s’est exécuté, et où |
start_time, end_time, duration_ms |
Durée et références |
status |
started, succeeded, failed, cancelled, timed_out |
rows_read, rows_written |
Volume et exécutions silencieuses à zéro ligne |
retry_count, trigger_type |
Nouvelles tentatives, et réexécutions planifiées ou manuelles |
error_code, error_message |
Raison de l’échec, expurgée |
Deux extensions valent la peine pour la supervision : window_start et window_end pour les charges incrémentielles, et rows_rejected pour la validation. L’article sur les chargements incrémentiels (en anglais) ajoute rows_inserted, rows_updated et rows_deleted à partir des métriques du MERGE Delta.
Un wrapper de notebook compact qui l’écrit :
import time, uuid
from datetime import datetime, timezone
ctx = notebookutils.runtime.context
execution_id = str(uuid.uuid4()) # one per execution, even if the notebook runs twice in a pipeline run
started = time.time()
def log(status, **metrics):
row = {
"execution_id": execution_id,
"parent_execution_id": pipeline_run_id, # notebook parameter from @pipeline().RunId
"correlation_id": correlation_id, # notebook parameter, e.g. "sales-daily-2026-10-24"
"pipeline_name": pipeline_name,
"notebook_name": ctx["currentNotebookName"],
"environment": environment,
"status": status,
"start_time": datetime.fromtimestamp(started, timezone.utc),
"end_time": datetime.now(timezone.utc) if status != "started" else None,
"duration_ms": int((time.time() - started) * 1000) if status != "started" else None,
"window_start": window_start,
"window_end": window_end,
**metrics,
}
spark.createDataFrame([row]).write.format("delta").mode("append").option("mergeSchema", "true").saveAsTable("execution_log")
log("started")
try:
rows_read, rows_written = run_load(window_start, window_end) # your transformation
log("succeeded", rows_read=rows_read, rows_written=rows_written)
except Exception as e:
log("failed", error_code=type(e).__name__, error_message=str(e)[:500])
raiseRelancez l’exception après l’avoir journalisée. Un notebook qui journalise un échec puis se termine proprement transforme une activité rouge en activité verte.
Quel que soit l’emplacement (une table de Lakehouse comme ci-dessus, une table de Warehouse ou une SQL database), gardez le journal indépendant de la rétention de l’historique des exécutions de la plateforme, pour pouvoir comparer ce mois-ci avec le trimestre précédent.
Corréler les exécutions parentes et enfants
Les charges réelles sont des arbres, pas des exécutions isolées :
pl_daily_sales pipeline run 9f1c… (correlation_id = sales-daily-2026-10-24)
├── Invoke pl_load_orders child run 47ab… parent = 9f1c…
│ ├── Copy job activity copy run
│ └── nb_silver_orders notebook run parent_execution_id = 47ab…
└── nb_validate_sales notebook run parent_execution_id = 9f1c…
Quand nb_silver_orders échoue, le pipeline parent indique seulement que le pipeline invoqué a échoué. Sans corrélation, un opérateur ouvre le parent, clique sur l’enfant, retrouve l’exécution du notebook, ouvre ses journaux Spark, puis devine quelle fenêtre il traitait. Avec la corrélation, une seule requête renvoie tout l’arbre :
-- Everything that happened for one business operation
SELECT pipeline_name, notebook_name, status, start_time, duration_ms,
rows_read, rows_written, retry_count, error_message
FROM execution_log
WHERE correlation_id = 'sales-daily-2026-10-24'
ORDER BY start_time;Les règles sont simples : chaque pipeline transmet @pipeline().RunId (et l’ID d’exécution du parent quand il est invoqué) à ce qu’il appelle ; chaque notebook journalise les deux ; et un seul correlation_id identifie l’opération métier à travers les réexécutions. Les colonnes amont et aval du hub de supervision donnent le même arbre côté plateforme, ce qui permet de passer de l’un à l’autre.
Superviser les chargements incrémentiels
Les charges incrémentielles ajoutent un état, et cet état ajoute des modes de défaillance que le statut d’exécution ne voit pas. L’article sur les chargements incrémentiels (en anglais) en couvre la conception. Pour la supervision, journalisez à chaque exécution :
- Le watermark précédent et la borne supérieure retenue pour cette exécution.
- Les lignes extraites de la fenêtre.
- Les lignes insérées, mises à jour, supprimées par le MERGE.
- Watermark avancé ?
last_successful_watermarka-t-il atteint la borne supérieure ? - Le statut de rapprochement du contrôle le plus récent.
Les deux situations qui méritent une alerte :
- Données écrites, watermark non avancé. L’exécution a validé Silver ou Gold, mais a échoué avant d’enregistrer le watermark. Avec une conception idempotente, l’exécution suivante rejoue la fenêtre sans risque, mais vous devez le savoir, et des occurrences répétées signifient que quelque chose échoue à la fin de chaque exécution.
- Watermark avancé, écriture en aval échouée ou absente. La situation dangereuse. Les modifications de cette fenêtre peuvent être définitivement sautées. Elle devrait être impossible par conception (le watermark bouge en dernier) : si elle se produit, traitez-la comme un incident.
Un contrôle simple compare la table de watermarks avec le journal d’exécution :
-- Watermark advanced without a succeeded run for that window
SELECT w.pipeline_name, w.last_successful_watermark, w.last_execution_id
FROM etl_watermark AS w
LEFT JOIN execution_log AS l
ON l.execution_id = w.last_execution_id AND l.status = 'succeeded'
WHERE l.execution_id IS NULL;Surveillez aussi le retard du watermark : l’écart entre last_successful_watermark et l’heure actuelle. Un watermark qui cesse d’avancer alors que chaque exécution signale un succès indique généralement une fenêtre vide ou erronée.
Superviser les nouvelles tentatives et les réexécutions
Les nouvelles tentatives masquent l’instabilité. Une activité configurée avec des nouvelles tentatives peut échouer deux fois, réussir à la troisième et laisser le pipeline au vert. Une fois, ce n’est pas grave. Chaque nuit, c’est un avertissement, et c’est un incident quand les nouvelles tentatives commencent à dupliquer le travail.
Distinguez quatre cas :
- Nouvelle tentative ponctuelle : une seule nouvelle tentative après une coupure réseau ou un bref dépassement de délai de la source. Journalisez-la, sans alerter.
- Tempête de nouvelles tentatives : de nombreuses nouvelles tentatives sur plusieurs activités ou exécutions, souvent après une panne de la source. Chacune peut relancer un travail lourd et alourdir la charge sur la capacité. Alertez sur la hausse, pas sur les occurrences isolées.
- Réexécution réussie après un échec partiel : un opérateur ou une planification réexécute une fenêtre en échec. C’est correct quand les écritures sont idempotentes, mais rendez-le visible :
trigger_typeet un nouvelexecution_idmontrent qu’il s’agit d’une réexécution, etcorrelation_idla rattache à la tentative d’origine. - Réexécution à partir de l’activité en échec : Fabric peut reprendre à partir de l’activité en échec. C’est utile, mais sûr seulement si les activités précédentes ne sont pas censées s’exécuter de nouveau pour la même fenêtre.
Conservez les tentatives échouées dans le journal ; ne les écrasez jamais quand une nouvelle tentative réussit. « Réussi après trois nouvelles tentatives » et « réussi » sont deux états de santé différents, et seul le journal permet de les distinguer après coup.
Références de durée
Les seuils de durée fixes (« alerter au-delà de 30 minutes ») sont soit trop stricts pour les jours chargés, soit trop lâches pour les jours légers. Comparez plutôt chaque exécution avec son propre historique :
- La même charge, pas une moyenne à l’échelle de la plateforme.
- Un historique récent : les deux à quatre dernières semaines, pour que la référence suive une croissance progressive.
- Un volume d’entrée comparable quand il varie beaucoup. La fenêtre de rattrapage du lundi n’est pas comparable à celle du mardi.
- Des percentiles (médiane et percentile élevé) plutôt que des moyennes, qu’une seule mauvaise nuit suffit à fausser.
Par exemple (à titre purement illustratif), un chargement dont les exécutions récentes prennent de 8 à 12 minutes et qui en prend 35 aujourd’hui mérite une investigation, même si 35 minutes n’auraient rien d’anormal pour une autre charge. La requête de supervision de l’espace de travail plus haut vous donne la vue plateforme ; le même calcul sur execution_log.duration_ms vous donne des références par notebook et par fenêtre.
Regardez aussi les tendances. Une exécution un peu plus lente chaque semaine correspond souvent à une table qui accumule de petits fichiers ou à une source qui croît plus vite que prévu. La maintenance des tables Delta (en anglais) couvre l’aspect organisation des fichiers. Revérifiez les références après chaque déploiement, car une mise en production CI/CD est la raison la plus fréquente pour laquelle une durée stable change du jour au lendemain.
Une supervision consciente de la capacité
Une charge peut ralentir sans aucun changement de son code ni de ses données, parce qu’elle partage la capacité avec tout le reste. Causes fréquentes :
- Charges qui se chevauchent à la même heure.
- Lissage : le travail en arrière-plan effectué plus tôt dans la journée pèse encore sur la capacité.
- Limitation (throttling) : retards ou rejets interactifs dès que l’utilisation lissée dépasse les limites.
- Limites de concurrence Spark : jobs mis en file (déclenchés par un pipeline) ou rejetés (interactifs) quand les cœurs Spark sont occupés.
Le chemin de diagnostic est court :
- Examiner l’historique de la charge. Cette exécution est-elle une valeur aberrante par rapport à sa référence ? Le temps de démarrage ou de traitement a-t-il augmenté ?
- Examiner la fenêtre de capacité dans l’application Capacity Metrics pour la même période. Y a-t-il eu de la limitation ? Quelles opérations dominaient ?
- Corréler avec les autres opérations. Quels autres pipelines, notebooks, actualisations ou requêtes tournaient en même temps ?
Si la capacité était sous pression et que la charge elle-même n’a pas changé, la replanifier ou l’isoler est généralement plus efficace que l’optimiser. La capacité Microsoft Fabric expliquée (en anglais) couvre le lissage, les étapes de limitation et la lecture de l’application Capacity Metrics ; cet article ne les répète pas.
Séparer le démarrage du traitement
Quand la durée totale d’un notebook augmente sans que sa logique ait changé, divisez le temps en trois parties :
- Attente et démarrage : file d’attente, acquisition de la session Spark, préparation de l’environnement et des bibliothèques.
- Traitement : lecture, transformation, shuffle.
- Écriture et validation : écriture des fichiers et validation de la transaction Delta, plus toute maintenance déclenchée après l’écriture.
Chacune oriente ailleurs. Un démarrage qui s’allonge oriente vers la configuration de session, les environnements, les bibliothèques ou la capacité, que traitent le temps de démarrage des notebooks et les session tags. Un traitement qui s’allonge oriente vers le volume de données, le déséquilibre, les scans ou les jointures ; voir Accélérer les notebooks Fabric. Une écriture qui s’allonge oriente vers l’organisation des fichiers, la portée du MERGE ou le compactage.
Une façon peu coûteuse d’obtenir cette séparation consiste à journaliser des horodatages dans le notebook : à l’exécution de la première cellule (fin du démarrage), avant l’écriture finale et après la validation. L’écart entre le début de l’activité du pipeline et la première cellule correspond à l’attente et au démarrage ; le reste vous appartient.
Comparez ce qui est comparable : une session à froid et une session réutilisée répondent à des questions différentes, tout comme des fenêtres d’entrée différentes.
Supervision de la qualité des données
Le succès de l’infrastructure n’est pas le succès des données. Un pipeline peut être vert et livrer quand même de mauvaises données : la validation doit faire partie de l’exécution, pas d’un rapport séparé que quelqu’un consulte plus tard.
Des contrôles pratiques, exécutés comme étape de validation après le chargement :
-- Duplicates on the business key
SELECT COUNT(*) - COUNT(DISTINCT sales_order_id) AS duplicate_rows FROM silver_sales_orders;
-- Null rate on a required column
SELECT AVG(CASE WHEN customer_id IS NULL THEN 1.0 ELSE 0.0 END) AS null_rate FROM silver_sales_orders;
-- Freshness: newest business timestamp
SELECT MAX(order_timestamp) AS newest_order FROM silver_sales_orders;Et les contrôles qui demandent du contexte :
- Écarts de nombre de lignes : les lignes du jour comparées à la référence récente du même jour de la semaine.
- Clés manquantes : clés présentes dans la source mais pas dans la cible, ou l’inverse, sur une période récente.
- Totaux et rapprochement : sommes par date dans la source et dans la cible.
- Partitions ou dates attendues : chaque date attendue présente dans Gold.
- Fichiers en retard : entrées attendues qui ne sont pas arrivées.
- Données périmées : l’horodatage le plus récent plus ancien que la fraîcheur convenue, même si le job a tourné.
Décidez de l’effet de chaque contrôle en échec. Certains doivent faire échouer l’exécution (clés en double dans une table d’état courant), pour que le chemin d’échec et les alertes du pipeline se déclenchent. D’autres doivent avertir (un nombre de lignes 20 % sous la référence un jour férié). Enregistrez chaque résultat dans le journal d’exécution pour rendre les tendances visibles.
Superviser l’ingestion de fichiers
Les chargements fondés sur des fichiers échouent fichier par fichier : supervisez-les à ce niveau :
- Fichiers découverts dans la zone d’atterrissage lors de cette exécution.
- Fichiers traités, ignorés et en échec, avec la raison des fichiers ignorés et des échecs.
- Fichiers en double : même nom ou même somme de contrôle déjà traités.
- Retard de traitement : l’âge du plus ancien fichier non traité.
Une table des fichiers traités, comme celle décrite dans le guide des chargements incrémentiels (en anglais), vous donne ces nombres gratuitement. Alertez sur les fichiers en échec et sur le retard, pas sur les fichiers ignorés pris isolément.
Alertes
Alertez sur ce qui exige une action ; suivez le reste en tendance.
Alertes immédiates :
- Échec d’un pipeline de production.
- Échec répété d’un notebook pour la même charge.
- Un échec de validation des données qui bloque l’usage en aval.
- Watermark avancé sans écriture en aval réussie.
- Limitation de capacité qui affecte une charge critique.
- Une exécution attendue qui n’a pas démarré.
Avertissements et tendances :
- Durée qui se dégrade par rapport à la référence.
- Nombre de nouvelles tentatives en hausse.
- Nombre de petits fichiers en hausse sur les tables clés.
- Dérive progressive du nombre de lignes.
- Temps de démarrage en hausse.
Ce que Fabric fournit nativement, en octobre 2026 :
- Alertes au niveau des activités : ajoutez une activité Outlook ou Teams sur le chemin d’échec d’une activité.
- Alertes au niveau des pipelines dans le nouveau hub de supervision (préversion), et notifications d’échec pour les exécutions planifiées de pipelines.
- Règles Activator sur les événements de job de pipeline, pour des notifications de réussite ou d’échec par e-mail ou Teams.
- Alertes au niveau de l’espace de travail : une requête KQL sur
ItemJobEventLogsde la supervision de l’espace de travail, avec une règle Activator par-dessus. - Événements de capacité dans le Real-Time hub, pour les changements d’état de la capacité.
Ce qui demande généralement votre propre travail : les alertes sur les données du journal d’exécution (nombres de lignes, watermarks, validation), les règles de durée par rapport à la référence, et le routage vers un système d’astreinte extérieur à Microsoft 365. Un notebook de validation qui fait échouer le pipeline est la passerelle la plus simple : il transforme un problème de données en un échec que les alertes natives savent déjà attraper.
Chaque alerte a besoin d’un destinataire et d’une première action. Une alerte dont personne n’est responsable apprend aux gens à ignorer le canal.
Un workflow de dépannage en production
- 1Alerte ou plainte d’un utilisateurQu’est-ce qui ne va pas, pour quelles données, depuis quand ?
- 2Trouver l’exécution concernéeHub de supervision, ou correlation_id dans le journal d’exécution
- 3Échec ou ralentissement ?Exécution rouge, verte mais fausse, ou verte mais lente
- 4Détails des exécutions d’activitésActivité en échec, paramètres d’entrée, erreur, exécutions enfants
- 5Vérifier le journal d’exécutionFenêtre, lignes, nouvelles tentatives, watermark
- 6Vérifier la validation des donnéesDoublons, totaux, fraîcheur
- 7Vérifier la fenêtre de capacitéLimitation, charges qui se chevauchent
- 8Comparer à la référence de duréeDémarrage, traitement ou écriture
- 9Identifier la cause
- Source
- Code
- Capacité
- Données
- 10Réexécuter sans risqueMême fenêtre, écritures idempotentes
- 11Vérifier l’état en avalValidation réussie, watermark correct, rapports à jour
Deux étapes sont le plus souvent sautées : vérifier la capacité avant d’optimiser le code, et vérifier l’état en aval après la réexécution. Une réexécution qui réussit mais laisse Gold ou le modèle sémantique périmés n’a pas clos l’incident. Déboguer les pipelines et notebooks Microsoft Fabric en production (en anglais) détaille chaque étape pour les exécutions en échec, lentes ou aux résultats erronés.
Les fiches Superviser les pipelines et notebooks Fabric et Déboguer les pipelines Fabric rassemblent les commandes et les endroits à consulter pour chaque étape.
Exemple illustratif : le chargement quotidien qui a pris 42 minutes
Il s’agit d’un déroulé de dépannage illustratif, pas d’un incident mesuré.
Le pipeline quotidien des ventes se termine normalement en 11 minutes environ. Un matin, il en prend 42. Il est vert, le rapport est en retard, et quelqu’un demande s’il faut optimiser le notebook.
- Trouver l’exécution. Le hub de supervision montre que l’exécution a réussi ; la vue Gantt montre qu’elle a démarré à l’heure et duré longtemps.
- Vérifier les détails des activités. L’activité Copy job a pris son temps habituel. L’activité du notebook Silver représente presque toute la demi-heure supplémentaire.
- Vérifier le journal d’exécution. Même taille de fenêtre que d’habitude, nombres de lignes normaux, aucune nouvelle tentative, validation réussie. Les données sont bonnes ; seule la durée pose problème.
- Séparer démarrage et traitement. Le démarrage était normal. Le traitement a pris environ quatre fois sa référence.
- Vérifier la capacité. L’application Capacity Metrics montre une capacité très chargée pendant la même fenêtre, avec un notebook de rechargement historique lourd, nouvellement planifié dans un autre espace de travail sur la même capacité, qui chevauche le chargement.
- Chercher des changements. Aucun déploiement, aucun changement de code, aucune croissance des données.
- Décider. La cause est la contention, pas le notebook. Déplacer le rechargement historique vers une fenêtre plus calme rétablit la durée normale dès le lendemain.
Sans le journal d’exécution et la vérification de la capacité, la réaction probable aurait été de réécrire un notebook qui n’était pas le problème.
Erreurs de supervision fréquentes
- N’alerter que sur les échecs. Les exécutions lentes, vides ou fausses sont vertes.
- Ne pas stocker les ID d’exécution. Sans eux, impossible de rattacher les journaux des notebooks aux exécutions de pipeline.
- Aucune corrélation parent-enfant. Chaque échec d’enfant devient une navigation manuelle de clic en clic.
- Aucune journalisation des nombres de lignes. Les exécutions à zéro ligne passent inaperçues pendant des jours.
- Aucun rapprochement. Les suppressions manquées et les fenêtres sautées n’apparaissent que lorsque quelqu’un compare des totaux à la main.
- Considérer un pipeline vert comme des données livrées. Le statut n’est pas l’exactitude.
- Aucune référence de durée. Sans historique, « lent » n’est qu’une impression.
- Ignorer les nouvelles tentatives. Elles masquent l’instabilité et peuvent dupliquer le travail.
- Optimiser des notebooks sans vérifier la capacité. Vue de l’intérieur du notebook, la contention ressemble exactement à du code lent.
- Tout journaliser sans rien en faire. Des journaux sans requêtes, tableaux de bord ni alertes sont un coût de stockage, pas de la supervision.
Liste de contrôle pour la production
- Statut des exécutions supervisé, avec des alertes sur les échecs des pipelines de production.
- Exécutions manquées détectées : planifications attendues comparées aux exécutions réelles.
- Durée comparée à la référence propre à chaque charge, pas à des seuils fixes.
- Nouvelles tentatives journalisées et suivies en tendance ; tentatives échouées conservées.
- ID d’exécution transmis des pipelines aux notebooks et stockés.
- Corrélation parent-enfant grâce aux ID d’exécution parents et à un
correlation_id. - Paramètres (date, fenêtre, environnement) enregistrés pour chaque exécution.
- Watermarks journalisés, avec des alertes sur les incohérences entre watermark et écritures.
- Lignes lues, écrites et rejetées journalisées pour chaque chargement.
- Validation (doublons, nulls, totaux, fraîcheur) intégrée à l’exécution, avec des règles claires d’échec ou d’avertissement.
- Capacité vérifiée pendant les investigations, avec des événements de capacité pour les charges critiques.
- Alertes attribuées : chaque alerte a un destinataire et une première action.
- Sûreté des réexécutions confirmée : écritures idempotentes et réexécutions visibles dans le journal.
Pour une liste de contrôle plus large couvrant les API, SQL et les SLA de données, consultez la liste de contrôle de la supervision d’une plateforme de données (en anglais). Pour décider quel outil doit posséder chaque étape, et comment cela détermine où se trouvent les éléments de preuve, consultez Pipelines, notebooks, Dataflow Gen2 ou Copy Job (en anglais).
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émoireSuperviser les pipelines et notebooks FabricSupervisez les pipelines et notebooks Microsoft Fabric avec le Monitoring hub, Workspace Monitoring, la supervision Spark, KQL, les alertes et la télémétrie de capacité afin de rendre observables les échecs et les régressions de performances.Ouvrir l’aide-mémoire
- ArticleSuperviser une plateforme de données : que faut-il vraiment mesurer ?Un modèle pratique de supervision qui relie clients, applications, API, moteurs de rapports, plateformes de données, calcul et stockage.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.