REST API design - 23 - Sécurité : les attaques que tu vas subir (et comment t'en protéger)
Input sanitization, SQL injection, mass assignment, limites de taille, HTTPS, security headers et OWASP API Top 10.
Articles : backend
59 articles sur le thème "backend".
REST API design - 22 - Performance : quand chaque milliseconde compte
N+1, batch endpoints, compression, streaming, connection pooling et 202 Accepted avec polling pour des APIs rapides.
REST API design - 09 - Erreurs : un format que tes clients vont adorer
Comment structurer tes réponses d'erreur avec RFC 7807 Problem Détails, des codes métier et une vraie stratégie d'internationalisation.
REST API design - 11 - Versioning : quand et comment faire évoluer ton API
URL path, header custom, content negotiation : les stratégies de versioning et comment gerer la deprecation proprement.
gRPC - 05 - gRPC en production : load balancing, TLS et observabilité
Déployer gRPC en production : TLS, load balancing L7, health checks, interceptors et observabilité avec OpenTelemetry.
Cles, chiffrement et authentification - 05 - TLS, HTTPS et certificats : comment ca marche
Le fonctionnement de TLS et HTTPS demystifie. Certificate authorities, Let's Encrypt, et ce qui se passe quand tu tapes https://.
Tests de performance - 00 - Ton code marche, mais est-ce qu'il tient la charge ?
Introduction aux tests de performance : benchmark, charge, stress et endurance. Pourquoi les tests fonctionnels ne suffisent pas.
SQL avance et PostgreSQL - 06 - Transactions et ACID : garantir l'intégrité
Les transactions SQL et les propriétés ACID. BEGIN, COMMIT, ROLLBACK, isolation levels et les pièges de la concurrence.
Authentification et sécurité web - 00 - Authentification vs autorisation
La différence entre authentification et autorisation. Deux concepts que les juniors confondent tout le temps.
SQL avance et PostgreSQL - 12 - Migrations : versionner ton schema de base de donnees
Gerer les migrations de schema PostgreSQL. Versionning, rollback, zero-downtime migrations et les outils disponibles.
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.
gRPC - 01 - Protocol Buffers : définir ton contrat d'API
Écrire des fichiers .proto pour définir tes services gRPC. Messages, types, enums et bonnes pratiques de schema.
gRPC - 07 - Glossaire
Tous les termes gRPC expliques : Protobuf, streaming, interceptor, channel, deadline, mTLS et plus. Avec exemples de code.
Design patterns en TypeScript - 02 - Repository : abstraire l'acces aux donnees
Le pattern Repository en TypeScript. Abstraire la base de donnees derrière une interface pour des tests faciles et un domaine propre.
SQL avance et PostgreSQL - 08 - Les triggers : reagir automatiquement aux changements
Les triggers PostgreSQL : exécuter du code automatiquement sur INSERT, UPDATE ou DELETE. Audit, validation et effets de bord.
Design patterns en TypeScript - 03 - Strategy : changer de comportement a la volee
Le pattern Strategy en TypeScript. Encapsuler des algorithmes interchangeables derrière une interface commune.
gRPC - 03 - Le client gRPC en TypeScript
Creer un client gRPC en TypeScript. Connexion, appels unaires, gestion d'erreurs et timeouts.
Authentification et sécurité web - 04 - Refresh tokens : garder l'utilisateur connecte
Les refresh tokens pour renouveler les access tokens sans redemander le mot de passe. Rotation, stockage et sécurité.
SQL avance et PostgreSQL - 13 - Performance : EXPLAIN ANALYZE, connection pooling et tuning
Optimiser PostgreSQL : lire EXPLAIN ANALYZE, connection pooling avec PgBouncer, et les paramètres de configuration.
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.
Tests de performance - 04 - Stress test : trouver le point de rupture
Comment trouver les limites de ton serveur avec un stress test. Le point de rupture, les cascades et ce qui casse en premier.
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.
SQL avance et PostgreSQL - 00 - Pourquoi comprendre SQL meme avec un ORM
Pourquoi chaque dev backend doit comprendre SQL. Les ORM cachent la complexité mais pas les problèmes de performance.
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.
SQL avance et PostgreSQL - 02 - Les JOINs : INNER, LEFT, RIGHT, FULL et CROSS
Comprendre les JOINs SQL une bonne fois pour toutes. INNER, LEFT, RIGHT, FULL et CROSS avec des schemas visuels.
Authentification et sécurité web - 01 - Sessions et cookies : le modèle classique
L'authentification par session et cookie. HttpOnly, Secure, SameSite et pourquoi c'est toujours le meilleur choix pour la plupart des apps.
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.
Authentification et sécurité web - 05 - Hashing de mots de passe : bcrypt, argon2 et pourquoi pas SHA-256
Pourquoi on hash les mots de passe et pourquoi SHA-256 n'est pas la bonne réponse. bcrypt, argon2 et le facteur de coût.
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.
gRPC - 02 - Creer un serveur gRPC en TypeScript
Implementer un serveur gRPC en TypeScript avec @grpc/grpc-js. Du fichier .proto au serveur fonctionnel, étape par étape.
Authentification et sécurité web - 03 - OAuth2 : les flows expliques sans jargon
OAuth2 demystifie : Authorization Code, PKCE, Client Credentials. Les flows expliques avec des schemas concrets.
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.
Design patterns en TypeScript - 07 - Decorator : ajouter des comportements sans modifier le code
Le pattern Decorator en TypeScript. Wrapper des fonctions pour ajouter logging, cache, retry, auth sans toucher au code original.
gRPC - 04 - Le streaming : la vraie force de gRPC
Les 4 types de streaming gRPC : unary, server, client et bidirectionnel. Exemples concrets en TypeScript.
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.
Design patterns en TypeScript - 04 - Observer et EventEmitter : reagir aux changements
Le pattern Observer en TypeScript. EventEmitter natif de Node, events custom et le découplage par les événements.
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.
Tests de performance - 06 - Timeouts et resilience : quand le réseau lache
Tester les timeouts, les retries et le comportement en mode degrade. AbortController, circuit breaker et chaos testing.
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.
Authentification et sécurité web - 02 - JWT : comment ca marche et quand l'utiliser
Les JSON Web Tokens expliques : structure, signature, quand les utiliser et surtout quand NE PAS les utiliser.
Héberger son serveur mail - 06 - Intégrer le serveur mail dans ton application
Connecter ton application a ton serveur mail. Envoi avec nodemailer, lecture IMAP avec imapflow, et templates HTML.
Authentification et sécurité web - 06 - RBAC : rôles, permissions et middleware
Implementer un système de rôles et permissions en TypeScript. RBAC, middleware et les erreurs classiques.
SQL avance et PostgreSQL - 10 - JSON et JSONB : le NoSQL dans ton PostgreSQL
Stocker et requeter du JSON dans PostgreSQL. JSONB, opérateurs, index GIN et quand utiliser JSON vs colonnes relationnelles.
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.
Design patterns en TypeScript - 01 - Factory : créer des objets sans new partout
Le pattern Factory en TypeScript : créer des objets complexes avec une fonction ou une classe. Exemples concrets et cas d'usage.
Microservices - 01 - Monolithe vs microservices : le vrai comparatif
Monolithe vs microservices : comparaison honnete avec avantages, inconvenients et cas d'usage concrets.
SQL avance et PostgreSQL - 14 - Sécurité : rôles, permissions et Row Level Security
Securiser PostgreSQL : rôles, GRANT/REVOKE, schemas, Row Level Security et les bonnes pratiques d'acces.
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.
Design patterns en TypeScript - 06 - Builder : construire des objets complexes pas a pas
Le pattern Builder en TypeScript. Construire des objets avec beaucoup de paramètres optionnels de facon lisible.
SQL avance et PostgreSQL - 01 - SELECT, WHERE, ORDER BY : les fondamentaux solides
Les bases du SELECT en SQL qui font la différence : WHERE, ORDER BY, LIMIT, OFFSET, DISTINCT, aliases et les pièges courants.
Microservices - 06 - Glossaire
Tous les termes de l'architecture microservices expliques : saga, circuit breaker, event sourcing, service mesh, CQRS et plus.
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.
SQL avance et PostgreSQL - 11 - Le problème N+1 : le détecter et le corriger
Le problème N+1 en SQL : comment il apparaît avec les ORM, comment le détecter et 3 stratégies pour le corriger.
SQL avance et PostgreSQL - 07 - Fonctions et stored procedures en PL/pgSQL
Écrire des fonctions et stored procedures en PostgreSQL. PL/pgSQL, paramètres, retours, exceptions et cas d'usage.
Design patterns en TypeScript - 05 - Adapter : faire parler deux interfaces incompatibles
Le pattern Adapter en TypeScript. Convertir l'interface d'une lib externe en celle que ton code attend.
SQL avance et PostgreSQL - 09 - Vues, vues materialisees et generated columns
Les vues SQL, les vues materialisees pour le cache de requêtes complexes, et les colonnes générées en PostgreSQL.
Tests fondamentaux - 07 - Tests de contrat d'API
Verifier que ton API respecte son contrat : status codes, shape des réponses, headers. Avec des exemples Elysia.