Cloud et automatisation
Design patterns pour le data engineering : modèles pratiques pour des plateformes de données fiables
Un guide pratique des design patterns appliqués au data engineering : ingestion, transformation, orchestration, stockage, fiabilité et serving.
Dans cet article
Quand les développeurs entendent parler de design patterns, ils pensent souvent aux patterns logiciels comme Factory, Strategy, Observer ou Repository.
Ces patterns restent utiles dans les systèmes de données, mais le data engineering a aussi ses propres problèmes récurrents :
- ingérer des données depuis des sources peu fiables ;
- traiter plusieurs fois le même fichier ou le même événement ;
- détecter uniquement ce qui a changé ;
- séparer les données brutes des données fiables ;
- gérer les enregistrements invalides sans arrêter tout un pipeline ;
- relancer sans risque après une erreur transitoire ;
- reconstruire les tables en aval sans corrompre l’historique ;
- servir le même jeu de données à des consommateurs différents ;
- garder des transformations compréhensibles à mesure que la plateforme grandit.
Ces problèmes se répètent d’une technologie à l’autre : SQL Server, Microsoft Fabric, Spark, Delta Lake, Kafka, les APIs, les warehouses et les lakehouses.
Ce sont donc de bons candidats pour des patterns.
Un design pattern n’est ni une fonctionnalité de produit ni une architecture obligatoire. C’est une forme de solution réutilisable pour un problème qui revient souvent.
Cet article se concentre sur des patterns pratiques, applicables à toutes les plateformes de données.
Les patterns de données ne sont pas des design patterns logiciels
Un pattern logiciel décrit généralement la façon dont des classes ou des objets collaborent.
Un pattern de data engineering décrit souvent la façon dont les données circulent, changent, échouent, se rétablissent et deviennent exploitables.
- Source
- Brut
- Validé
- Préparé
- Serving
Ce n’est pas un design pattern orienté objet. C’est pourtant bien un pattern, car la même séparation résout la même catégorie de problèmes dans de nombreux systèmes.
Les patterns de données les plus utiles se répartissent généralement en six groupes :
- ingestion ;
- transformation ;
- orchestration ;
- stockage et modélisation ;
- fiabilité ;
- serving et intégration.
L’important n’est pas de mémoriser des noms. L’important est de reconnaître le problème que chaque pattern résout.
1. Traitement idempotent
Si je devais choisir un seul pattern que tout data engineer en production doit comprendre, ce serait l’idempotence.
Une opération est idempotente lorsque l’exécuter à nouveau avec la même entrée produit le même état final.
C’est important, parce que les pipelines échouent.
Un job peut expirer après avoir écrit des données, perdre son accusé de réception, être relancé par un orchestrateur, recevoir deux fois le même fichier, recevoir un événement en double ou être relancé manuellement.
Sans idempotence, les nouvelles tentatives peuvent créer des données en double.
Une clé métier ou d’ingestion stable peut reposer sur :
source_file + source_row_id
ou :
event_id
ou :
tenant_id + order_id + event_timestamp
Appliquez ensuite la règle selon laquelle une même entrée logique ne peut pas créer une autre copie logique.
L’implémentation exacte peut être une contrainte d’unicité, un MERGE, un INSERT ... WHERE NOT EXISTS, un merge Delta ou une étape de dédoublonnage.
C’est le pattern qui compte :
Une nouvelle tentative doit être sans risque.
Ne confondez pas unicité technique et unicité métier. Un ID de ligne généré n’empêche pas les événements métier en double si chaque nouvelle tentative génère un nouvel ID.
2. Chargement incrémental
Un rechargement complet est simple :
- Tout supprimer
- Tout recharger
Il peut aussi devenir extrêmement coûteux.
Le pattern de chargement incrémental ne traite que les enregistrements nouveaux ou modifiés depuis la précédente exécution réussie.
Les indicateurs de changement courants sont :
updated_at;- une identité croissante ;
- un numéro de séquence de la source ;
- le change tracking ;
- la capture des changements de données (CDC) ;
- une position dans le journal des transactions ;
- l’heure d’arrivée des fichiers ;
- un watermark.
Un flux de watermark courant ressemble à ceci :
- 1Lire le dernier watermark réussi
- 2Lire les lignes source après ce watermark
- 3Transformer
- 4Écrire la destination
- 5Valider le nouveau watermark
Le mot clé est réussi. Le watermark ne doit avancer qu’une fois les données correspondantes validées en toute sécurité.
Un horodatage seul peut aussi être dangereux. Si plusieurs enregistrements partagent le même horodatage, un watermark plus sûr peut inclure un critère de départage comme (updated_at, primary_key).
3. Change Data Capture
Les chargements incrémentaux répondent à la question : qu’est-ce qui a changé depuis ma précédente exécution ?
Le Change Data Capture, ou CDC, va plus loin en représentant les changements de la source comme un flux d’insertions, de mises à jour et de suppressions.
INSERT customer 42
UPDATE customer 42
DELETE customer 17
C’est utile pour la réplication opérationnelle, l’analytique quasi temps réel, les architectures orientées événements, l’ingestion dans un lakehouse et la synchronisation des magasins de serving.
Le CDC introduit aussi de nouvelles responsabilités d’ingénierie :
- l’ordre ;
- les doublons ;
- les suppressions ;
- les changements de schéma ;
- les checkpoints ;
- la relecture ;
- les événements tardifs.
Le CDC ne supprime pas la complexité. Il rapproche la détection des changements de la source et rend l’historique des changements explicite.
4. Couches brute → validée → préparée
L’un des patterns de plateforme les plus courants consiste à séparer les données selon leur niveau de confiance.
Les noms exacts varient :
- Brut
- Nettoyé
- Préparé
- Bronze
- Silver
- Gold
- Atterrissage
- Standardisé
- Serving
Les noms comptent moins que les responsabilités.
La couche brute conserve ce qui est arrivé. La couche validée normalise les types, applique les contrôles de qualité, dédoublonne et standardise les clés. La couche préparée met en forme les données pour l’analytique, les APIs, les rapports, le machine learning ou la consommation par domaine.
Cette séparation apporte quelque chose d’extrêmement précieux : la rejouabilité.
Si une règle de transformation change, vous pouvez souvent reconstruire les couches fiables à partir des données brutes conservées, au lieu de demander à la source de renvoyer l’historique.
Ne créez pas trois couches parce qu’un schéma vous l’a dit. Si chaque couche se contente de copier la précédente sans ajouter de responsabilité, vous avez créé de la surcharge, pas une architecture.
5. Pattern de quarantaine / dead-letter
Les données de production sont rarement parfaites.
Un pipeline fragile traite une ligne invalide de cette façon :
- 1 ligne invalide
- Tout le lot échoue
Un pattern plus résilient isole les enregistrements invalides.
- Enregistrements entrants
- Valider
- validesCible
- invalidesQuarantaine
L’enregistrement en quarantaine doit contenir assez d’informations pour analyser l’échec :
contenu d'origine
motif de l'erreur
règle de validation
source
ID d'exécution
horodatage
Dans les systèmes d’événements, l’équivalent s’appelle souvent une dead-letter queue.
Une table de quarantaine ne doit pas devenir un cimetière de données. Elle a besoin de supervision, d’un responsable, d’une durée de conservation et de règles de nouvelle tentative ou de correction.
6. Retry avec backoff exponentiel
Les erreurs transitoires sont normales dans les systèmes distribués :
- HTTP 429 ;
- HTTP 503 ;
- échec temporaire de connexion à la base de données ;
- throttling du stockage ;
- brève interruption réseau.
Des nouvelles tentatives immédiates et répétées peuvent aggraver la situation.
À la place :
- Échec
- attendre 1 sRéessayer
- attendre 2 sRéessayer
- attendre 4 sRéessayer
On ajoute souvent une composante aléatoire, ou jitter, pour que des milliers de workers ne réessaient pas exactement au même instant.
Les nouvelles tentatives doivent normalement être combinées à l’idempotence. Sinon, une requête peut réussir, sa réponse peut être perdue, et la nouvelle tentative peut créer une écriture en double.
Retry + idempotence + nombre de tentatives borné : c’est le pattern le plus solide.
7. Pattern pipeline / traitement par étapes
Les grosses transformations deviennent difficiles à comprendre quand toutes les règles vivent dans un seul notebook, une seule procédure stockée ou une seule fonction Python géante.
Un pattern pipeline découpe le traitement en étapes :
- Extraire
- Analyser
- Valider
- Normaliser
- Enrichir
- Publier
Chaque étape a une responsabilité et un contrat définis.
records = extract(source)
records = parse(records)
records = validate(records)
records = normalize(records)
records = enrich(records)
publish(records)
Les bénéfices : des tests plus simples, des échecs plus clairs, des étapes réutilisables, une meilleure observabilité et une responsabilité plus facile à attribuer.
Des étapes logiques n’ont pas forcément besoin de devenir des services réseau séparés.
8. Pattern Strategy pour les comportements propres à chaque source
Une plateforme de données peut commencer avec un seul flux CSV et devoir un jour prendre en charge :
CSV
JSON
SFTP
API
Base de données
Le code finit alors par devenir une longue chaîne de if/elif.
C’est là que le pattern Strategy classique devient utile.
Définissez un comportement commun :
class SourceReader:
def read(self):
raise NotImplementedError
Puis implémentez des stratégies propres à chaque source :
class CsvReader(SourceReader):
...
class ApiReader(SourceReader):
...
class SftpReader(SourceReader):
...
L’orchestration dépend de l’interface plutôt que des détails de la source.
C’est particulièrement utile pour les plateformes multi-tenant où les tenants utilisent des transports ou des formats différents, mais partagent le même cycle de vie d’ingestion.
9. Pattern Adapter pour les systèmes externes
Les systèmes externes exposent rarement exactement le contrat que votre plateforme attend.
Une API peut renvoyer :
{
"customerNumber": 42,
"created": "2026-10-09T14:00:00Z"
}
alors qu’une autre renvoie :
{
"id": 42,
"created_at": "2026-10-09 14:00:00"
}
Ne laissez pas les contrats propres à chaque source se répandre dans toute la plateforme.
Utilisez un Adapter :
- API externe
- Adapter
- Contrat client canonique
L’adapter traduit les noms de champs, les dates, la sémantique des valeurs nulles, les valeurs de statut, le comportement d’authentification et les erreurs propres à la source.
Les transformations en aval travaillent sur le modèle canonique.
10. Fan-out / fan-in
Parfois, une entrée doit déclencher plusieurs opérations indépendantes.
- Entrée
- Analyse
- Métriques de qualité
- Transformation principale
- Audit
- Notifications
C’est le fan-out.
Plus tard, les résultats peuvent être rassemblés :
- Tâche A
- Tâche B
- Tâche C
- Publication finale
C’est le fan-in.
Ce pattern est utile pour traiter plusieurs partitions ou fichiers, générer plusieurs formats de rapport, calculer des agrégations indépendantes ou écrire vers plusieurs magasins en aval.
Le fan-out introduit de la coordination. Vous devez décider ce que signifie l’échec d’une branche, si les branches réussies restent validées, comment fonctionnent les nouvelles tentatives et comment la fin du traitement est détectée.
11. Pattern snapshot + historique
Parfois, un consommateur veut l’état actuel :
Client 42
statut = Actif
pays = US
D’autres consommateurs ont besoin de savoir comment cet état a évolué.
Un pattern utile consiste à maintenir à la fois une table de l’état actuel et un historique, ou à modéliser l’historique avec des dates d’effet :
customer_id
status
valid_from
valid_to
is_current
C’est étroitement lié aux patterns de Slowly Changing Dimension.
L’idée plus générale est la suivante :
Séparer « qu’est-ce qui est vrai maintenant ? » de « qu’est-ce qui était vrai à un instant donné ? »
C’est utile pour les attributs client, la configuration des marchands, les règles de prix, la hiérarchie organisationnelle, le statut des comptes et les données de référence.
12. Pattern de serving matérialisé
Une erreur fréquente consiste à obliger chaque consommateur à exécuter des transformations complexes au moment de la requête.
- Requête de l’interface
- Calcul à la requête
- 12 jointures
- 3 grosses agrégations
- fonctions de fenêtrage
- Réponse
Le pattern de serving matérialisé déplace en amont le travail coûteux et réutilisable.
- Données brutes
- Transformation
- Résultat préparé / matérialisé
- API / tableau de bord / rapport
Les implémentations possibles incluent des tables d’agrégats, des vues matérialisées, des tables Gold, du Parquet pré-généré, des résultats de rapports en cache et des index de recherche.
Le compromis, c’est la fraîcheur.
Ne vous demandez pas seulement : faut-il précalculer ce résultat ?
Demandez-vous :
Le résultat est-il assez coûteux, assez souvent demandé et assez stable pour que le précalcul coûte moins cher que le recalcul ?
Traitement piloté par la configuration
À mesure qu’une plateforme de données grandit, coder chaque source en dur crée souvent des centaines de pipelines presque identiques.
Au lieu de :
Pipeline A pour le tenant A
Pipeline B pour le tenant B
Pipeline C pour le tenant C
vous pouvez utiliser :
Moteur d'ingestion générique
+
configuration
Exemple :
{
"tenant": "tenant-a",
"source_type": "sftp",
"format": "csv",
"delimiter": ",",
"encoding": "windows-1252",
"date_format": "%Y-%m-%d",
"target": "sales"
}
La configuration sélectionne des stratégies au lieu d’intégrer chaque décision dans le code d’orchestration.
Cela fonctionne particulièrement bien lorsque les différences sont des paramètres.
Cela fonctionne mal lorsque les tenants ont des processus métier fondamentalement différents et que la configuration devient un langage de programmation déguisé en JSON.
Patterns souvent combinés
Certaines combinaisons sont particulièrement utiles.
Chargement incrémental + watermark + idempotence
- Watermark
- Lire les changements
- Merge idempotent
- Valider le watermark
CDC + dédoublonnage + ordre
- Flux CDC
- Ordre / checkpoint
- Dédupliquer
- Appliquer le changement
Retry + backoff + circuit breaker
Utile pour appeler des systèmes en aval instables. Un circuit breaker cesse temporairement les appels après des échecs répétés, au lieu de solliciter sans relâche une dépendance en mauvaise santé.
Couche brute + quarantaine + relecture
La couche brute conserve les preuves, la quarantaine isole les problèmes et la relecture rend la reprise possible.
Strategy + Adapter + configuration
Utile pour les moteurs d’ingestion multi-sources ou multi-tenant.
Quand un pattern devient de la sur-ingénierie
Les patterns sont utiles parce qu’ils donnent un nom à des structures éprouvées.
Ils deviennent nuisibles quand les équipes les appliquent sans avoir le problème correspondant.
- N’implémentez pas de CDC pour une table de 5 000 lignes chargée une fois par jour si une lecture complète ne coûte presque rien.
- Ne construisez pas cinq couches de données quand deux ont des responsabilités claires.
- N’introduisez pas un bus de messages simplement parce que les systèmes asynchrones sont à la mode.
- Ne construisez pas un framework de plugins générique pour deux formats de fichier fixes.
- Ne créez pas un moteur de configuration si flexible que plus personne ne comprend ce qu’il va exécuter.
- N’introduisez pas l’event sourcing quand de simples tables d’historique répondent au besoin.
La meilleure architecture n’est pas celle qui contient le plus de patterns.
C’est celle où chaque pattern supprime un problème précis d’exploitation ou de maintenance.
Guide de choix pratique
| Problème | Pattern à envisager |
|---|---|
| Les nouvelles tentatives créent des doublons | Idempotence |
| Les chargements complets coûtent trop cher | Chargement incrémental |
| Besoin d’un flux de changements au niveau de la base | CDC |
| Besoin de relecture et d’auditabilité | Brute → validée → préparée |
| Des lignes invalides arrêtent tout le lot | Quarantaine / dead-letter |
| Échecs temporaires de systèmes distants | Retry + backoff exponentiel |
| La transformation est un énorme bloc unique | Pipeline / traitement par étapes |
| Plusieurs comportements selon la source | Strategy |
| Les schémas externes se répandent partout | Adapter |
| Du travail indépendant peut s’exécuter en parallèle | Fan-out / fan-in |
| Besoin des valeurs actuelles et historiques | Snapshot + historique / SCD |
| Des requêtes complexes se répètent sans cesse | Serving matérialisé |
| Des centaines de pipelines presque identiques | Traitement piloté par la configuration |
Ce que je standardiserais sur une plateforme de données
Si je définissais les standards d’ingénierie d’une plateforme de données en production, j’attendrais de la plupart des pipelines qu’ils répondent à ces questions :
Identité : qu’est-ce qui identifie l’entrée de façon unique ?
Relecture : le pipeline peut-il être relancé sans risque ?
Incrémentalité : comment sait-il ce qui a changé ?
Qualité : où vont les enregistrements invalides ?
État : où sont stockés les watermarks et les checkpoints ?
Observabilité : puis-je identifier l’exécution, le tenant, la source, l’heure de début et de fin, les lignes lues, les lignes écrites, les lignes rejetées, l’erreur et les nouvelles tentatives ?
Reprise : que se passe-t-il après un échec partiel ?
Serving : le consommateur lit-il des transformations brutes ou un modèle de serving conçu pour lui ?
Ces questions ont plus de valeur que de demander quelle technologie l’équipe a utilisée.
Un pipeline peut utiliser la plateforme la plus récente du marché et rester fragile si ces préoccupations sont absentes.
Les design patterns facilitent les discussions d’architecture
Un bénéfice sous-estimé des patterns, c’est la communication.
Comparez :
Nous avons un processus qui stocke le fichier d’origine, valide les enregistrements, met les lignes invalides ailleurs, relance les échecs temporaires de l’API et empêche les doublons.
avec :
L’ingestion est rejouable et idempotente, utilise une couche d’atterrissage brute, met en quarantaine les enregistrements invalides et relance les appels transitoires avec un backoff exponentiel.
La seconde description condense beaucoup d’informations d’architecture.
Ce vocabulaire partagé devient utile lors des revues d’architecture, des revues de code, des analyses d’incident, de l’intégration de nouveaux arrivants, des standards de plateforme et des documents de conception.
Les patterns ne sont pas seulement des techniques d’implémentation. Ce sont aussi un langage pour les décisions d’ingénierie.
Conclusion
Une bonne architecture de données consiste rarement à trouver la plateforme parfaite.
Elle consiste à traiter les problèmes récurrents de façon prévisible.
Les données arrivent en double. Les sources changent. Les APIs échouent. Les fichiers sont mal formés. Les jobs sont relancés. Les règles métier évoluent. Les consommateurs veulent à la fois des données fraîches et des réponses rapides.
Les technologies continueront de changer, mais ces problèmes continueront d’apparaître.
C’est pourquoi des patterns comme l’idempotence, le chargement incrémental, le CDC, le traitement par couches, la quarantaine, le retry, Strategy, Adapter, le fan-out/fan-in, la modélisation de l’historique et le serving matérialisé restent utiles.
Les plateformes de données les plus solides ne sont pas celles qui ont les schémas les plus compliqués.
Ce sont celles où les modes de défaillance courants ont déjà été anticipés, et où la solution est reproductible au lieu d’être réinventée dans chaque pipeline.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Continuer à apprendre
- ArticlePatterns d’intégration de données : guide pratique pour les plateformes modernesGuide pratique des patterns modernes d’intégration : batch, ETL, ELT, CDC, streaming, réplication, API, fédération, reverse ETL et zero-copy.Lire l’article
- Aide-mémoireArchitecture Medallion : référence rapideConcevoir des couches de données Bronze, Silver et Gold avec des responsabilités clairement attribuées, la possibilité de rejouer les chargements, des contrôles qualité, un traitement incrémental et des contrats de restitution, sans réduire l’architecture Medallion à une convention rigide de nommage de dossiers.Ouvrir l’aide-mémoire
- RessourceContenu en anglaisMicrosoft Fabric Certification Study PlannerAn adaptable 6–8 week example plan that connects official Fabric certification objectives with hands-on practice, review, and exam readiness.Voir la ressource
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.