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