Parcourir les aide-mémoire · Ingénierie des données

Technologie: Ingénierie des donnéesCatégorie: ArchitectureNiveau: IntermédiaireMis à jour

Traitement batch ou streaming

Choisissez entre traitement batch et streaming des données en comparant latence, exactitude, complexité opérationnelle, coût, rejeu, état et reprise après échec pour de vraies charges de production.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Modèle de traitement batch
  5. 2. Modèle de traitement en streaming
  6. 3. Le micro-batch reste du streaming
  7. 4. Le batch ne signifie pas forcément « une fois par jour »
  8. 5. Définir l’exigence de latence avant de choisir l’architecture
  9. 6. Fenêtre de lot bornée
  10. 7. Ajouter un critère de départage lorsque les horodatages ne sont pas uniques
  11. 8. Exemple de watermark batch
  12. 9. N’avancez jamais un watermark batch avant la réussite
  13. 10. Exemple de checkpoint de streaming
  14. 11. Conserver les événements source de manière durable si possible
  15. 12. Séparer l’ingestion de la transformation métier
  16. 13. Le streaming ne signifie pas « pas de stockage »
  17. 14. Traitement en temps d’événement
  18. 15. Données tardives
  19. 16. En streaming, les watermarks ne sont pas l’équivalent des checkpoints batch
  20. 17. Ne choisissez pas un seuil de retard arbitraire
  21. 18. Agrégation fenêtrée en streaming
  22. 19. Les jointures en streaming nécessitent un état
  23. 20. Les jointures entre table statique et flux sont plus simples
  24. 21. Dédupliquer les événements de streaming par un ID d’événement durable
  25. 22. Les cibles idempotentes réduisent le risque lié aux nouvelles tentatives
  26. 23. Les promesses « exactly once » doivent préciser leur périmètre
  27. 24. La livraison « at-least-once » est courante
  28. 25. Les réexécutions batch ont aussi besoin d’idempotence
  29. 26. Batch avec rechargement complet
  30. 27. Batch incrémental
  31. 28. La Change Data Capture peut alimenter les deux modèles
  32. 29. Une source d’événements n’impose pas un consommateur en streaming
  33. 30. Les fichiers n’imposent pas une architecture exclusivement batch
  34. 31. Utiliser un batch déclenché lorsque la latence le permet
  35. 32. Le streaming est utile pour les décisions opérationnelles
  36. 33. Le batch suffit souvent pour l’analytique
  37. 34. N’utilisez pas le streaming pour des tableaux de bord sans exigence de latence
  38. 35. Le batch est plus facile à rejouer
  39. 36. Le backfill doit coexister avec le streaming
  40. 37. Utiliser des contrôles de backfill distincts
  41. 38. Les échecs batch sont naturellement bornés
  42. 39. Les échecs en streaming peuvent accumuler du retard
  43. 40. Le retard est une métrique de santé centrale du streaming
  44. 41. Le débit doit dépasser le rythme d’arrivée soutenu
  45. 42. La gestion des pics compte
  46. 43. Le batch subit aussi la pression des fenêtres de pointe
  47. 44. Le streaming peut reporter la charge en aval en continu
  48. 45. Le micro-batch peut protéger les systèmes en aval
  49. 46. Évitez un appel d’API externe par événement à fort volume
  50. 47. L’état du streaming peut devenir volumineux
  51. 48. Le batch a aussi un état, mais il est souvent explicite
  52. 49. Suivre les métadonnées d’exécution des lots
  53. 50. Suivre les métadonnées d’exécution du streaming
  54. 51. Privilégier des transformations déterministes
  55. 52. Enregistrer le temps de traitement séparément du temps d’événement
  56. 53. Distinguer la fraîcheur métier de la latence du pipeline
  57. 54. L’ordre des événements n’est pas forcément garanti globalement
  58. 55. La clé de partition influe sur l’ordre et la montée en charge du streaming
  59. 56. Évitez une clé unique chaude
  60. 57. Le partitionnement batch influe aussi sur les performances
  61. 58. Les schémas de streaming évoluent aussi
  62. 59. La dérive de schéma en batch est plus facile à mettre en quarantaine
  63. 60. Utiliser avec prudence les modèles dead-letter/quarantaine
  64. 61. Ne laissez pas un seul enregistrement incorrect arrêter inutilement tout le flux
  65. 62. Les coûts du streaming ne se limitent pas au calcul
  66. 63. Les coûts du batch ne sont pas automatiquement plus faibles
  67. 64. Le coût suit le travail effectué
  68. 65. Batch et streaming peuvent partager les transformations
  69. 66. Construire un chemin de rejeu pour la logique de streaming
  70. 67. L’architecture Lambda duplique la logique
  71. 68. L’approche de type Kappa met l’accent sur des flux rejouables
  72. 69. Ne faites pas des noms d’architecture des objectifs de conception
  73. 70. Utiliser une architecture hybride lorsque les exigences diffèrent
  74. 71. Le streaming pour le signal précoce, le batch pour la réconciliation
  75. 72. La réconciliation doit être délibérée
  76. 73. Définir la sémantique de la source de vérité
  77. 74. Les contrats de données comptent davantage en streaming
  78. 75. Le streaming exige une supervision opérationnelle plus poussée
  79. 76. La supervision batch doit vérifier la complétude
  80. 77. Définir la reprise avant la production
  81. 78. Tester les scénarios d’échec
  82. 79. Le streaming n’est pas toujours du « temps réel »
  83. 80. Choisir l’architecture la plus simple qui satisfait l’exigence
  84. Interpréter le résultat
  85. Points à vérifier
  86. Le job de streaming tourne, mais les données sont périmées
  87. Le batch se termine, mais les données sont incomplètes
  88. L’état du streaming ne cesse de croître
  89. Le backfill crée des doublons
  90. Le pipeline prend régulièrement du retard pendant les pics
  91. Des batchs fréquents respectent largement le SLA
  92. Notes de production
  93. La latence est une exigence métier, pas une fonctionnalité technologique
  94. La capacité de rejeu est essentielle
  95. Le streaming accroît l’état opérationnel
  96. Les systèmes en aval peuvent contraindre le choix
  97. Mesurer ensemble le coût et la complexité
  98. L’hybride est normal
  99. Erreurs fréquentes
  100. 1. Choisir le streaming parce que la source est Kafka/Event Hub
  101. 2. Juger un batch horaire « pas assez temps réel » sans SLA
  102. 3. Supposer que le streaming élimine les doublons
  103. 4. Supposer que le streaming offre une cohérence d’instantané
  104. 5. Avancer les watermarks batch avant la réussite des écritures
  105. 6. Utiliser des horodatages sans critère de départage
  106. 7. Ignorer les événements tardifs/hors ordre
  107. 8. Laisser l’état du streaming croître sans limite
  108. 9. Traiter les checkpoints de streaming comme des fichiers temporaires jetables
  109. 10. Construire du streaming sans plan de rejeu/backfill
  110. Étape suivante
  111. Pour aller plus loin

