Logstash pour les devs - 30 - Logstash en production : architecture et bonnes pratiques
Déployer Logstash en production : haute disponibilité, load balancing, dimensionnement et patterns d'architecture.
Articles : architecture
50 articles sur le thème "architecture".
Logstash pour les devs - 03 - Anatomie d'un pipeline Logstash
Input, filter, output : comprendre les trois blocs d'un pipeline Logstash avec un exemple concret de bout en bout.
Logstash pour les devs - 01 - L'Elastic Stack de A a Z
Comment Elasticsearch, Logstash, Kibana et Beats s'articulent ensemble. Architecture, flux de donnees et quand utiliser quoi.
Logstash pour les devs - 05 - Input Beats : recevoir des logs de Filebeat
Configurer l'input Beats pour recevoir des événements de Filebeat. Architecture Filebeat + Logstash avec Docker Compose.
Logstash pour les devs - 20 - Pipelines multiples et pipeline-to-pipeline
Configurer plusieurs pipelines dans une instance Logstash et les faire communiquer avec pipeline-to-pipeline.
Docker pour les devs - 16 - Docker et monorepo
Dockerfile par service, build context, code partage, .dockerignore, et un exemple concret de structure monorepo dockerisee.
Docker pour les devs - 02 - L'architecture de Docker
Comment Docker fonctionne : daemon, client, images, conteneurs, registries, et le standard OCI.
Clean code et refactoring - 17 - Structurer un projet — feature-based vs layer-based
Layer-based ou feature-based ? Le choix de la structure de dossiers a un impact direct sur la maintenabilité du projet.
TypeScript en pratique - 04 - Organiser ses types dans un projet
Colocation ou centralisation, conventions de nommage, barrel files, et comment structurer les types entre frontend et backend.
REST API design - 01 - Les principes REST que personne ne lit
Les contraintes REST de Fielding, le modèle de maturite de Richardson, et pourquoi REST n'est pas du CRUD sur HTTP.
Clean code et refactoring - 08 - SOLID en pratique avec TypeScript
Les cinq principes SOLID illustres avec du TypeScript concret, et quand ils sont de trop
Domaines et cycles de vie - 01 - Le domaine métier : la fondation de tout
Ce qu'est un domaine métier en DDD, ses composants, ses frontieres, et pourquoi c'est le contrat le plus important de ton architecture.
Design patterns en TypeScript - 08 - Singleton, Service Locator et Dependency Injection
Singleton (et pourquoi l'éviter), Service Locator (et pourquoi c'est pire) et Dependency Injection (la bonne approche).
Architecture hexagonale - 06 - Projet complet : une API de commandes en TypeScript
Projet complet en architecture hexagonale avec TypeScript. API de commandes avec domaine, ports, adaptateurs et tests.
Tests en pratique - 01 - Quelle stratégie de test pour quel projet
La stratégie de test depend du projet. CRUD simple, API complexe, frontend, microservices : pas les memes tests.
Domaines et cycles de vie - 06 - Single Source of Truth (SSOT)
Pourquoi l'état d'une entité doit vivre a un seul endroit. SSOT, état persiste vs derive, et bonnes pratiques backend pour le cycle de vie.
Design patterns en TypeScript - 00 - Pourquoi les patterns comptent (et lesquels ignorer)
Les design patterns qui comptent en 2026. Pas les 23 du GoF, les 10 qu'on utilise vraiment au quotidien en TypeScript.
Domaines et cycles de vie - 10 - Features vs Domaine : la bonne decoupe
Comment découper les features autour du cycle de vie. Relation entre feature et domaine DDD, séparation des responsabilités en architecture logicielle.
Architecture hexagonale - 04 - Les adaptateurs : brancher le monde réel
Les adaptateurs en architecture hexagonale : implementer les ports avec PostgreSQL, Express, Stripe et le reste du monde réel.
Architecture hexagonale - 07 - Quand utiliser (et ne pas utiliser) l'hexa
Quand l'architecture hexagonale vaut le coup et quand c'est overkill. Comparaison avec clean architecture, MVC et les microservices.
Domaines et cycles de vie - 09 - La dette technique : quand on construit sans lifecycle
7 problèmes concrets causes par l'absence de cycle de vie dans ton code. Avec la solution architecture pour chacun, et du refactoring pragmatique.
Architecture hexagonale - 02 - Le domaine : ta logique métier sans dépendances
Isoler la logique métier dans le domaine. Entités, value objects et regles métier en TypeScript, sans framework ni base de donnees.
Microservices - 03 - Communication inter-services : REST, gRPC et messages
Les trois facons de faire communiquer des microservices : REST, gRPC et messaging asynchrone. Quand utiliser chaque approche.
Domaines et cycles de vie - 04 - La machine a états (State Machine / FSM)
Comment implementer une machine a états finis en TypeScript. Transition map declarative vs if/else, avec exemples concrets pour le backend.
Microservices - 04 - L'infra : Docker, orchestration et service discovery
L'infrastructure des microservices : Docker Compose pour le dev, Kubernetes pour la prod, service discovery et reverse proxy.
Domaines et cycles de vie - 03 - Le cycle de vie d'une entité
Comment modéliser le cycle de vie d'une entité avec des états explicites. Le lifecycle est l'ossature de toute architecture DDD solide.
Domaines et cycles de vie - 00 - Introduction : pourquoi on structure le code autour du métier
Pourquoi penser domaine métier avant de coder. Introduction a une serie sur l'architecture, le DDD et les cycles de vie en développement.
Microservices - 02 - Decouper un monolithe : par ou commencer
Comment découper un monolithe en microservices. Identifier les bounded contexts, extraire le premier service, éviter le distributed monolith.
Tests fondamentaux - 05 - Tests fonctionnels : valider les use cases complets
Tester un use case de bout en bout avec des fakes. La différence entre test unitaire et test fonctionnel en archi hexagonale.
Architecture hexagonale - 08 - Glossaire complet
Tous les termes de l'architecture hexagonale expliques : port, adaptateur, domaine, use case, DIP, clean architecture et plus. Avec des exemples TypeScript.
Architecture hexagonale - 00 - Pourquoi ton code merite une vraie architecture
Pourquoi l'architecture hexagonale change la facon de structurer ton code. Introduction aux ports et adaptateurs pour les devs pragmatiques.
Tests en pratique - 07 - Organiser ses tests dans un projet
Co-location vs dossier __tests__, nommage, séparation par type, scripts et configuration bun test.
Domaines et cycles de vie - 11 - Glossaire complet
Glossaire complet des termes DDD et architecture logicielle : aggregate, bounded context, CQRS, entity, FSM, invariant, et plus. Avec exemples.
Microservices - 00 - C'est quoi un microservice (et pourquoi tu n'en as peut-etre pas besoin)
Les microservices expliques sans bullshit. Ce que c'est, ce que ca n'est pas, et pourquoi un monolithe bien fait suffit souvent.
Architecture hexagonale - 01 - Le concept : ports, adaptateurs et le domaine au centre
Le concept de l'architecture hexagonale explique simplement. Domaine, ports et adaptateurs avec un schema clair.
Domaines et cycles de vie - 07 - Les invariants : ce qui doit toujours etre vrai
Les invariants en DDD : des conditions testables par état du cycle de vie. Comment les définir, les vérifier et les utiliser pour debugger en TypeScript.
Microservices - 05 - Les 7 erreurs classiques (et comment les éviter)
Les erreurs les plus courantes en microservices : nano-services, couplage distribue, pas de monitoring, et comment les éviter.
gRPC - 00 - Pourquoi gRPC existe et quand l'utiliser
gRPC explique simplement : pourquoi Google l'a créé, comment ca marche, et quand préférer gRPC a REST.
Déploiement automatique avec GitLab CI - 01 - L'architecture : VPS, Docker Compose et Caddy
L'architecture d'un déploiement automatise : VPS, Docker Compose, Caddy reverse proxy et multi-subdomains avec auto-SSL.
Architecture hexagonale - 03 - Les ports : les interfaces du domaine
Les ports en architecture hexagonale : interfaces TypeScript entre le domaine et le monde extérieur. Ports entrants et sortants.
Architecture hexagonale - 05 - Tester sans souffrir : le vrai gain de l'hexa
Comment l'architecture hexagonale rend tes tests simples. Domaine testable sans base de donnees, adaptateurs interchangeables.
gRPC - 06 - gRPC vs REST : le comparatif définitif
gRPC vs REST compare point par point : performance, typing, streaming, tooling, debugging. Avec benchmarks et recommandations.
Microservices - 01 - Monolithe vs microservices : le vrai comparatif
Monolithe vs microservices : comparaison honnete avec avantages, inconvenients et cas d'usage concrets.
Domaines et cycles de vie - 05 - Transitions, guards et side effects
Les transitions, guards et side effects dans une state machine. Comment protéger ton cycle de vie avec des preconditions testables en TypeScript.
Microservices - 06 - Glossaire
Tous les termes de l'architecture microservices expliques : saga, circuit breaker, event sourcing, service mesh, CQRS et plus.
Tests fondamentaux - 01 - La pyramide des tests : unit, intégration, e2e
La pyramide des tests de Mike Cohn : beaucoup d'unitaires, moins d'intégration, peu de e2e. Et les anti-patterns a éviter.
Domaines et cycles de vie - 02 - Entités, Value Objects et identité
Comprendre la différence entre entité, Value Object et DTO en DDD. Exemples TypeScript pour bien structurer ton domaine métier.
Domaines et cycles de vie - 08 - Idempotence : exécuter sans crainte
L'idempotence expliquee simplement : pourquoi c'est indispensable pour les API, les transitions d'état et les systèmes distribues.
Bun vs Node.js en 2026 : quel runtime choisir ?
Comparaison détaillée de Bun et Node.js en 2026. Performance, écosystème, compatibilité et cas d'usage pour choisir le bon runtime JavaScript.
gRPC vs REST : quand choisir quoi ?
Comparaison pratique entre gRPC et REST pour vos APIs. Performance, DX, cas d'usage et critères de choix pour votre architecture.