Rubrique
Architecture
Event Sourcing, CQRS, DDD, messaging : comment un système tient dans la durée.
Dossiers
Systèmes event-sourcés
DDD, CQRS, sagas, projections : quatorze chapitres pour concevoir, tester et opérer un système event-sourcé, avec les compromis que les introductions passent sous silence.
14 chapitres · 4 h 40 de lecture
SaaS multi-tenant de bout en bout
Choisir un modèle de tenancy, isoler les données, limiter les voisins bruyants, migrer sans casser les clients et répondre aux exigences des grands comptes sans transformer le produit en collection d'installations séparées.
11 chapitres · 2 h 40 de lecture
Articles
50 articles
Isolation multi-tenant : comment les fuites entre clients arrivent
Pourquoi les fuites entre clients viennent rarement de la requête SQL et presque toujours des copies de la donnée (cache, files, index de recherche, stockage objet), et où poser le tenant pour qu'un oubli ne soit plus possible.
8 minMembres
Tests de caractérisation : figer un comportement qu'on ne comprend pas
Avant de toucher à du code que personne ne comprend, on enregistre ce qu'il fait, pas ce qu'il devrait faire. Comment construire ce filet, le rendre déterministe, savoir ce qu'il ne couvre pas, et quand le jeter.
7 minMembres
Mutation testing : mesurer ce que valent vos tests
La couverture dit quelles lignes sont exécutées, pas lesquelles sont vérifiées. Ce que le mutation testing mesure réellement, ce qu'il coûte en temps machine et en attention, et les zones du code où il rapporte.
7 minMembres
Réécrire : les quatre cas où c'est la bonne décision
« Ne jamais réécrire » est une règle utile et fausse. Les quatre situations où la réécriture bat la migration progressive, le calcul qui les départage, et les conditions sans lesquelles même une réécriture justifiée échoue.
7 minMembres
Circuit breakers : pourquoi ils déçoivent
Pourquoi un disjoncteur binaire répond mal aux pannes partielles, comment il transforme 10 % d'erreurs en panne totale, et par quoi le remplacer dans la plupart des cas.
6 minLecture libre
Pannes métastables : quand le système ne revient pas
Pourquoi un système peut rester en panne après la disparition de ce qui l'a fait tomber, comment reconnaître la boucle qui l'y maintient, et ce qu'il faut couper pour en sortir.
7 minMembres
Le retry qui a tué la production
Comment trois couches qui rejouent chacune trois fois multiplient la charge par soixante-quatre, pourquoi le backoff n'y change rien, et comment un budget de retry borne l'amplification.
7 minLecture libre
Des échéances propagées plutôt que des timeouts
Pourquoi des timeouts réglés couche par couche font travailler le système pour des clients déjà partis, et comment propager une échéance unique jusqu'à la requête SQL.
7 minMembres
Migrations par tenant : mille schémas ou une colonne
Ce que coûte, en exploitation, chacun des trois modèles de base multi-tenant (colonne partagée, schéma par tenant, base par tenant) le jour d'une migration, d'une restauration et d'un départ de client, et le critère pour choisir.
8 minMembres
Lire sur un replica : les bugs de lecture périmée
Les trois anomalies qu'un replica de lecture introduit dans une application qui n'en avait pas, les quatre façons de lire ses propres écritures avec leur prix, et le critère pour décider quelles lectures ont le droit de quitter le primaire.
8 minMembres
Lire un rapport de test de cohérence en trente minutes
Une méthode en cinq passes pour tirer une décision d'un rapport de test de cohérence sans être spécialiste des systèmes distribués : ce qui a été testé, ce qui était promis, ce qui a cassé, sous quelle panne, et ce que ça change pour votre usage.
8 minMembres
La double écriture est toujours un bug
Pourquoi écrire dans deux systèmes depuis le même code finit toujours par diverger, les seules sorties correctes, et comment choisir entre outbox et CDC selon ce que chacun vous fait payer.
7 minMembres
Simulation déterministe pour équipes ordinaires
Sans réécrire votre système autour d'un simulateur, vous pouvez rendre reproductibles les bugs d'ordre, de doublon et de panne partielle. Ce qui est atteignable avec une horloge injectée, un aléa à graine et un bus simulé, ce que ça coûte, et où ça s'arrête.
7 minMembres
Write skew : l'anomalie que vos tests ne voient pas
Comment deux transactions correctes prises isolément violent ensemble un invariant, pourquoi ni READ COMMITTED ni REPEATABLE READ ne l'empêchent, et les quatre parades avec leur prix.
7 minMembres
Concevoir une API pour des agents
Ce qui change quand le consommateur de votre API est un modèle qui la relit à chaque appel : les descriptions deviennent le contrat, les erreurs des instructions, et la taille des réponses un budget.
8 minMembres
Webhooks fiables : envoyer et recevoir
Ce qu'un webhook garantit vraiment, comment l'émettre sans qu'un destinataire lent bloque les autres, et comment le recevoir sans dépendre de l'ordre ni de l'unicité des livraisons.
7 minMembres
Durable execution : moteur de workflow ou table d'état ?
Un moteur de durable execution et une table d'état résolvent le même problème avec des contraintes opposées, surtout le jour où vous modifiez un workflow dont des instances sont en cours. Les stratégies de versionnement et le critère pour choisir.
7 minMembres
Le comité d'architecture, ou comment ralentir sans protéger
Pourquoi une instance d'approbation préalable ajoute des semaines sans retirer de risque, quels besoins réels elle recouvre, et les mécanismes qui y répondent mieux, avec leurs propres défaillances.
8 minMembres
Choisir l'ennui : le budget d'innovation d'une équipe
Une technologie nouvelle coûte des jours d'exploitation chaque année, qu'on s'en serve beaucoup ou peu. Comment chiffrer ce coût, compter les jetons qu'une équipe peut réellement dépenser, et décider où les placer.
7 minLecture libre
Pagination par clé : en finir avec OFFSET
Pourquoi OFFSET ralentit et se trompe, comment paginer sur une clé de tri totale, et les cas limites qui cassent un curseur : égalités, tris mixtes, NULL, colonnes qui bougent.
7 minMembres
Les migrations s'arrêtent à 80 % : comment les finir
Pourquoi une migration technique cale toujours au même endroit, ce que coûte l'état intermédiaire, et les mécanismes d'organisation qui permettent d'éteindre réellement l'ancien système.
7 minMembres
Sagas : la compensation que personne ne teste
Une compensation s'exécute rarement, dans le pire état possible, et peut elle-même échouer. Comment énumérer les états de panne partielle d'une saga, ordonner les étapes autour d'un pivot, et tester chaque chemin de retour par injection de pannes.
7 minMembres
Les horloges mentent : ce que ça casse dans votre code
Quatre mensonges de l'horloge (elle recule, elle diffère d'une machine à l'autre, elle dépend d'un fuseau, elle confond le fait et sa saisie) et pour chacun la parade, son prix et le cas où l'on peut s'en passer.
7 minMembres
Rollback : le mythe
Pourquoi revenir à la version précédente ne ramène pas l'état précédent, ce qu'il faut garantir pour qu'un rollback reste possible, et quand la correction en marche avant est la seule option honnête.
7 minMembres
Feature flags : la dette invisible
Pourquoi chaque flag double l'espace des états que vous n'avez jamais testés, et la discipline minimale (type, propriétaire, échéance) pour qu'un flag meure à la date prévue.
7 minLecture libre
Monolithe ou microservices : une question d'effectif
Le découpage en services répond à un problème de coordination entre équipes bien plus qu'à un problème technique. Des calculs pour situer votre seuil, et les rares cas où la technique décide quand même.
7 minMembres
Architecture cellulaire : pour qui, à partir de quand
Ce qu'une architecture en cellules réduit réellement, ce que coûtent le routeur et la migration de tenants, et les seuils en dessous desquels des étapes plus modestes donnent l'essentiel du bénéfice.
7 minMembres
Idempotency keys : les sept détails qui comptent
Portée, hash de requête, rejeux concurrents, résultat stocké, erreurs, expiration, propagation : les sept décisions qui séparent une clé d'idempotence qui protège d'une clé qui rassure.
7 minLecture libre
Faire ou acheter : la grille que le directeur financier accepte
Comparer un abonnement et un développement interne sur le même horizon, avec le coût de sortie et le point de croisement du tarif à l'usage. Une grille en sept lignes qui tient devant quelqu'un qui lit des budgets.
7 minLecture libre
Rapprocher ses comptes avec un prestataire de paiement
Les webhooks ne suffisent pas à garantir que votre registre et celui du prestataire disent la même chose. Comment construire un rapprochement quotidien, classer les écarts, tolérer les délais et corriger sans réécrire.
7 minMembres
Revenir des microservices : critères, plan de consolidation, ce qu'on perd
Les signaux qui justifient de regrouper des services, l'ordre dans lequel consolider sans fabriquer une boule de boue, et la liste honnête de ce que vous abandonnez en revenant.
7 minMembres
Un solde n'est pas une colonne
Pourquoi une colonne `balance` ne peut ni s'expliquer ni se corriger, ce qu'apporte un registre en partie double par rapport à un simple journal, et le schéma PostgreSQL minimal pour en tenir un.
6 minMembres
Rate limiting : quatre algorithmes, quatre façons d'échouer
Ce que chaque algorithme de limitation laisse passer malgré lui, ce que coûte un compteur partagé entre instances, et pourquoi une limite par client ne remplace pas le délestage.
8 minMembres
Le cache est une dette de disponibilité
Pourquoi un cache efficace rend le système incapable de démarrer sans lui, comment naissent les ruées sur une clé expirée, et les critères pour décider si un cache est une optimisation ou une dépendance dure.
7 minMembres
ADR : la dette documentaire que personne ne compte
Pourquoi un répertoire d'ADR se périme sans que personne le voie, ce qu'une décision périmée coûte quand un humain ou un agent l'applique, et le format qui rend le remplacement moins cher que l'oubli.
7 minMembres
Exactly-once n'existe pas : ce qu'on vous vend à la place
Ce que couvrent réellement les promesses « exactly-once » des brokers, où elles s'arrêtent, et comment obtenir un effet unique avec une livraison au moins une fois et un consommateur idempotent.
7 minMembres
Le voisin bruyant : quotas, équité et facturation de l'usage
Pourquoi une limite globale ne protège aucun client, comment répartir une ressource partagée entre tenants, et pourquoi le compteur qui limite n'est jamais celui qui facture.
8 minLecture libre
Monolithe modulaire : ce que coûte vraiment une frontière
Une frontière de module n'existe que si une machine la vérifie. Ce qu'il faut outiller, ce que chaque frontière coûte à chaque fonctionnalité, et comment elle s'érode quand même.
7 minLecture libre
Verrous distribués : le fencing token ou rien
Pourquoi un bail avec expiration ne garantit jamais l'exclusion mutuelle, comment le fencing token déplace la vérification vers la ressource, et que faire quand la ressource ne sait pas vérifier.
7 minMembres
Versionner une API sans la casser pendant cinq ans
Comment empiler des couches de compatibilité au-dessus d'un seul modèle courant, ce que chaque couche coûte pour toujours, et les changements qu'aucune couche ne sait absorber.
7 minMembres
Event Sourcing : quand il faut refuser le pattern
Ce que l'Event Sourcing rapporte et coûte vraiment, les signaux pour l'adopter ou le refuser, et comment défendre un refus en réunion d'architecture.
7 minLecture libre
CQRS et UX : ce que coûte l'eventual consistency
Pourquoi une projection est en retard par design, et comment choisir entre token de version, notification push et optimistic UI pour garantir à l'utilisateur de lire ses propres écritures.
5 minLecture libre
Stop subscribing to domain events
Pourquoi un subscriber in-process sur un domain event perd des effets de bord, et comment décider entre subscriber direct, integration event via Outbox ou workflow.
4 minMembres
Outbox Pattern : pourquoi votre EventBus ne suffit pas
Pourquoi publier sur un bus après le commit perd des événements, et comment l'Outbox, l'Inbox, le CDC et la Dead Letter Queue garantissent une livraison au moins une fois.
4 minMembres
Saga vs Process Manager : la confusion qui casse les workflows
Ce qui distingue une saga d'un process manager, comment les rendre idempotents et gérer les timeouts, et à quel moment passer à Temporal ou à un workflow engine.
4 minMembres
Projection rebuild : ce qui casse à 50 millions d'événements
Pourquoi un rebuild naïf ne tient pas à 50 millions d'événements, et comment checkpointing, Blue-Green, Lazy Backfill et partitionnement permettent de le faire sans coupure.
5 minMembres
Schema evolution : corriger sans réécrire l'histoire
Quelle stratégie appliquer à chaque type de changement de schéma, comment tester les upcasters, et pourquoi un événement correctif n'est pas un événement compensatoire.
5 minMembres
GDPR et Event Sourcing : effacer sans supprimer l'histoire
Comment classifier les données, choisir entre Personal Data Store, crypto-shredding et tombstones, et traiter snapshots, projections et logs pour répondre à une demande d'effacement.
4 minMembres
Kill the Aggregate : et si la frontière de cohérence n'était pas l'entité ?
Ce que l'aggregate garantit et ce qu'il rigidifie, ce que proposent les Dynamic Consistency Boundaries, et comment décider si votre invariant justifie de sortir du modèle aggregate.
5 minMembres
Optimistic locking : éviter le Lost Update silencieux
Comment expectedVersion empêche deux retraits concurrents de s'écraser, comment le CommandBus fait un retry, et les règles à tenir en production.
3 minLecture libre
Nouveautés
· Architecture
Kubernetes v1.37 ajoute cinq conditions de Node pour le cycle de vie
Cinq conditions de Node normalisées décrivent désormais le drain, la maintenance et l'arrêt gracieux d'un nœud.
· Architecture
PostgreSQL 19 Beta 4 retire plusieurs fonctionnalités attendues
La quatrième bêta de PostgreSQL 19 annule SQL/PGQ, FOR PORTION OF et MERGE/SPLIT PARTITIONS, et annonce une release candidate début octobre.