Problème

Vous devez déplacer ou transformer des données, mais la décision d’architecture n’est pas claire :

Faut-il exécuter le traitement en batch toutes les quelques minutes ou heures ?
Ou faut-il traiter les événements en continu, à mesure qu’ils arrivent ?

Un mauvais choix peut créer inutilement :

  • de la latence
  • de la complexité opérationnelle
  • des coûts
  • des traitements en double
  • des problèmes de gestion de l’état
  • des difficultés de reprise
  • une pression sur les systèmes en aval

L’objectif est de choisir le modèle de traitement le plus simple qui satisfait les exigences métier réelles de latence et d’exactitude.

Réponse rapide

Utilisez ce modèle de décision :

Des minutes ou des heures de latence sont acceptables
→ le batch est généralement plus simple

Les données doivent être traitées en continu avec une faible latence
→ le streaming peut être approprié

Besoin d’un rejeu facile et d’un recalcul déterministe
→ le batch est généralement plus facile

Besoin d’alertes immédiates, de détection de fraude, de télémétrie ou d’un état opérationnel en direct
→ le streaming peut être justifié

Besoin à la fois d’exactitude historique et de faible latence
→ combiner une ingestion en streaming avec un stockage durable et des chemins batch/backfill rejouables

Une règle utile :

Ne choisissez pas le streaming parce que la source émet des événements.

Choisissez le streaming parce que le métier a besoin d’un traitement continu.

Code / commandes

1. Modèle de traitement batch

Flux type :

source
→ déposer les données brutes
→ traiter un jeu de données borné
→ écrire la sortie organisée
→ enregistrer un checkpoint de fin

Exemple de pseudo-workflow :

start = get_last_successful_watermark()
end = get_current_cutoff()

df = read_source(
    start_time=start,
    end_time=end,
)

clean = transform(df)

validate(clean)

write_output(clean)

save_watermark(end)

La propriété importante est que la plage d’entrée est bornée.


2. Modèle de traitement en streaming

Flux type :

source d’événements
→ ingérer en continu
→ traiter les enregistrements/micro-batchs
→ maintenir l’état/les checkpoints
→ écrire la sortie en continu

Exemple conceptuel avec Spark Structured Streaming :

events = (
    spark.readStream
    .format("delta")
    .table("bronze_events")
)

clean = (
    events
    .filter("event_type IS NOT NULL")
    .select(
        "event_id",
        "event_time",
        "event_type",
        "customer_id",
    )
)

query = (
    clean.writeStream
    .format("delta")
    .option("checkpointLocation", "/checkpoints/silver_events")
    .outputMode("append")
    .toTable("silver_events")
)

Le streaming exige une conception durable des checkpoints et de l’état, et pas seulement une boucle qui tourne en continu.


3. Le micro-batch reste du streaming

De nombreux moteurs de streaming en production traitent les événements sous forme de petits lots répétés.

Conceptuellement :

les événements arrivent en continu
→ à intervalle court, le moteur traite les nouvelles données
→ le checkpoint avance

Il s’agit toujours d’une architecture de streaming, car le pipeline est incrémental en continu.


