Un crash à 3 heures du matin ne devrait jamais coûter un re-run complet
À 3 h 04 du matin, le pager s'allume : le job des trajets, six heures dans un run de sept heures, vient de mourir sur une erreur de mémoire saturée. La correction prend onze minutes. La récupération en prend sept, parce que le seul plan que quelqu'un ait écrit dit « supprimez la sortie et recommencez », et le rapport de 9 h arrive vide pendant que la réexécution traverse encore la troisième ville.
Notre position est facile à contester : un pipeline qui exige sept heures de réexécution après une seule mauvaise heure n'est pas malchanceux, il est inachevé. La capacité de reprendre est une propriété de la forme du pipeline, décidée au moment où s'écrit la première écriture, et presque impossible à greffer au moment où on en a réellement besoin. Ce billet suit un exemple unique mené de bout en bout, le job de nuit qui transforme une journée de positions GPS brutes en table de trajets, et il se termine là où vit la décision intéressante : dans l'écriture, pas dans le retry.
La réexécution complète mérite un procès loyal
Commencez par la défense de la réponse évidente, parce qu'elle gagne assez souvent pour que la refuser soit aussi un signe. Une transformation qui tourne vingt minutes, lit une entrée fixe, écrit une sortie fixe et ne touche la boîte de personne peut échouer puis simplement être relancée. Supprimer, relancer, terminé. Les checkpoints ne sont pas gratuits non plus : une conception idempotente doit être entretenue et parfois expliquée, et l'équipe qui a construit du checkpointing dans un job de vingt minutes a acheté de la complexité pour un problème qu'elle n'avait pas.
Le job des trajets échoue à ce test sur un chiffre unique : sept heures par réexécution. Ce coût se compose en silence pendant le développement, bien avant le vrai réveil de 3 h. Chaque correction de bogue exige une réexécution, donc l'équipe apprend à entasser les correctifs dans de « gros runs », et un changement d'une ligne part en production en paquet non testé, parce que le tester seul coûte une journée de travail. L'impôt de la réexécution ne ralentit pas que la récupération après un crash. Il ralentit chaque correction qui la précède, et voilà l'argument pour changer la conception, il arrive des semaines avant le pager.
Reprendre aux frontières de fichiers ne fait que déplacer le mensonge
Le premier correctif auquel tout le monde tend la main consiste à sauter les fichiers déjà traités. Un répertoire de transit garde un fichier par heure d'ingestion, et le job note chaque fichier terminé dans un manifeste, si bien qu'un redémarrage lit le manifeste et repart après la dernière entrée. Cela ressemble à une capacité de reprise, et cela se dissout au contact des détails.
Un fichier « terminé » est une affirmation, portée par un marqueur écrit quelque part. Le crash peut tomber entre l'écriture du fichier et celle du marqueur, et le redémarrage saute alors une heure seulement moitié écrite en aval. Le marqueur peut aussi mentir dans l'autre sens : un fichier déclaré terminé sur le disque a été tronqué en cours d'écriture, et le manifeste ne dit rien de sa queue. Et si deux personnes relancent le job dans la même heure, toutes deux lisent le même manifeste, toutes deux repartent au même décalage, et l'aval contient désormais deux copies entrelacées de la même soirée.
Un meilleur marqueur resserre la même affirmation, rien de plus. Ce dont la conception a besoin, c'est de moins d'affirmations : si chaque écriture supporte d'être appliquée deux fois, le manifeste devient une optimisation, un moyen de sauter du travail, au lieu d'être la chose dont la vérité du run dépend. Cette inversion est le pivot, et tout ce que nous avons gardé est en aval d'elle.
Ce qui a gagné : le sink garde le journal d'avancement
Deux décisions portent toute la conception, et toutes deux vivent dans l'écriture.
Décidez l'identité à l'ingestion, depuis l'entrée seule. La clé d'un trajet se dérive des données : l'identifiant de l'appareil et l'horodatage de départ, ou l'identifiant que le fournisseur du véhicule a déjà attribué. Elle ne doit pas dépendre du run : ni le compteur auto-incrémenté, ni l'ordre d'arrivée des enregistrements. Une clé qui change entre deux runs n'est pas une clé ; ce sont deux faits différents portant un même nom.
Rendez l'écriture idempotente, adossée à cette identité. Notre sink est une table Postgres, donc l'écriture est un upsert. Postgres fournit ON CONFLICT depuis la version 9.5, arrivée en 2016, et MERGE depuis la version 15, en 2022 ; l'exemple ci-dessous utilise ce dernier. Le même contrat existe dans tous les choix de moteur que nous faisons pour les autres charges de travail, du MERGE de Spark sur les tables Delta et Iceberg jusqu'à la stratégie incrémentale merge documentée pour les modèles dbt, et la gestion des coordonnées sous un tel schéma est toute une argumentation antérieure.
MERGE INTO trips AS target
USING staged_trips AS source
ON target.trip_id = source.trip_id
WHEN MATCHED THEN UPDATE
SET started_at = source.started_at,
distance_m = source.distance_m,
vehicle_class = source.vehicle_class
WHEN NOT MATCHED THEN INSERT
(trip_id, started_at, distance_m, vehicle_class)
VALUES (source.trip_id, source.started_at, source.distance_m, source.vehicle_class);
Une fois chaque écriture répétable, l'avancement se dérive au lieu de se déclarer. L'heure que le job peut sauter est la plus haute heure d'ingestion entièrement présente dans le sink, et une requête contre la sortie y répond, quelles que soient les prétentions du manifeste. À 3 h 04, le redémarrage fait un SELECT max() unique, saute les six heures confirmées et termine la septième. Le manifeste existe toujours, mais pour économiser du travail, jamais pour être cru seul.
Voilà aussi pourquoi l'identité précède l'idempotence dans l'ordre du travail. Un MERGE adossé à un identifiant dérivé du run laisse des lignes dupliquées derrière lui à chaque réexécution : chaque run croyait de bonne foi rencontrer un fait entièrement neuf.
Un checkpoint stocké hors du sink n'est qu'une rumeur
L'endroit où vit le checkpoint importe autant que le comportement des écritures. Un checkpoint détenu dans la mémoire d'un serveur de job meurt avec ce serveur, et un répertoire de checkpoint Spark Structured Streaming ou un offset de consommateur Kafka ne sert que s'il est livré avec la sortie qu'il décrit. Le producteur transactionnel de Kafka existe précisément pour cela depuis la version 0.11, publiée en 2017 : l'offset et l'écriture de sink tombent dans une seule transaction atomique, si bien qu'un redémarrage ne peut avancer l'offset au-delà d'un travail jamais écrit.
Tout ce qui empoisonne l'écriture empoisonne la reprise. Les fonctions d'horloge viennent en tête : une ligne estampillée now() diffère entre le crash et la reprise, si bien que la reprise réécrit en silence des lignes qu'elle vient d'écrire au lieu de les rencontrer inchangées. Les clés aléatoires et l'ordre d'itération non trié de la source sont le même défaut sous d'autres habits. La règle est brutale : dérivez tout de l'entrée, et faites de la reprise une seconde lecture du même monde plutôt qu'un monde neuf.
La table de checkpoint reçoit elle-même la durabilité de la sortie, parce qu'elle est sa table des matières. Nous gardons une ligne confirmed_batches écrite dans la même transaction que le lot qu'elle décrit, ce qui tient une promesse qui vaut n'importe quel tableau de bord : le travail confirmé n'est ni perdu ni appliqué deux fois.
Ce que la conception de la reprise ne peut pas réparer
Les effets de bord sont hors contrat. Un courriel de confirmation, un webhook vers un partenaire, un billet ouvert dans une file d'exploitation : les lignes se réécrivent, un courriel ne se désenvoie pas. Notre parade déplace tout ce qui a cette forme dans son propre petit job, qui lit la sortie confirmée et déclenche les effets une fois par fait, derrière une clé d'idempotence que le système récepteur peut vérifier. Le grand job reprend ; le job des effets se rejoue en quelques secondes.
Le non-déterminisme du monde, et pas seulement du code, est la deuxième limite. Un run qui joint à l'exécution des données vivantes de deux sources se résout autrement après un redémarrage, parce qu'une source a été mise à jour entre le crash et la reprise. Poser d'abord les entrées brutes et tout dériver depuis la zone de transit coûte une copie, et il achète une reprise qui redérive depuis les mêmes octets que la première fois. Nous le payons pour tout pipeline long ; sur les pipelines courts, nous sautons la zone de transit et vivons avec le risque réduit.
Et l'idempotence n'est pas de l'exactitude-une-fois, si bien ajustée soit-elle par un fournisseur. C'est de l'exactitude-une-fois-à-la-lecture : une réexécution écrira deux fois le même fait, et les lecteurs qui ne tolèrent pas de voir un fait deux fois ont besoin d'une logique de déduplication ou d'une source transactionnelle. Nommer cette distinction dans un document de conception a réglé plus d'arguments que toute comparaison de frameworks que nous ayons traversée.
Choisissez le budget de réexécution de chaque pipeline avant d'écrire la première transformation : un job récupérable en une demi-heure est honnêtement et à peu de frais une relance, et un job récupérable en sept heures est une écriture idempotente avec un journal d'avancement côté sink, que ces mots figurent ou non sur la liste de contrôle. Si supprimer-relancer reste le plan de récupération, chiffrez chaque correctif comme une réexécution complète et laissez ce chiffre plaider pour vous.
Le coût d'un crash se décide à l'heure de l'écriture, pas à l'heure du retry.
AngoraTek construit des pipelines de données capables de reprendre pour de petites équipes. Si votre plan de récupération reste la touche supprimer, [apportez-nous le pipeline](/fr/#contact) et nous chercherons ensemble le premier endroit où un checkpoint a sa place.Merci d'avoir lu jusqu'ici. Si cela ressemble au problème sur lequel vous butez, parlez-nous-en. L'équipe lit chaque message.
Engager la conversation