Catalogue technique

L'évolution du web sous le capot : multiplexage HTTP/2, le piège du head-of-line blocking TCP, et QUIC qui change de transport. Même langage HTTP, plomberie réinventée.

Processus, threads, parallélisme, FastCGI, le pool PHP-FPM et FrankenPHP. Comment PHP traite plusieurs requêtes à la fois, et où va la mémoire.

Comprends comment HTTP envoie des données progressivement : chunked encoding, Server-Sent Events et streaming de fichiers.

Listeners, subscribers, priorités, propagation, TraceableEventDispatcher — le bus d'événements Symfony dans les détails.

Tagged services, décoration, compiler passes, service locators, lazy — le conteneur Symfony sans mystère.

Bus de messages, Envelope, Stamps, Middleware, Transport, Worker, Retry — Messenger sans mystère.

Firewalls, authenticators, voters, tokens, stratégies — maîtrise complète de la couche Security Symfony.

Arguments, options, SymfonyStyle, ProgressBar, autocomplétion et tests — maîtrise complète du composant Console.

Maîtrise le streaming PHP de A à Z : output buffering, générateurs et streams natifs. Traite des données volumineuses sans saturer la mémoire.

Pipeline normalize/encode, normalizers fournis, attributs, groupes, contexte, custom normalizer — le Serializer Symfony sans mystère.

ValidatorInterface, contraintes built-in, groupes, cascading, contraintes custom — le Validator Symfony sans mystère.

PSR-6, PSR-16, adapters, tags, early expiration — le composant Cache Symfony sans mystère.

FormInterface, DataTransformer, DataMapper, Events, TypeExtension — le Form Component Symfony sans mystère.

Attributs #[Route], requirements, génération d'URL, conditions, RouteCollection et matching — maîtrise complète du composant Routing.

Workflow, StateMachine, guards, événements, Registry — modélise n'importe quel cycle de vie métier avec le composant Workflow.

CurlHttpClient, streaming, concurrence, retry, MockHttpClient — maîtrise le client HTTP de Symfony du test à la production.

Verrous exclusifs et partagés, TTL, blocking, stores Redis/Flock/PostgreSQL — gère les accès concurrents en production.

TreeBuilder, Processor, AbstractExtension, prepend — construis des bundles configurables et robustes.

Domaines, pluriels Interval et ICU, catalogues avec fallback, LocaleSwitcher, extraction — l'i18n Symfony de A à Z.

Valider, normaliser et documenter les options d'une classe — lazy options, nested, prototypes, déprecation.

Construis un serveur TCP et un client de zéro en Python. Sockets, bind/listen/accept, handshake, paquets, ports — tout ce que HTTP, Redis et PostgreSQL ont en commun sous le capot.

Reverse proxy, couches de cache HTTP, CDN, invalidation — comment servir du contenu vite et sans surcharger l'origin.

Call stack, microtasks, I/O non-bloquant, async/await, PHP Fibers — comment un seul thread fait tout en même temps.

Producteur/consommateur, ACK, DLQ, backpressure, RabbitMQ, Kafka — les patterns de communication asynchrone.

Token bucket, leaky bucket, sliding window, fixed window, Redis distribué — les algorithmes qui protègent tes APIs de la surcharge.

LRU, LFU, TTL, Redis, stampede, write-through — tout ce qui se passe derrière un simple hit de cache.

RequestEvent, ControllerEvent, ViewEvent, ExceptionEvent — les 8 événements qui orchestrent chaque requête Symfony.

ACID, niveaux d'isolation, MVCC, deadlocks, optimistic locking — comprendre ce qui se passe vraiment entre BEGIN et COMMIT.

Du log texte au log JSON. Collecte avec Promtail, stockage dans Loki, requêtes LogQL et corrélation avec métriques et traces.

Comprends comment une requête traverse plusieurs services. Spans, propagation W3C, SDK OpenTelemetry, stockage Tempo, et TraceQL pour diagnostiquer n'importe quel problème de performance.

Comment fonctionne un index B-tree, comment un ORM génère N+1 requêtes sans prévenir, et comment lire EXPLAIN ANALYZE.

Logs, métriques, traces — comprendre les trois signaux qui rendent un système observable, comment les corréler, et pourquoi le monitoring seul ne suffit plus.

Comprends le modèle pull de Prometheus, les quatre types de métriques, PromQL et comment construire une stack d'alerting fiable.

Datasources, dashboards, variables de template, alerting et corrélations métriques-logs-traces dans Grafana. La vitrine unifiée du stack LGTM.

Monolog JSON, SDK OpenTelemetry PHP, auto-instrumentation Symfony, corrélation trace_id dans les logs. L'observabilité complète d'une application PHP dans le stack LGTM.

Conçois un pipeline de métriques scalable pour Kubernetes : Prometheus + Thanos (Sidecar, Store Gateway, Query, Compacteur) + S3 long terme + Grafana. Du pod unique à l'architecture haute disponibilité.

Strings, Lists, Hashes, Sets, Sorted Sets, TTL, persistance RDB/AOF, Pub/Sub, Streams et patterns avancés. Du premier INCR au verrou distribué.

Handshake TLS 1.3, certificats X.509, Forward Secrecy, SNI, ALPN, HSTS — comment HTTPS fonctionne vraiment.

Conçois un système qui passe à l'échelle, étape par étape : d'un serveur unique à une architecture distribuée. Serveur sans état, load balancing, microservices, gateway, object storage, broker, cache, CDN, rate limiting — le tout illustré en construisant un clone de Google Drive.

Construis une messagerie instantanée entièrement serverless : WebSocket via API Gateway, Lambda, DynamoDB, file SQS et IAM. Le capstone pour comprendre comment on architecture les systèmes temps réel dans le cloud.

Les cinq timeouts d'un système (connexion, lecture, attente, traitement, réponse), pourquoi un timeout n'annule rien, comment ils se cumulent derrière un proxy, et les patterns de résilience qui évitent les tempêtes de retry : backoff, jitter, circuit breaker, idempotence.

Construis un raccourcisseur d'URL comme Bitly, entièrement serverless : API Gateway, Lambda, DynamoDB, IAM et CloudWatch. Un TP fil rouge pour comprendre l'architecture événementielle dans le cloud.

Deux faces d'un même problème : gérer les erreurs à l'intérieur (exceptions — lever, ne jamais avaler, mapper) et les communiquer à l'extérieur de façon normalisée (codes de statut HTTP, puis Problem Details — RFC 7807 et RFC 9457).

Plonge sous le capot de PHP : la SAPI, le cycle de vie d'une requête, la compilation en opcodes, OPcache, la gestion mémoire et le modèle share-nothing. Comprendre comment PHP fonctionne pour mieux développer et mieux héberger.

Comprends WebTransport, le protocole bâti sur HTTP/3 et QUIC : sessions, streams bidirectionnels et datagrammes non fiables — de l'UDP dans le navigateur. Pourquoi il arrive après WebSocket, ce qu'il change, et quand le choisir.

Dès qu'une entité change d'état, d'autres parties du système doivent réagir. Injecter des services dans l'entité ? C'est tentant — et c'est faux. Les Domain Events règlent ça proprement.

Les relations ManyToMany en ORM cachent souvent une question que tu ne t'es pas encore posée : qui est vraiment responsable de cette association ? On remodélise ensemble, avec Doctrine et les règles des agrégats DDD.