4. Le batch ne signifie pas forcément « une fois par jour »

Un batch peut s’exécuter :

toutes les 5 minutes
toutes les 15 minutes
toutes les heures
chaque nuit
à l’arrivée d’un fichier
à la demande

Si une latence de cinq minutes satisfait l’exigence, un petit batch fréquent peut être plus simple qu’une plateforme de streaming complète.


5. Définir l’exigence de latence avant de choisir l’architecture

Écrivez l’exigence explicitement :

Nouvelle transaction visible dans l’analytique sous :
15 minutes

ou :

Alerte de fraude générée sous :
5 secondes

Ne partez pas de :

Nous devrions utiliser Kafka/Spark Streaming parce que c’est moderne.

L’architecture doit découler du SLA métier.


6. Fenêtre de lot bornée

Un batch robuste définit généralement :

[start, end)

Exemple :

WHERE event_time >= @start_time
  AND event_time <  @end_time

Les fenêtres semi-ouvertes évitent le chevauchement entre lots adjacents lorsque les horodatages servent de limite incrémentale.


7. Ajouter un critère de départage lorsque les horodatages ne sont pas uniques

Mauvais état incrémental :

last_processed_timestamp

si des milliers de lignes peuvent partager le même horodatage.

Meilleur état :

last_processed_timestamp
+
last_processed_id

ou utilisez une séquence/version fournie par la source.


8. Exemple de watermark batch

Checkpoint :

{
  "lastSuccessfulEnd": "2026-10-04T14:00:00Z"
}

Lot suivant :

start = 2026-10-04T14:00:00Z
end   = 2026-10-04T15:00:00Z

N’avancez le watermark qu’après la réussite d’un traitement durable.


9. N’avancez jamais un watermark batch avant la réussite

Mauvais :

enregistrer le watermark
→ traiter les données
→ le pipeline échoue

L’intervalle en échec peut être sauté lors de la nouvelle tentative.

Plus sûr :

lire une entrée bornée
→ transformer
→ valider
→ écrire de façon durable
→ persister le watermark

10. Exemple de checkpoint de streaming

Le checkpoint d’un moteur de streaming suit généralement :

les offsets de la source
la progression
les métadonnées du magasin d’état
les informations de commit de la cible

Le stockage des checkpoints doit être durable et isolé pour chaque flux logique.

Ne faites pas pointer des jobs de streaming sans rapport vers le même emplacement de checkpoint.


11. Conserver les événements source de manière durable si possible

Modèle utile :

bus d’événements / source
→ couche Bronze/brute durable
→ transformation en streaming

Des données brutes durables permettent de :

  • rejouer
  • effectuer un backfill
  • déboguer
  • reconstruire l’état en aval

Un streaming sans possibilité de rejeu rend la reprise en production beaucoup plus difficile.


12. Séparer l’ingestion de la transformation métier

Une architecture solide utilise souvent :

Événements source
→ ingestion durable
→ transformation
→ mise à disposition

Ne placez pas toutes les règles métier dans la couche d’ingestion si cela empêche de rejouer plus tard les données brutes de la source.


13. Le streaming ne signifie pas « pas de stockage »

Les systèmes de streaming ont toujours besoin d’un état durable pour :

  • les offsets
  • les checkpoints
  • la déduplication
  • les fenêtres
  • les jointures
  • l’état d’agrégation
  • le rejeu/backfill

Le calcul continu accroît l’importance de la gestion de l’état.


14. Traitement en temps d’événement

La logique de streaming devrait souvent utiliser :

event_time

plutôt que seulement :

processing_time

Exemple :

event_time
→ moment où l’événement métier s’est réellement produit

processing_time
→ moment où le moteur l’a reçu/traité

Ils peuvent différer de façon importante.


15. Données tardives

Exemple :

l’événement s’est produit à 10:00
l’événement est arrivé à 10:12

Un système de streaming doit décider :

accepter l’événement tardif ?
mettre à jour le résultat précédent ?
l’abandonner ?
l’envoyer en quarantaine ?

Il s’agit d’une décision d’exactitude métier.


16. En streaming, les watermarks ne sont pas l’équivalent des checkpoints batch

En streaming sur le temps d’événement, un watermark exprime souvent jusqu’à quel point, en temps d’événement, le moteur s’attend à recevoir des données tardives.

Conceptuellement :

temps d’événement maximal observé
-
retard autorisé

Le moteur peut utiliser cette limite pour purger l’ancien état.

La sémantique exacte dépend du moteur de streaming.


17. Ne choisissez pas un seuil de retard arbitraire

Appuyez-vous sur des éléments concrets issus de la source et du métier.

Exemples de questions :

Avec quel retard les événements peuvent-ils arriver ?
Quel est leur retard réel en production ?
Les anciennes fenêtres peuvent-elles être mises à jour ?
Quels consommateurs en aval attendent des corrections ?

N’inventez pas un watermark universel de cinq minutes ou d’une heure.


18. Agrégation fenêtrée en streaming

Exemple conceptuel en PySpark :

from pyspark.sql import functions as F

