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.

Par JaviPublié 17 min de lectureIntermédiaire

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.

  1. Source
  2. Brut
  3. Validé
  4. Préparé
  5. Serving
De la source au 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 :

  1. ingestion ;
  2. transformation ;
  3. orchestration ;
  4. stockage et modélisation ;
  5. fiabilité ;
  6. 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 :

  1. Tout supprimer
  2. Tout recharger
Rechargement complet

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 :

  1. 1Lire le dernier watermark réussi
  2. 2Lire les lignes source après ce watermark
  3. 3Transformer
  4. 4Écrire la destination
  5. 5Valider le nouveau watermark
Chargement incrémental par 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 :

    1. Brut
    2. Nettoyé
    3. Préparé
    1. Bronze
    2. Silver
    3. Gold
    1. Atterrissage
    2. Standardisé
    3. Serving
Noms courants des trois couches

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. 1 ligne invalide
  2. Tout le lot échoue
Fragile : une ligne invalide fait échouer le lot

Un pattern plus résilient isole les enregistrements invalides.

  1. Enregistrements entrants
  2. Valider
    • valides
      Cible
    • invalides
      Quarantaine
Pattern de quarantaine

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 :

  1. Échec
  2. attendre 1 s
    Réessayer
  3. attendre 2 s
    Réessayer
  4. attendre 4 s
    Réessayer
Retry avec backoff exponentiel

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 :

  1. Extraire
  2. Analyser
  3. Valider
  4. Normaliser
  5. Enrichir
  6. Publier
Traitement par étapes

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 :

  1. API externe
  2. Adapter
  3. Contrat client canonique
Adapter pour un système externe

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.

  1. Entrée
  2. Analyse
    • Métriques de qualité
    • Transformation principale
    • Audit
    • Notifications
Fan-out

C’est le fan-out.

Plus tard, les résultats peuvent être rassemblés :

    • Tâche A
    • Tâche B
    • Tâche C
  1. Publication finale
Fan-in

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.

  1. Requête de l’interface
  2. Calcul à la requête
    • 12 jointures
    • 3 grosses agrégations
    • fonctions de fenêtrage
  3. Réponse
Anti-pattern : calculer au moment de la requête

Le pattern de serving matérialisé déplace en amont le travail coûteux et réutilisable.

  1. Données brutes
  2. Transformation
  3. Résultat préparé / matérialisé
  4. API / tableau de bord / rapport
Serving matérialisé

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

  1. Watermark
  2. Lire les changements
  3. Merge idempotent
  4. Valider le watermark
Chargement incrémental avec watermark et idempotence

CDC + dédoublonnage + ordre

  1. Flux CDC
  2. Ordre / checkpoint
  3. Dédupliquer
  4. Appliquer le changement
CDC avec ordonnancement et déduplication

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.

Étiquettes

  • Architecture de données
  • Pipelines de données
  • Design patterns