Parcourir les aide-mémoire · Ingénierie des données
Contrôles de qualité des données
Mettez en place des contrôles de qualité des données concrets pour le schéma, la complétude, l’unicité, la validité, l’intégrité référentielle, la fraîcheur, la réconciliation et la dérive des pipelines, sans vous appuyer sur des seuils universels arbitraires.
Sur cette page
- Problème
- Réponse rapide
- Code / commandes
- 1. Valider les colonnes obligatoires
- 2. Détecter les colonnes inattendues
- 3. Valider les types de données Spark
- 4. Vérifier les champs obligatoirement non nuls
- 5. Vérifier le pourcentage de valeurs nulles
- 6. Éviter d’analyser la table à plusieurs reprises
- 7. Vérifier l’unicité de la clé métier
- 8. Valider l’unicité d’une clé composite
- 9. Ne pas utiliser dropDuplicates() comme contrôle de qualité
- 10. Examiner des exemples de doublons
- 11. Valider le grain des lignes après les jointures
- 12. Valider une plage numérique
- 13. Valider des valeurs de domaine bornées
- 14. Valider les codes de devise
- 15. Valider des motifs de chaînes
- 16. Vérifier les chaînes vides séparément des nulls
- 17. Normaliser les espaces avant la validation lorsque c’est pertinent
- 18. Valider des plages de dates
- 19. Valider les dates futures impossibles
- 20. Valider l’analyse des horodatages
- 21. Conserver les valeurs brutes pendant l’analyse
- 22. Valider l’intégrité référentielle
- 23. Faire attention au calendrier des données de référence
- 24. Mettre en quarantaine les enregistrements invalides
- 25. Ajouter des codes de motif
- 26. Valider la présence des fichiers source
- 27. Valider le nombre de fichiers source
- 28. Valider la complétude des partitions
- 29. Valider la fraîcheur
- 30. Distinguer la fraîcheur de la source de celle du pipeline
- 31. Comparer le nombre de lignes à l’historique
- 32. Fonder les seuils d’anomalie sur des faits
- 33. Valider avec prudence les chargements à zéro ligne
- 34. Réconcilier les totaux financiers
- 35. Réconcilier par segment métier
- 36. Réconcilier au grain attendu
- 37. Vérifier les doublons lors de la préparation d’un MERGE
- 38. Valider avant de faire avancer le watermark
- 39. Valider aussi après l’écriture
- 40. Vérifier l’idempotence
- 41. Conserver les identifiants de lot
- 42. Détecter les fichiers source répétés
- 43. Utiliser les hachages avec prudence
- 44. Ne pas hacher aveuglément une sérialisation instable
- 45. Valider les règles de comparaison tenant compte des nulls
- 46. Valider la dérive de schéma
- 47. Détecter délibérément l’élargissement ou le rétrécissement des types
- 48. Valider la précision et l’échelle des décimaux
- 49. Valider les hypothèses de fuseau horaire
- 50. Vérifier le comportement aux limites de date
- 51. Valider les énumérations par rapport à une table de référence
- 52. Valider les attentes un-à-plusieurs
- 53. Vérifier les lignes enfants orphelines
- 54. Valider les relations entre agrégats
- 55. Valider les relations de proportion
- 56. Détecter les combinaisons impossibles
- 57. Valider les transitions de cycle de vie
- 58. Vérifier les champs de séquence monotones
- 59. Valider les identifiants d’événement
- 60. Les contrôles de qualité des données peuvent être des avertissements ou bloquants
- 61. Utiliser la gravité de manière délibérée
- 62. Éviter un score de qualité global unique
- 63. Attribuer des identifiants de règle stables
- 64. Enregistrer les résultats des règles
- 65. Conserver des échantillons d’échecs
- 66. Protéger les données sensibles dans les journaux de qualité
- 67. Réconcilier le nombre de lignes avant et après les filtres
- 68. Garder une comptabilité explicite des rejets
- 69. Vérifier la multiplication des lignes dans les jointures
- 70. Appliquer le principe des contrôles de type validate dans les pipelines distribués
- 71. Valider le nombre de lignes par partition
- 72. Valider les totaux par partition
- 73. Détecter les partitions ou lots en double
- 74. Valider les limites incrémentales
- 75. Utiliser des fenêtres temporelles semi-ouvertes de manière cohérente
- 76. Vérifier les enregistrements arrivés en retard
- 77. Détecter la dérive des distributions
- 78. Vérifier la distribution catégorielle
- 79. Vérifier le résumé numérique
- 80. Utiliser les percentiles avec prudence
- 81. Comparer les métriques actuelles et historiques
- 82. Détecter les colonnes entièrement nulles
- 83. Vérifier les colonnes constantes
- 84. Faire attention aux contrôles distinct coûteux
- 85. Échantillonner uniquement pour l’exploration, pas pour les garanties finales
- 86. Éviter de collecter de grands ensembles invalides sur le driver
- 87. Limiter les exemples dans les alertes
- 88. Conserver séparément les preuves complètes des échecs
- 89. Valider le schéma cible après l’écriture
- 90. Valider l’unicité de la cible après un MERGE
- 91. Comparer les clés de la source et de la cible
- 92. Le périmètre de la réconciliation doit correspondre
- 93. Valider les comptages avant un écrasement destructif
- 94. Ajouter des garde-fous aux reconstructions
- 95. Les règles de qualité doivent être versionnées avec le code
- 96. Distinguer les défauts de la source de ceux du pipeline
- 97. Les contrôles de qualité ont besoin d’un responsable
- 98. Définir le chemin de correction
- 99. La qualité des données s’applique à plusieurs couches
- 100. Utiliser un processus de qualité reproductible
- Interpréter le résultat
- Points à vérifier
- Le nombre de lignes chute soudainement
- Le nombre de lignes augmente soudainement
- Des clés en double apparaissent après une jointure
- Le taux de nulls grimpe brusquement
- Les totaux financiers divergent alors que le nombre de lignes correspond
- Le contrôle de fraîcheur échoue alors que la durée du pipeline est normale
- Notes de production
- Les contrôles consomment des ressources de calcul
- Les règles bloquantes doivent être déterministes
- L’état de la qualité doit être auditable
- La quarantaine n’est pas une poubelle
- Les seuils doivent reposer sur des faits
- Les contrôles de qualité ne doivent bloquer par défaut que là où le métier l’exige
- Erreurs fréquentes
- 1. Utiliser un score de qualité générique unique
- 2. Supprimer les doublons sans les examiner
- 3. Considérer chaque null comme une erreur
- 4. Considérer zéro ligne comme toujours invalide
- 5. S’appuyer uniquement sur le nombre de lignes
- 6. Contrôler la qualité uniquement avant l’écriture
- 7. Utiliser des seuils arbitraires
- 8. Collecter toutes les lignes incorrectes sur le driver
- 9. Faire avancer les watermarks avant que les contrôles bloquants soient passés
- 10. Alerter sans responsable ni chemin de correction
- Étape suivante
- Pour aller plus loin
Problème
Un pipeline peut se terminer avec succès et produire malgré tout des données incorrectes.
Les défaillances typiques sont les suivantes :
- des lignes manquantes
- des clés métier en double
- des valeurs nulles inattendues
- des valeurs invalides
- une dérive de schéma
- des clés étrangères rompues
- des données obsolètes
- des chargements en double
- des agrégats incorrects
- des partitions partiellement chargées
- des changements de type silencieux
L’objectif est de rendre les contrôles de qualité des données propres au jeu de données et au contrat métier, de détecter les défaillances au plus tôt et d’orienter les données incorrectes vers la bonne étape suivante, au lieu de s’appuyer sur un « score de qualité » générique.
Réponse rapide
Un ensemble solide de contrôles en production couvre généralement :
Schéma
→ colonnes et types attendus
Complétude
→ les valeurs obligatoires sont présentes
Unicité
→ les clés sont uniques au grain attendu
Validité
→ les valeurs respectent les règles du domaine
Intégrité référentielle
→ les références étrangères/métier existent
Fraîcheur
→ les données sont arrivées à temps
Volume
→ les nombres de lignes/partitions sont plausibles
Réconciliation
→ les totaux métier correspondent aux attentes de la source de confiance
Dérive
→ les distributions ou les contrats ont changé de façon inattendue
Exemple de base en PySpark :
from pyspark.sql import functions as F
result = (
df.agg(
F.count("*").alias("row_count"),
F.countDistinct("order_id").alias("distinct_order_id"),
F.sum(
F.when(F.col("order_id").isNull(), 1).otherwise(0)
).alias("null_order_id"),
F.sum("amount").alias("amount_total"),
F.min("order_date").alias("min_order_date"),
F.max("order_date").alias("max_order_date"),
)
.collect()[0]
)
La règle essentielle est :
les contrôles doivent faire respecter un contrat connu
et non inventer des seuils arbitraires
Code / commandes
1. Valider les colonnes obligatoires
required_columns = {
"order_id",
"customer_id",
"order_date",
"amount",
}
actual_columns = set(df.columns)
missing = required_columns - actual_columns
if missing:
raise ValueError(
f"Missing required columns: {sorted(missing)}"
)
Utilisez ce contrôle avant les transformations qui supposent l’existence de ces champs.
2. Détecter les colonnes inattendues
allowed_columns = {
"order_id",
"customer_id",
"order_date",
"amount",
"currency",
}
unexpected = set(df.columns) - allowed_columns
if unexpected:
print(
f"Unexpected columns: {sorted(unexpected)}"
)
Le choix entre échec et avertissement dépend de votre politique d’évolution du schéma.
3. Valider les types de données Spark
expected_types = {
"order_id": "string",
"customer_id": "string",
"order_date": "date",
"amount": "decimal(18,2)",
}
actual_types = {
field.name: field.dataType.simpleString()
for field in df.schema.fields
}
mismatches = {
name: {
"expected": expected,
"actual": actual_types.get(name),
}
for name, expected in expected_types.items()
if actual_types.get(name) != expected
}
if mismatches:
raise ValueError(
f"Schema type mismatches: {mismatches}"
)
Utilisez des types explicites pour les pipelines critiques.
4. Vérifier les champs obligatoirement non nuls
from pyspark.sql import functions as F
required_not_null = [
"order_id",
"order_date",
]
null_checks = [
F.sum(
F.when(F.col(c).isNull(), 1).otherwise(0)
).alias(f"{c}_nulls")
for c in required_not_null
]
result = df.agg(*null_checks)
result.show(truncate=False)
Une clé métier principale ne devrait souvent contenir aucune valeur nulle.
N’appliquez pas de règle « zéro nul » aux champs facultatifs.
5. Vérifier le pourcentage de valeurs nulles
row_count = df.count()
null_stats = df.agg(
*[
(
F.sum(
F.when(F.col(c).isNull(), 1).otherwise(0)
) / F.lit(row_count)
).alias(f"{c}_null_pct")
for c in df.columns
]
)
null_stats.show(truncate=False)
Utilisez des pourcentages pour surveiller la dérive.
Ne supposez pas qu’il existe un pourcentage de nulls acceptable universel.
6. Éviter d’analyser la table à plusieurs reprises
Au lieu d’exécuter :
count()
compter les nulls
compter les doublons
somme du montant
comme des actions distinctes, regroupez les contrôles dans une seule agrégation lorsque c’est possible.
Les analyses distribuées sont coûteuses.
7. Vérifier l’unicité de la clé métier
duplicates = (
df.groupBy("order_id")
.count()
.filter(F.col("count") > 1)
)
duplicate_count = duplicates.count()
Si order_id est censé définir une seule ligne, tout doublon constitue une violation du contrat.
8. Valider l’unicité d’une clé composite
duplicates = (
df.groupBy(
"merchant_id",
"order_id",
)
.count()
.filter(F.col("count") > 1)
)
Utilisez le grain métier réel, et non une colonne unique choisie arbitrairement.
9. Ne pas utiliser dropDuplicates() comme contrôle de qualité
À éviter :
df = df.dropDuplicates(["order_id"])
Cela fait disparaître les preuves.
Commencez par détecter et examiner les doublons.
Résolvez-les ensuite à l’aide d’une règle métier documentée.
10. Examiner des exemples de doublons
duplicate_keys = (
df.groupBy("order_id")
.count()
.filter(F.col("count") > 1)
.select("order_id")
)
examples = (
df.join(
duplicate_keys,
on="order_id",
how="inner",
)
.orderBy("order_id")
)
examples.show(100, truncate=False)
Déterminez si les doublons sont :
- de véritables doublons de la source
- des nouvelles tentatives
- des enregistrements versionnés
- une multiplication due à une jointure
- plusieurs événements légitimes
11. Valider le grain des lignes après les jointures
Supposons que la sortie doive contenir une ligne par commande.
Vérifiez :
summary = df.agg(
F.count("*").alias("rows"),
F.countDistinct("order_id").alias("distinct_orders"),
)
summary.show()
Si :
rows > distinct_orders
déterminez si plusieurs lignes par commande sont attendues.
12. Valider une plage numérique
Exemple :
invalid = df.filter(
F.col("amount") < 0
)
Ne considérez les valeurs négatives comme invalides que si le contrat métier l’indique.
Les retours et remboursements peuvent légitimement être négatifs.
13. Valider des valeurs de domaine bornées
allowed_status = [
"pending",
"completed",
"cancelled",
]
invalid_status = df.filter(
~F.col("status").isin(allowed_status)
& F.col("status").isNotNull()
)
Utilisez un ensemble de valeurs gouverné.
14. Valider les codes de devise
Exemple :
invalid_currency = df.filter(
~F.col("currency").isin(
"USD",
"CAD",
"EUR",
)
)
En production, utilisez le référentiel des devises prises en charge par l’organisation plutôt que de coder en dur des hypothèses globales incomplètes.
15. Valider des motifs de chaînes
Exemple :
invalid_ids = df.filter(
~F.col("order_id").rlike(r"^[A-Z0-9\-]+$")
)
N’utilisez une expression régulière que si le contrat de l’identifiant est réellement défini.
N’inventez pas de contraintes de format à partir de simples échantillons.
16. Vérifier les chaînes vides séparément des nulls
empty_names = df.filter(
F.trim(F.col("customer_name")) == ""
)
Une valeur nulle et une chaîne vide sont deux états différents.
Ne les regroupez pas, sauf si la règle métier indique qu’ils sont équivalents.
17. Normaliser les espaces avant la validation lorsque c’est pertinent
df = df.withColumn(
"country_code",
F.trim(F.col("country_code"))
)
Ne normalisez pas silencieusement des identifiants dont les espaces de début ou de fin ont une signification.
18. Valider des plages de dates
Exemple :
invalid_dates = df.filter(
F.col("end_date") < F.col("start_date")
)
Il s’agit d’une règle sémantique défendable.
19. Valider les dates futures impossibles
Si les règles métier interdisent les événements datés dans le futur :
invalid = df.filter(
F.col("event_date") > F.current_date()
)
N’utilisez ce contrôle que lorsque les dates futures sont réellement invalides.
20. Valider l’analyse des horodatages
Si les horodatages de la source sont des chaînes :
parsed = df.withColumn(
"event_ts_parsed",
F.to_timestamp("event_ts")
)
bad = parsed.filter(
F.col("event_ts").isNotNull()
& F.col("event_ts_parsed").isNull()
)
Examinez les échecs avant d’écraser le champ texte d’origine.
21. Conserver les valeurs brutes pendant l’analyse
Bonne pratique :
event_ts_raw
event_ts_parsed
Cela aide à diagnostiquer les problèmes de format de la source.
Ne détruisez pas la valeur d’origine avant que la validation ait réussi.
22. Valider l’intégrité référentielle
Exemple :
missing_customers = (
orders.alias("o")
.join(
customers.select("customer_id").alias("c"),
on="customer_id",
how="left_anti",
)
)
Il s’agit des lignes de commande dont la clé client est absente du jeu de données de référence.
23. Faire attention au calendrier des données de référence
Une ligne de dimension manquante peut signifier :
clé source invalide
ou :
dimension arrivée en retard
Ne classez pas automatiquement chaque résultat d’anti-jointure comme une donnée corrompue.
24. Mettre en quarantaine les enregistrements invalides
Modèle :
valid = df.filter(
F.col("order_id").isNotNull()
)
invalid = df.filter(
F.col("order_id").isNull()
)
Écrivez les enregistrements invalides avec :
validation_reason
batch_id
source_file
ingestion_time
Ne les supprimez pas silencieusement s’ils ont une importance opérationnelle.
25. Ajouter des codes de motif
Exemple :
invalid = (
df.withColumn(
"validation_reason",
F.when(
F.col("order_id").isNull(),
F.lit("missing_order_id"),
)
.when(
F.col("amount").isNull(),
F.lit("missing_amount"),
)
)
.filter(F.col("validation_reason").isNotNull())
)
Lorsque plusieurs problèmes surviennent simultanément, envisagez un tableau ou une liste de motifs plutôt qu’un motif unique écrasé.
26. Valider la présence des fichiers source
Pour des flux quotidiens attendus :
orders_20261004.csv
customers_20261004.csv
un travail réussi ne devrait pas s’exécuter avec une seule des sources requises.
Comparez les fichiers attendus et reçus avant le traitement.
27. Valider le nombre de fichiers source
Exemple :
attendu :
1 fichier de contrôle
12 fichiers horaires
reçu :
11 fichiers horaires
Le choix entre échouer ou attendre dépend du contrat d’ingestion.
28. Valider la complétude des partitions
Si une partition par jour est attendue :
expected_dates = ...
actual_dates = ...
missing_dates = expected_dates - actual_dates
Une table peut contenir des lignes valides et pourtant manquer une journée entière.
29. Valider la fraîcheur
Exemple :
latest = df.agg(
F.max("ingested_at").alias("latest_ingested_at")
)
latest.show()
Comparez avec le SLA réel du jeu de données.
N’inventez pas de seuil de fraîcheur global.
30. Distinguer la fraîcheur de la source de celle du pipeline
Suivez :
heure de l’événement source
heure d’ingestion
heure de fin du traitement
Exemple :
la source a 2 heures de retard
le pipeline la traite en 2 minutes
Le pipeline est rapide, mais les données métier sont obsolètes.
31. Comparer le nombre de lignes à l’historique
Stockez des métriques par exécution :
batch_id
row_count
Comparez ensuite le volume actuel aux références récentes.
N’échouez pas sur des variations en pourcentage arbitraires sans comprendre la saisonnalité naturelle et le comportement de la source.
32. Fonder les seuils d’anomalie sur des faits
Pour certains flux, une variation de 5 % est significative.
Pour d’autres, le volume quotidien varie légitimement de 200 %.
Construisez les seuils à partir de :
- la distribution historique
- le calendrier métier
- la saisonnalité connue
- le contrat de la source
33. Valider avec prudence les chargements à zéro ligne
Zéro ligne peut signifier :
période creuse légitime
défaillance de la source
bug de filtre
fichier manquant
mauvais watermark
Ne considérez pas automatiquement zéro comme un succès ou un échec sans contexte.
34. Réconcilier les totaux financiers
Exemple :
totals = df.agg(
F.count("*").alias("rows"),
F.sum("amount").alias("amount_total"),
)
totals.show()
Comparez avec le total de contrôle ou de la source de confiance lorsqu’il est disponible.
35. Réconcilier par segment métier
Exemple :
(
df.groupBy("merchant_id")
.agg(
F.count("*").alias("rows"),
F.sum("amount").alias("amount_total"),
)
.orderBy("merchant_id")
)
Les totaux globaux peuvent masquer un segment surchargé ou sous-chargé.
36. Réconcilier au grain attendu
Les dimensions utiles peuvent inclure :
date
tenant
merchant
devise
système source
Choisissez des dimensions alignées sur la façon dont le métier valide les données.
37. Vérifier les doublons lors de la préparation d’un MERGE
Avant un MERGE Delta :
source_dupes = (
source.groupBy("order_id")
.count()
.filter(F.col("count") > 1)
)
if source_dupes.limit(1).count() > 0:
raise ValueError(
"MERGE source contains duplicate order_id values"
)
Cela évite les mises à jour ambiguës.
38. Valider avant de faire avancer le watermark
Ordre correct :
lire la source
→ transformer
→ valider
→ écrire
→ réconcilier
→ valider/enregistrer le watermark
Ne faites pas avancer l’état avant que les contrôles de qualité bloquants soient passés.
39. Valider aussi après l’écriture
Les contrôles avant écriture confirment le jeu de données candidat.
Les contrôles après écriture confirment le résultat stocké.
Contrôles après écriture utiles :
nombre de lignes de la cible
nombre de clés distinctes de la cible
totaux métier de la cible
couverture des partitions de la cible
40. Vérifier l’idempotence
Relancez le même lot et vérifiez que la cible ne double pas.
Exemple :
même batch_id
mêmes enregistrements source
→ même état final de la table
Il s’agit d’une propriété de qualité, et pas seulement d’une question d’orchestration.
41. Conserver les identifiants de lot
Colonnes utiles :
batch_id
source_file
ingested_at
pipeline_run_id
Cela aide à retracer les chargements en double ou manquants.
42. Détecter les fichiers source répétés
Suivez le manifeste de la source :
source_file
file_size
checksum/hash
received_at
processed_batch_id
Un nom de fichier répété ne prouve pas à lui seul que le contenu est dupliqué.
Un hachage ou des identifiants fournis par la source peuvent aider.
43. Utiliser les hachages avec prudence
Un hachage d’enregistrement peut aider à identifier les lignes inchangées ou en double.
Exemple :
from pyspark.sql import functions as F
df = df.withColumn(
"record_hash",
F.sha2(
F.concat_ws(
"||",
F.col("customer_id"),
F.col("status"),
F.col("amount").cast("string"),
),
256,
)
)
Définissez soigneusement le formatage canonique.
Les nulls, les décimaux, les horodatages et les espaces peuvent modifier le hachage de manière inattendue.
44. Ne pas hacher aveuglément une sérialisation instable
Modèle à éviter :
hacher la chaîne JSON entière
si l’ordre ou le formatage des champs peut changer alors que la sémantique reste identique.
Canonicalisez d’abord les champs.
45. Valider les règles de comparaison tenant compte des nulls
Lorsque vous comparez des enregistrements actuels et antérieurs, n’oubliez pas que :
NULL = NULL
n’est pas vrai selon la sémantique SQL normale.
Utilisez une comparaison null-safe lorsque le moteur la prend en charge et que le sens métier l’exige.
46. Valider la dérive de schéma
Suivez :
colonnes ajoutées
colonnes supprimées
changements de type
changements de nullabilité
Classez les changements :
compatible
avertissement
cassant
Ne traitez pas chaque nouvelle colonne nullable comme un échec bloquant si votre contrat autorise une évolution compatible.
47. Détecter délibérément l’élargissement ou le rétrécissement des types
Exemples :
int → long
decimal(18,2) → decimal(18,4)
string → int
Leurs implications en matière de compatibilité sont différentes.
Ne comparez pas les schémas uniquement par nom de colonne.
48. Valider la précision et l’échelle des décimaux
Les champs financiers doivent respecter la précision et l’échelle attendues.
Une conversion inattendue en virgule flottante justifie un échec précoce.
49. Valider les hypothèses de fuseau horaire
Vérifiez si les horodatages sont :
UTC
heure locale
avec décalage horaire
naïf
Un décalage de fuseau horaire peut produire des dates apparemment valides mais incorrectes.
50. Vérifier le comportement aux limites de date
Exemple :
23:30 UTC
peut correspondre à une autre date métier locale.
Si les rapports quotidiens reposent sur l’heure locale, validez le regroupement après la conversion de fuseau horaire.
51. Valider les énumérations par rapport à une table de référence
Au lieu de listes codées en dur :
invalid = (
facts.alias("f")
.join(
valid_statuses.alias("s"),
F.col("f.status") == F.col("s.status"),
"left_anti",
)
)
Utile lorsque les valeurs de domaine sont gouvernées à l’extérieur.
52. Valider les attentes un-à-plusieurs
Exemple :
une commande
→ plusieurs lignes de détail
C’est valide.
La règle de qualité devrait être :
un seul en-tête de commande par order_id
et non :
order_id unique dans le jeu de données joint commandes-lignes
Les contrôles doivent correspondre au grain des données.
53. Vérifier les lignes enfants orphelines
orphans = (
order_lines.alias("l")
.join(
orders.select("order_id").alias("o"),
on="order_id",
how="left_anti",
)
)
Examinez l’ordre de la source et le comportement des arrivées tardives avant de supprimer ou de rejeter.
54. Valider les relations entre agrégats
Exemple :
order_total
≈
somme(order_line_amount)
Utilisez une comparaison exacte ou avec tolérance selon les règles de devise et d’arrondi.
N’inventez pas de tolérances arbitraires.
55. Valider les relations de proportion
Exemple :
discount <= subtotal
ou :
tax >= 0
uniquement si ces règles sont vraies pour le domaine.
56. Détecter les combinaisons impossibles
Exemple :
statut = annulé
ET
shipped_at IS NOT NULL
si cet état est impossible dans le cycle de vie métier.
Ces contrôles croisés entre champs ont souvent plus de valeur que des contrôles de nulls génériques.
57. Valider les transitions de cycle de vie
Pour les entités avec état :
en attente
→ approuvé
→ terminé
Une transition comme :
terminé
→ en attente
peut être invalide.
Cela nécessite une validation tenant compte de l’historique et de l’état.
58. Vérifier les champs de séquence monotones
Si la source fournit :
sequence_number
validez :
- les doublons
- les trous, si les trous ne sont pas autorisés
- les régressions
- les arrivées dans le désordre
Ne supposez pas que chaque séquence est sans trou, sauf si c’est documenté.
59. Valider les identifiants d’événement
Pour les pipelines d’événements, un identifiant d’événement stable permet :
dédoublonnage
replay
idempotence
traçabilité
Vérifiez l’unicité sur la fenêtre de rétention appropriée.
60. Les contrôles de qualité des données peuvent être des avertissements ou bloquants
Classez les contrôles :
BLOQUANT
→ le pipeline doit s’arrêter/mettre en quarantaine
AVERTISSEMENT
→ continuer mais alerter
MÉTRIQUE
→ enregistrer pour le suivi des tendances
Toutes les anomalies ne doivent pas arrêter la production.
61. Utiliser la gravité de manière délibérée
Exemple :
clé primaire manquante
→ bloquant
nombre de lignes légèrement inhabituel
→ avertissement/métrique
nouvelle colonne facultative
→ avertissement
La gravité doit découler de l’impact métier.
62. Éviter un score de qualité global unique
Un score comme :
97 % de qualité
peut masquer :
0,1 % de clés primaires manquantes
ce qui peut être inacceptable.
Suivez les règles individuelles et leur impact métier.
63. Attribuer des identifiants de règle stables
Exemple :
DQ_ORDER_001
→ order_id ne doit pas être nul
DQ_ORDER_002
→ order_id unique dans les commandes Silver
DQ_ORDER_003
→ la devise du montant doit être reconnue
Cela facilite :
- les alertes
- les tableaux de bord
- la documentation
- le suivi des tendances
64. Enregistrer les résultats des règles
Schéma utile :
run_id
dataset
rule_id
status
failed_count
checked_count
severity
observed_value
expected_rule
checked_at
Cela crée une piste d’audit.
65. Conserver des échantillons d’échecs
Pour les règles en échec, stockez un échantillon borné :
rule_id
clé métier
valeur invalide
fichier source
lot
Ne stockez pas toutes les lignes incorrectes dans les métadonnées de supervision si le volume peut être énorme.
Utilisez des tables ou fichiers de quarantaine pour le détail complet.
66. Protéger les données sensibles dans les journaux de qualité
N’exposez pas :
mots de passe
jetons
données personnelles complètes
données de paiement
dans les journaux de validation.
Utilisez des clés métier ou des échantillons masqués lorsque c’est possible.
67. Réconcilier le nombre de lignes avant et après les filtres
Exemple :
lignes source
-
lignes invalides
-
lignes dédoublonnées
=
lignes cibles valides
Cette comptabilité rend la perte de lignes explicable.
68. Garder une comptabilité explicite des rejets
Exemple :
10 000 lignes source
9 950 valides
30 en double
20 invalides
C’est beaucoup plus utile que :
pipeline réussi
69. Vérifier la multiplication des lignes dans les jointures
Avant la jointure :
100 000 commandes
Après la jointure avec une dimension supposée un-à-un :
125 000 lignes
Cela indique des clés de dimension en double ou un mauvais grain de jointure.
70. Appliquer le principe des contrôles de type validate dans les pipelines distribués
Même lorsque le framework ne propose pas d’équivalent au validate="many_to_one" de pandas, imposez explicitement la même attente.
Exemple :
la clé de dimension doit être unique avant la jointure
Vérifiez-le.
71. Valider le nombre de lignes par partition
Exemple :
(
df.groupBy("order_date")
.agg(F.count("*").alias("rows"))
.orderBy("order_date")
)
Les contrôles par partition détectent une journée manquante masquée par un total global normal.
72. Valider les totaux par partition
(
df.groupBy("order_date")
.agg(
F.count("*").alias("rows"),
F.sum("amount").alias("amount_total"),
)
.orderBy("order_date")
)
Utile pour les pipelines financiers et transactionnels.
73. Détecter les partitions ou lots en double
Vérifiez si les mêmes :
batch_id
partition_date
fichier source
ont été validés plus d’une fois.
Cela révèle souvent des bogues de nouvelle tentative.
74. Valider les limites incrémentales
Pour les chargements par watermark, enregistrez :
watermark de début
watermark de fin
lignes source
lignes cibles
Vérifiez ensuite qu’aucun intervalle n’a été :
ignoré
chevauché involontairement
retraité sans idempotence
75. Utiliser des fenêtres temporelles semi-ouvertes de manière cohérente
Exemple :
[start, end)
Cela permet aux lots adjacents de s’enchaîner sans chevauchement des horodatages de fin.
Les égalités d’horodatage et les arrivées tardives exigent toutefois une conception explicite.
76. Vérifier les enregistrements arrivés en retard
Mesurez :
ingestion_time - event_time
Suivez la distribution dans le temps.
Appuyez-vous sur le comportement réel de la source pour définir la politique de retard.
77. Détecter la dérive des distributions
Exemples :
répartition par pays
répartition par statut
distribution des montants
taux de nulls
nombre de clients distincts
Comparez à l’historique.
Ne déclenchez pas d’alerte à chaque fluctuation naturelle.
78. Vérifier la distribution catégorielle
(
df.groupBy("status")
.count()
.orderBy(F.desc("count"))
.show()
)
Un statut nouveau ou inconnu peut indiquer un changement dans la source.
79. Vérifier le résumé numérique
df.select(
F.min("amount").alias("min_amount"),
F.max("amount").alias("max_amount"),
F.avg("amount").alias("avg_amount"),
).show()
Appuyez-vous sur les tendances et le contexte plutôt que sur des valeurs « acceptables » universelles.
80. Utiliser les percentiles avec prudence
Pour des métriques asymétriques, des percentiles approximatifs peuvent être plus informatifs que la moyenne.
Exemple :
df.selectExpr(
"percentile_approx(amount, array(0.5, 0.95, 0.99)) AS percentiles"
).show(truncate=False)
Le comportement des percentiles approximatifs dépend du moteur et de la configuration.
81. Comparer les métriques actuelles et historiques
Stockez des métriques par exécution afin de pouvoir répondre à :
Le taux de nulls a-t-il bondi ?
Le nombre de lignes s’est-il effondré ?
Une catégorie a-t-elle disparu ?
La distribution des montants a-t-elle changé ?
Le contexte des tendances est plus utile que des seuils isolés.
82. Détecter les colonnes entièrement nulles
row_count = df.count()
all_null_exprs = [
(
F.sum(
F.when(F.col(c).isNull(), 1).otherwise(0)
) == row_count
).alias(c)
for c in df.columns
]
Un champ obligatoire entièrement nul signale souvent une défaillance de l’analyseur, du schéma ou de la source.
83. Vérifier les colonnes constantes
Un champ qui n’a soudain plus qu’une seule valeur distincte peut indiquer :
- un bogue de valeur codée en dur dans la source
- un problème d’analyseur
- une valeur par défaut en amont
- une condition métier légitime
Suivez :
df.select(
*[
F.countDistinct(c).alias(c)
for c in df.columns
]
)
Utilisez ce contrôle de manière sélective, sur des colonnes gérables ou à forte valeur.
84. Faire attention aux contrôles distinct coûteux
countDistinct peut générer un shuffle important.
N’exécutez pas des dizaines d’analyses distinct complètes sur des tables massives sans prioriser les clés et colonnes importantes.
Regroupez le travail lorsque c’est possible.
85. Échantillonner uniquement pour l’exploration, pas pour les garanties finales
sample = df.sample(
withReplacement=False,
fraction=0.01,
)
Un échantillon peut révéler des problèmes.
Il ne peut pas prouver :
zéro doublon
zéro clé invalide
intégrité référentielle complète
Utilisez des contrôles complets lorsque le contrat exige une certitude.
86. Éviter de collecter de grands ensembles invalides sur le driver
À éviter :
bad_rows = invalid.collect()
En cas d’échecs volumineux, écrivez dans un stockage de quarantaine et ne collectez que de petits résumés ou échantillons.
87. Limiter les exemples dans les alertes
Alerte :
règle en échec
failed_count=1,248,321
sample_keys=[...]
N’attachez pas un million de lignes incorrectes aux journaux ou à un e-mail.
88. Conserver séparément les preuves complètes des échecs
Modèle :
table des résultats de qualité
→ synthèse
table de quarantaine
→ lignes en échec complètes
Cela sépare la supervision de la correction détaillée.
89. Valider le schéma cible après l’écriture
target = spark.read.table("silver.orders")
target.printSchema()
Utile lorsque l’évolution du schéma ou le comportement d’écrasement entre en jeu.
90. Valider l’unicité de la cible après un MERGE
duplicates = (
spark.read.table("silver.orders")
.groupBy("order_id")
.count()
.filter(F.col("count") > 1)
)
Ne supposez pas que la logique du MERGE a préservé le grain prévu.
91. Comparer les clés de la source et de la cible
Clés absentes de la cible :
missing = (
source.select("order_id").distinct()
.join(
target.select("order_id").distinct(),
on="order_id",
how="left_anti",
)
)
Clés en trop dans la cible :
extra = (
target.select("order_id").distinct()
.join(
source.select("order_id").distinct(),
on="order_id",
how="left_anti",
)
)
À utiliser uniquement lorsque les périmètres de la source et de la cible sont réellement comparables.
92. Le périmètre de la réconciliation doit correspondre
Ne comparez pas :
la source du jour
avec :
tout l’historique de la cible
sans appliquer le même périmètre métier, de date ou de tenant.
93. Valider les comptages avant un écrasement destructif
Avant de remplacer une partition ou une table :
nombre de lignes du nouveau candidat
vs
nombre attendu existant/source
Si le candidat est vide de manière inattendue, arrêtez-vous avant l’écrasement.
94. Ajouter des garde-fous aux reconstructions
Exemple :
candidate_count = candidate.count()
if candidate_count == 0:
raise ValueError(
"Refusing to overwrite target with zero rows"
)
N’utilisez ce contrôle que si zéro ligne ne peut jamais être légitime pour cette reconstruction.
95. Les règles de qualité doivent être versionnées avec le code
Une modification de règle fait partie du comportement du pipeline.
Suivez :
version de la règle
commit du code
déploiement
Cela aide à expliquer pourquoi des données ont commencé à échouer après une mise en production.
96. Distinguer les défauts de la source de ceux du pipeline
Classez les échecs :
qualité de la source
contrat de schéma
transformation du pipeline
données de référence
écriture dans la cible
Cela aide à attribuer correctement la responsabilité.
97. Les contrôles de qualité ont besoin d’un responsable
Chaque règle bloquante doit avoir :
responsable
runbook
action attendue
chemin d’escalade
Un contrôle en échec sans responsable devient du bruit d’alerte.
98. Définir le chemin de correction
Pour chaque règle importante :
faire échouer le pipeline ?
mettre en quarantaine les lignes invalides ?
continuer avec un avertissement ?
relancer la source ?
rattraper plus tard (backfill) ?
ouvrir un incident ?
Décidez-en avant la défaillance en production.
99. La qualité des données s’applique à plusieurs couches
Modèle typique :
Bronze
→ contrôles d’ingestion/de la source
Silver
→ schéma, dédoublonnage, validité, règles référentielles
Gold
→ réconciliation métier, grain, cohérence des métriques
Ne placez pas toutes les règles dans une seule couche.
100. Utiliser un processus de qualité reproductible
1. Valider le schéma
2. Valider les clés obligatoires
3. Valider l’unicité/le grain
4. Valider les règles du domaine
5. Valider les références
6. Valider la fraîcheur/le volume
7. Réconcilier les totaux métier
8. Mettre les échecs en quarantaine
9. Conserver les résultats des règles
10. Avancer le watermark uniquement après le passage des contrôles requis
Interpréter le résultat
| Type de contrôle | Ce qu’il protège |
|---|---|
| Schéma | Compatibilité du contrat |
| Non nul | Complétude des données obligatoires |
| Unicité | Grain métier attendu |
| Domaine/plage | Validité sémantique |
| Intégrité référentielle | Cohérence entre entités |
| Fraîcheur | Disponibilité des données dans les délais |
| Volume | Chargements manquants ou en double |
| Réconciliation | Exactitude métier |
| Dérive des distributions | Changements inattendus de la source ou du comportement |
| Idempotence | Nouvelles tentatives et retraitements sûrs |
| Couverture des partitions | Tranches temporelles ou de tenant manquantes |
Le principe fondamental est :
qualité des données = contrats métier/données explicites
et non des pourcentages génériques
Points à vérifier
Le nombre de lignes chute soudainement
Vérifiez :
- des fichiers source manquants
- des changements de filtre ou de watermark
- une panne de la source
- des échecs d’analyse du schéma
- des partitions omises
Le nombre de lignes augmente soudainement
Vérifiez :
- un chargement en double de la source
- une multiplication due à une jointure
- une duplication due aux nouvelles tentatives
- un changement de comportement de la source
Des clés en double apparaissent après une jointure
Examinez l’unicité des clés du côté droit et la cardinalité de la jointure.
Le taux de nulls grimpe brusquement
Vérifiez le schéma de la source, l’analyse, les champs renommés et les valeurs par défaut en amont.
Les totaux financiers divergent alors que le nombre de lignes correspond
Vérifiez :
- des montants en double
- la devise
- les filtres
- l’arrondi
- les conventions de signe
- des lignes de détail supprimées ou dupliquées
Le contrôle de fraîcheur échoue alors que la durée du pipeline est normale
La source est peut-être en retard, plutôt que le pipeline lent.
Notes de production
Les contrôles consomment des ressources de calcul
Les analyses de table complète, les comptages distinct et les jointures référentielles peuvent être coûteux.
Priorisez les règles critiques et regroupez les agrégations.
Les règles bloquantes doivent être déterministes
Une règle qui échoue aléatoirement à cause d’un échantillonnage instable ne convient pas comme contrôle bloquant en production.
L’état de la qualité doit être auditable
Conservez :
règle
exécution
valeur observée
statut
horodatage
et pas seulement une ligne de journal « réussite/échec ».
La quarantaine n’est pas une poubelle
Les enregistrements en quarantaine nécessitent :
- un motif
- un responsable
- une durée de rétention
- un chemin de correction
Les seuils doivent reposer sur des faits
Ne copiez pas des seuils génériques comme :
5 % de nulls
10 % d’écart du nombre de lignes
sans justification métier ou historique.
Les contrôles de qualité ne doivent bloquer par défaut que là où le métier l’exige
Toutes les anomalies ne doivent pas interrompre l’ensemble de la livraison des données.
Appuyez-vous sur la gravité et l’impact.
Erreurs fréquentes
1. Utiliser un score de qualité générique unique
Des défaillances critiques peuvent être masquées par un score moyen élevé.
2. Supprimer les doublons sans les examiner
Cela détruit les preuves et peut écarter la mauvaise ligne.
3. Considérer chaque null comme une erreur
Une valeur nulle peut être valide pour des champs facultatifs.
4. Considérer zéro ligne comme toujours invalide
Certains flux n’ont légitimement aucune activité.
5. S’appuyer uniquement sur le nombre de lignes
Les totaux métier et les contrôles au niveau des clés peuvent révéler des erreurs que le nombre de lignes ne voit pas.
6. Contrôler la qualité uniquement avant l’écriture
Le comportement d’écriture dans la cible peut encore introduire des problèmes.
7. Utiliser des seuils arbitraires
Les seuils doivent découler des contrats et du comportement historique.
8. Collecter toutes les lignes incorrectes sur le driver
Cela peut faire planter de gros travaux distribués.
9. Faire avancer les watermarks avant que les contrôles bloquants soient passés
Cela peut faire sauter définitivement des données en échec.
10. Alerter sans responsable ni chemin de correction
Cela crée du bruit au lieu de fiabilité.
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.