agg = (
    events
    .withWatermark("event_time", "30 minutes")
    .groupBy(
        F.window("event_time", "5 minutes"),
        "merchant_id",
    )
    .agg(
        F.count("*").alias("event_count")
    )
)

À n’utiliser que si une politique de retard de 30 minutes est réellement adaptée à la source et au métier.

La valeur ci-dessus est illustrative, et non une recommandation universelle.


19. Les jointures en streaming nécessitent un état

Joindre deux flux non bornés peut exiger de conserver un état historique.

Exemple :

flux des commandes
JOIN
flux des paiements

Sans règles bornant le temps/l’état, l’état peut croître indéfiniment.

Utilisez :

  • des contraintes de temps d’événement
  • des watermarks
  • des fenêtres de correspondance bornées

lorsque le moteur les exige ou les prend en charge.


20. Les jointures entre table statique et flux sont plus simples

Modèle courant :

flux d’événements
JOIN
petite table de référence/de dimension

C’est souvent plus simple que les jointures entre flux.

Mais décidez comment les modifications des données de référence deviennent visibles :

  • rechargement
  • actualisation
  • mise à jour par broadcast
  • table versionnée

21. Dédupliquer les événements de streaming par un ID d’événement durable

Conceptuellement :

event_id = identifiant d’événement source stable au niveau global

La déduplication peut alors raisonner sur le rejeu et les nouvelles tentatives.

Évitez de générer un nouvel ID d’événement aléatoire chaque fois qu’un événement est retraité.


22. Les cibles idempotentes réduisent le risque lié aux nouvelles tentatives

Un pipeline est plus facile à reprendre lorsque l’écriture double d’un même enregistrement logique ne corrompt pas l’état.

Exemples :

MERGE par clé métier/d’événement
upsert par ID stable
ajout transactionnel avec déduplication en aval

Ne comptez pas sur le fait que « l’événement n’arrivera qu’une seule fois ».


23. Les promesses « exactly once » doivent préciser leur périmètre

« Exactly once » (exactement une fois) peut désigner :

le traitement des offsets de la source
la mise à jour de l’état
le commit dans la cible
l’effet de bord métier

Ces garanties ne sont pas automatiquement identiques.

Par exemple :

le flux écrit la ligne exactement une fois

ne signifie pas :

l’e-mail est envoyé exactement une fois

Concevez séparément les effets de bord externes.


24. La livraison « at-least-once » est courante

Une nouvelle tentative peut livrer/traiter à nouveau le même événement.

La logique en aval doit le tolérer autant que possible.

Utilisez des identifiants stables et l’idempotence.


25. Les réexécutions batch ont aussi besoin d’idempotence

Le batch n’est pas automatiquement sûr.

Mauvaise réexécution :

INSERT de tout l’intervalle une nouvelle fois

peut dupliquer la sortie.

Options plus sûres :

écraser une partition bornée
MERGE par clé
supprimer/reconstruire un intervalle contrôlé
ajout avec des ID de lot/d’événement déterministes

Choisissez selon la sémantique de la table.


26. Batch avec rechargement complet

Modèle :

lire toute la source
→ reconstruire toute la cible

Utile lorsque :

  • le jeu de données est suffisamment petit
  • la logique change souvent
  • une exactitude simple compte davantage que l’optimisation incrémentale

N’implémentez pas une CDC complexe si une reconstruction complète sûre coûte peu.


27. Batch incrémental

Modèle :

watermark
→ lire uniquement les données modifiées/nouvelles
→ fusionner dans la cible

Utile lorsque le rechargement complet devient trop coûteux.

La conception incrémentale ajoute de la complexité en matière d’état et de reprise.


28. La Change Data Capture peut alimenter les deux modèles

La CDC ne signifie pas automatiquement streaming.

Les enregistrements CDC peuvent être traités :

en continu

ou :

par lots périodiques

Choisissez le mode de consommation en fonction de l’exigence de latence.


29. Une source d’événements n’impose pas un consommateur en streaming

Exemple :

source Kafka / Event Hub / Kinesis

peut tout de même être consommée vers un stockage durable et traitée périodiquement.

Ne laissez pas la technologie de la source dicter automatiquement l’architecture en aval.


30. Les fichiers n’imposent pas une architecture exclusivement batch

Des événements d’arrivée de fichiers peuvent déclencher un traitement en quasi temps réel.

L’architecture peut être :

un fichier arrive
→ déclencheur d’événement
→ traitement borné

Il s’agit d’un batch piloté par les événements, pas forcément d’un streaming continu.


31. Utiliser un batch déclenché lorsque la latence le permet

Exemple :

un nouveau fichier est déposé
→ l’orchestrateur déclenche le pipeline
→ traiter uniquement ce fichier/lot

Cela peut offrir une faible latence sans faire tourner en permanence un moteur de streaming.


32. Le streaming est utile pour les décisions opérationnelles

Bons candidats :

détection de fraude
alertes de télémétrie des appareils
événements de sécurité
personnalisation en direct
tableaux de bord opérationnels en temps réel
signaux de stock

Ces cas d’usage perdent de leur valeur lorsqu’ils sont traités trop tard.


33. Le batch suffit souvent pour l’analytique

Bons candidats :

rapports financiers quotidiens
agrégats métier horaires
transformations d’entrepôt de données
extractions réglementaires
caractéristiques historiques pour les modèles
backfills

Si le consommateur n’a pas besoin de données immédiates, le batch réduit généralement la charge opérationnelle.


34. N’utilisez pas le streaming pour des tableaux de bord sans exigence de latence

Demandez-vous :

Ce tableau de bord a-t-il vraiment besoin d’une fraîcheur de 2 secondes ?

Si une fraîcheur de 5 à 15 minutes est acceptable, un batch incrémental fréquent peut être plus simple et moins coûteux.


35. Le batch est plus facile à rejouer

Modèle de rejeu :

choisir un intervalle historique
→ réexécuter la transformation
→ comparer la sortie

C’est précieux pour :

  • corriger des défauts
  • modifier la logique métier
  • reconstruire l’historique

Les systèmes de streaming doivent préserver une capacité de rejeu équivalente si la correction de l’historique compte.


36. Le backfill doit coexister avec le streaming

Exigence de production courante :

le flux en direct traite aujourd’hui
pendant que
le backfill répare le mois dernier

Prévoyez :

  • les conflits d’écriture
  • les clés en double
  • le chevauchement de partitions
  • les mises à jour en aval
  • la contention des ressources

Ne supposez pas que les backfills n’arriveront jamais.


37. Utiliser des contrôles de backfill distincts

Exemple :

checkpoint en direct
!=
checkpoint de backfill

Un backfill historique ne doit pas faire reculer le checkpoint du flux en direct ni écraser accidentellement son état.


38. Les échecs batch sont naturellement bornés

Si le lot horaire 14:00–15:00 échoue :

réexécuter 14:00–15:00

Le périmètre de l’échec est facile à cerner.

La reprise en streaming peut impliquer :

  • les offsets
  • l’état
  • la compatibilité des checkpoints
  • le rejeu des événements
  • les données tardives

39. Les échecs en streaming peuvent accumuler du retard

Si le traitement s’arrête :

les événements continuent d’arriver
→ l’arriéré (backlog) grossit

La reprise exige une capacité suffisante pour :

traiter les nouvelles arrivées
+
rattraper l’arriéré

Supervisez explicitement le retard (lag) et l’arriéré du consommateur.


40. Le retard est une métrique de santé centrale du streaming

Notion utile :

dernière position de la source
-
position traitée par le consommateur

ou son équivalent en temps.

Un job de streaming en cours d’exécution peut tout de même être en mauvaise santé si le retard ne cesse d’augmenter.


41. Le débit doit dépasser le rythme d’arrivée soutenu

Si la source produit :

10 000 événements/s

et que le pipeline traite de façon soutenue :

8 000 événements/s

le retard grossit indéfiniment.

Ne dimensionnez pas le streaming uniquement sur le trafic moyen si les charges réelles connaissent des pics soutenus.


42. La gestion des pics compte

Un flux peut recevoir habituellement peu de trafic, mais connaître des pics occasionnels.

Les options comprennent :

  • la mise en tampon dans un broker/stockage durable
  • la mise à l’échelle automatique
  • la mise à l’échelle des partitions
  • une contre-pression (backpressure) bornée
  • une capacité de rattrapage

43. Le batch subit aussi la pression des fenêtres de pointe

Un batch nocturne peut entrer en concurrence avec :

  • les utilisateurs de l’entrepôt de données
  • les sauvegardes
  • la maintenance
  • les rapports en aval

Le batch simplifie l’état du traitement, mais la planification et la contention des ressources restent importantes.


44. Le streaming peut reporter la charge en aval en continu

Une base de données en aval qui gérait :

un MERGE massif par heure

peut se comporter différemment avec :

de petites mises à jour continues

Évaluez les modèles d’écriture en aval.

Un streaming en amont ne garantit pas que les systèmes en aval soient adaptés à des écritures constantes.


45. Le micro-batch peut protéger les systèmes en aval

Au lieu d’écrire chaque événement individuellement :

mettre en tampon sur un court intervalle
→ écrire le lot

Cela peut réduire le surcoût par requête/transaction.

Choisissez l’intervalle en fonction de la latence et de la capacité de la cible.


46. Évitez un appel d’API externe par événement à fort volume

Modèle :

événement
→ requête HTTP
→ événement
→ requête HTTP

peut surcharger les services en aval.

Envisagez :

  • le traitement par lots
  • la mise en file d’attente
  • la limitation de débit
  • des workers asynchrones
  • un traitement dédupliqué des effets de bord

47. L’état du streaming peut devenir volumineux

Les opérations avec état comprennent :

  • les fenêtres
  • la déduplication
  • les jointures entre flux
  • la sessionisation

Si l’état n’est pas borné, la pression sur la mémoire/le stockage peut croître en continu.

Utilisez une sémantique de rétention/de watermark appropriée.


48. Le batch a aussi un état, mais il est souvent explicite

Exemples :

table de watermarks
manifeste des fichiers traités
ID de lot
high-water mark

Persistez l’état de manière transactionnelle lorsque c’est possible.


49. Suivre les métadonnées d’exécution des lots

Champs utiles :

batch_id
start_watermark
end_watermark
start_time
end_time
row_count
status
source_version
code_version

Cela facilite le rejeu et l’analyse des incidents.


50. Suivre les métadonnées d’exécution du streaming

Signaux utiles :

checkpoint
offset de la source
lignes traitées/s
lignes en entrée/s
retard (lag)
taille de l’état
durée du lot
lot en échec
commit dans la cible

Les métriques exactes dépendent de la plateforme.


51. Privilégier des transformations déterministes

Avec la même entrée :

même code
+
mêmes données/version de référence
→ même sortie

Cela rend le rejeu plus sûr.

Évitez les dépendances cachées à l’heure courante ou à un état de recherche modifiable, sauf si elles sont voulues.


52. Enregistrer le temps de traitement séparément du temps d’événement

Colonnes utiles :

event_time
ingestion_time
processed_time

Elles permettent de répondre à :

Quand l’événement s’est-il produit ?
Quand la plateforme l’a-t-elle reçu ?
Quand la transformation s’est-elle terminée ?

53. Distinguer la fraîcheur métier de la latence du pipeline

Exemple :

le pipeline a traité l’événement en 5 secondes

mais la source elle-même l’a livré avec 20 minutes de retard.

La latence de votre pipeline est faible, mais la fraîcheur des données métier ne l’est pas.

Supervisez les deux.


54. L’ordre des événements n’est pas forcément garanti globalement

Les sources distribuées peuvent ne préserver l’ordre que :

  • au sein d’une partition
  • au sein d’une clé
  • au sein d’une session de producteur

Ne supposez pas un ordre global, sauf si la source le garantit.


55. La clé de partition influe sur l’ordre et la montée en charge du streaming

Une clé de partition contrôle :

la distribution
le parallélisme
l’ordre par clé
les partitions chaudes

Une mauvaise clé peut créer du skew.


56. Évitez une clé unique chaude

Exemple :

partition_key = "all_events"

force tous les événements à passer par une seule partition/clé.

Choisissez une clé alignée sur :

  • l’ordre requis
  • la répartition de la charge
  • la sémantique des consommateurs

57. Le partitionnement batch influe aussi sur les performances

Un batch peut être inefficace si tout le travail se concentre dans :

  • un seul fichier
  • une seule partition
  • un seul compartiment de date
  • un seul locataire

Partitionnez selon les modèles réels d’accès et de traitement.


58. Les schémas de streaming évoluent aussi

Les événements peuvent ajouter/modifier des champs au fil du temps.

Prévoyez :

  • la compatibilité des schémas
  • des valeurs par défaut
  • des ajouts nullables
  • le versionnage
  • une quarantaine pour les événements invalides

Ne supposez pas que les contrats d’événements restent figés parce qu’ils sont en temps réel.


59. La dérive de schéma en batch est plus facile à mettre en quarantaine

Un fichier ou un lot en échec peut être isolé sans arrêter tous les traitements futurs si l’orchestration est correctement conçue.

En streaming, les erreurs de schéma peuvent arrêter ou empoisonner le traitement continu si elles ne sont pas gérées.


60. Utiliser avec prudence les modèles dead-letter/quarantaine

Pour les enregistrements invalides :

valide
→ chemin normal

invalide
→ quarantaine avec motif/contexte

N’abandonnez pas silencieusement les enregistrements incorrects s’ils comptent pour l’exactitude métier.


61. Ne laissez pas un seul enregistrement incorrect arrêter inutilement tout le flux

Lorsque la sémantique de la plateforme le permet, isolez les événements mal formés.

Mais ne transformez pas de graves défaillances de schéma/de contrat en pertes de données silencieuses.


62. Les coûts du streaming ne se limitent pas au calcul

Tenez compte :

du broker d’événements
du stockage de l’état/des checkpoints
du calcul continu
du réseau
de la supervision
du support opérationnel
du stockage pour le rejeu

63. Les coûts du batch ne sont pas automatiquement plus faibles

Une analyse complète quotidienne mal conçue de données massives peut coûter plus cher qu’un streaming incrémental.

Mesurez la charge de travail réelle.


64. Le coût suit le travail effectué

Question utile :

Quel volume de données lisons-nous, redistribuons-nous (shuffle), stockons-nous et écrivons-nous ?

et pas simplement :

Est-ce du batch ou du streaming ?

65. Batch et streaming peuvent partager les transformations

Une conception solide sépare :

la logique de transformation métier
du
mode d’exécution

Lorsque c’est réaliste, la même logique peut être réutilisée pour :

  • le traitement incrémental en direct
  • le rejeu historique
  • les tests

66. Construire un chemin de rejeu pour la logique de streaming

Exemple :

table Delta Bronze
→ lecture batch d’une plage historique
→ même transformation Silver

Cela aide à :

  • se remettre de défauts
  • reconstruire l’état
  • valider les changements de logique

67. L’architecture Lambda duplique la logique

L’architecture Lambda classique utilise :

un chemin batch
+
un chemin rapide/de streaming

Cela peut entraîner une duplication opérationnelle et une logique incohérente.

À n’utiliser que lorsque c’est justifié.

Les conceptions modernes privilégient souvent une couche durable unique d’événements/de données brutes, associée à un traitement incrémental/batch réutilisable.


68. L’approche de type Kappa met l’accent sur des flux rejouables

Conceptuellement :

journal d’événements durable
→ traitement en streaming
→ rejeu si nécessaire

L’exigence pratique n’est pas le nom de l’architecture.

La capacité importante est un historique de la source rejouable et un traitement déterministe.


69. Ne faites pas des noms d’architecture des objectifs de conception

Ne choisissez pas :

Lambda
Kappa
temps réel
piloté par les événements

parce que le terme sonne moderne.

Définissez :

la latence
l’exactitude
le rejeu
le coût
le comportement en cas d’échec
la responsabilité opérationnelle

d’abord.


70. Utiliser une architecture hybride lorsque les exigences diffèrent

Exemple :

streaming
→ alertes opérationnelles

batch
→ totaux financiers quotidiens de référence

Une même source peut alimenter plusieurs chemins de traitement lorsque les besoins métier diffèrent.


71. Le streaming pour le signal précoce, le batch pour la réconciliation

Exemple :

flux
→ tableau de bord en quasi temps réel

batch nocturne
→ recalcul/réconciliation de référence

Cela peut être utile lorsque la fraîcheur du streaming compte, mais que l’exactitude finale exige des données tardives ou une réconciliation avec une source de référence.


72. La réconciliation doit être délibérée

Comparez :

l’agrégat de streaming
vs
l’agrégat batch de référence

Analysez les écarts.

Ne considérez pas la correction par batch comme une autorisation d’ignorer la qualité du streaming.


73. Définir la sémantique de la source de vérité

Demandez-vous :

Le journal d’événements brut fait-il foi ?
La base de données source fait-elle foi ?
L’extraction quotidienne fait-elle foi ?

La reprise et la réconciliation dépendent de cette réponse.


74. Les contrats de données comptent davantage en streaming

Comme les consommateurs de streaming réagissent vite, les mauvaises modifications côté producteur se propagent vite.

Utilisez :

  • des contrats de schéma
  • le versionnage
  • des tests de compatibilité
  • un déploiement progressif

75. Le streaming exige une supervision opérationnelle plus poussée

Surveillez au minimum :

le job est-il actif ?
le débit d’entrée
le débit de traitement
le retard (lag)
la progression des checkpoints
la croissance de l’état
le taux d’erreur
les échecs de la cible

Un statut de processus au vert ne suffit pas.


76. La supervision batch doit vérifier la complétude

Surveillez :

le lot attendu est-il arrivé ?
le lot a-t-il réussi ?
le nombre de lignes est-il plausible ?
le watermark a-t-il avancé ?
lot en double ?
fichier en retard ?

Une exécution terminée dans le planificateur ne garantit pas des données complètes.


77. Définir la reprise avant la production

Pour le batch :

Comment réexécuter un seul intervalle ?

Pour le streaming :

Comment rejouer depuis un point antérieur ?
Que devient l’état ?
Comment éviter les effets de bord en double ?

Si la reprise n’est pas définie, l’architecture est incomplète.


78. Tester les scénarios d’échec

Tests utiles :

un worker plante en cours de traitement
cible indisponible
événement en double
événement tardif
événement hors ordre
changement de schéma
checkpoint indisponible
un backfill chevauche les données en direct

La résilience en production doit être démontrée, pas supposée.


79. Le streaming n’est pas toujours du « temps réel »

La latence réelle de bout en bout comprend :

le délai de la source
le délai du broker
le délai de traitement
le délai de la cible
le délai d’actualisation du consommateur/du cache

Un moteur de streaming seul ne garantit pas une expérience utilisateur en temps réel.


80. Choisir l’architecture la plus simple qui satisfait l’exigence

Ordre de décision :

1. Définir la fraîcheur requise
2. Définir les besoins d’exactitude/de rejeu
3. Définir le volume attendu et le comportement en cas de pics
4. Définir les capacités en aval
5. Définir le modèle d’échec/de reprise
6. Estimer la complexité/le coût opérationnels
7. Choisir le batch, le streaming ou l’hybride

Interpréter le résultat

Dimension Batch Streaming
Entrée Bornée Non bornée/continue
Latence typique De quelques minutes à quelques heures, mais peut être fréquent De quelques secondes à quelques minutes selon la plateforme/la conception
État Watermarks/manifestes/métadonnées des lots Offsets/checkpoints/magasins d’état/watermarks
Rejeu Généralement simple Exige une source durable + une stratégie de checkpoint/d’état
Périmètre des échecs Généralement un intervalle borné Peut créer de l’arriéré/du retard et des problèmes d’état
Données tardives Lot suivant/de réconciliation Une politique explicite de temps d’événement/de retard est souvent nécessaire
Complexité opérationnelle Généralement plus faible Généralement plus élevée
Backfill ponctuel Adéquation naturelle Souvent géré par un chemin de rejeu/backfill distinct
Alertes en direct Peu adapté si la latence est élevée Très adapté
Recalcul historique à grande échelle Très adapté Généralement réalisé par batch/rejeu

Le compromis central est le suivant :

une latence plus faible
exige souvent
plus d’état + plus de complexité opérationnelle

Points à vérifier

Le job de streaming tourne, mais les données sont périmées

Vérifiez :

  • le retard de la source
  • le débit d’entrée par rapport au débit de traitement
  • la progression des checkpoints
  • la latence de la cible
  • l’actualisation du cache/de la couche de mise à disposition en aval

Le batch se termine, mais les données sont incomplètes

Vérifiez :

  • la complétude des arrivées de la source
  • le watermark
  • les fichiers sautés
  • le filtrage des doublons
  • les enregistrements tardifs

L’état du streaming ne cesse de croître

Examinez :

  • les jointures non bornées
  • la rétention de la déduplication
  • les définitions des fenêtres
  • la politique de watermark/de retard
  • les clés à forte cardinalité

Le backfill crée des doublons

Vérifiez :

  • la logique d’écriture idempotente
  • les plages de dates qui se chevauchent
  • la coordination entre flux en direct et backfill
  • les clés de MERGE

Le pipeline prend régulièrement du retard pendant les pics

Vérifiez le débit soutenu, le skew des partitions, la capacité de la cible en aval et la marge de rattrapage.

Des batchs fréquents respectent largement le SLA

Le streaming risque d’ajouter de la complexité sans valeur métier suffisante.

Notes de production

La latence est une exigence métier, pas une fonctionnalité technologique

N’optimisez pas pour une latence plus faible que celle dont les consommateurs ont besoin.

La capacité de rejeu est essentielle

En batch comme en streaming, conservez suffisamment de données source/d’historique durables pour vous remettre de défauts et reconstruire les sorties.

Le streaming accroît l’état opérationnel

Les checkpoints, offsets, watermarks et magasins d’état font partie de l’exactitude.

Traitez-les comme des données de production.

Les systèmes en aval peuvent contraindre le choix

Une source d’événements continue ne signifie pas que la base de données/l’API cible peut absorber sans risque une écriture par événement.

Mesurer ensemble le coût et la complexité

Le streaming peut réduire la latence de fraîcheur tout en augmentant :

  • les services de plateforme
  • la supervision
  • la complexité des incidents
  • la gestion de l’état

L’hybride est normal

De nombreuses plateformes matures utilisent les deux :

le streaming pour la fraîcheur
le batch pour le recalcul/la réconciliation

lorsque les exigences le justifient.

Erreurs fréquentes

1. Choisir le streaming parce que la source est Kafka/Event Hub

Le transport de la source ne définit pas les exigences de traitement.

2. Juger un batch horaire « pas assez temps réel » sans SLA

Définissez d’abord l’exigence réelle de fraîcheur.

3. Supposer que le streaming élimine les doublons

Les nouvelles tentatives et la livraison « at-least-once » exigent toujours un traitement idempotent.

4. Supposer que le streaming offre une cohérence d’instantané

Les données en direct peuvent changer pendant leur traitement.

5. Avancer les watermarks batch avant la réussite des écritures

Cela peut faire sauter des intervalles en échec.

6. Utiliser des horodatages sans critère de départage

Des lignes partageant le même horodatage peuvent être sautées lors du traitement incrémental.

7. Ignorer les événements tardifs/hors ordre

Le temps d’événement et le temps de traitement sont différents.

8. Laisser l’état du streaming croître sans limite

Les fenêtres, les jointures et la déduplication ont besoin d’une sémantique de rétention.

9. Traiter les checkpoints de streaming comme des fichiers temporaires jetables

Ils font partie de la reprise et de l’exactitude.

10. Construire du streaming sans plan de rejeu/backfill

Vous finirez par devoir réparer l’historique.

Étape suivante

Laissez l’exigence guider le choix de la mise en œuvre.

  • Des minutes/heures de latence sont acceptables → commencez par le batch.
  • Des décisions en moins d’une minute/en continu sont nécessaires → évaluez le streaming.
  • Le batch n’est trop lent que pendant les fenêtres de pointe de données → optimisez le périmètre incrémental avant de changer d’architecture.
  • Le streaming prend du retard → examinez le retard, le débit, le partitionnement, le skew et la capacité de la cible.
  • Les données tardives comptent → définissez une politique de temps d’événement et de retard.
  • Des doublons apparaissent → ajoutez des clés d’événement/métier stables et des écritures idempotentes.
  • Besoin de réparer l’historique → construisez un chemin de rejeu/backfill à partir de données brutes durables.
  • Besoin de résultats à la fois frais et de référence → envisagez le streaming pour la fraîcheur et une réconciliation par batch.
  • Vous ne savez pas quel modèle choisir → quantifiez d’abord la latence, l’exactitude, le rejeu, le volume, la responsabilité opérationnelle et les contraintes en aval.

← Tous les aide-mémoire