Formation Développement Web Avancé

Leçon 1 • Limitations de HTTP et besoins en temps réel

Met en contraste le modèle traditionnel requête-réponse de HTTP avec les exigences du temps réel. Justifie l'existence des solutions transitoires que sont le polling, le long-polling et SSE.

Leçon 2 • Choisir la bonne stratégie en temps réel

Fournit un cadre décisionnel comparant WebSockets, SSE et WebRTC pour différents scénarios. Les étudiants appliquent le cadre à des besoins fonctionnels réalistes.

Leçon 3 • Principes de l'architecture orientée événements

Introduit les éditeurs, les abonnés et les bus d'événements comme éléments de base architecturaux. Prépare les étudiants à concevoir des systèmes en temps réel découplés tout au long du cours.

Leçon 1 • Configuration de l'environnement et gestion des secrets

Couvre les variables d'environnement, les fichiers de configuration et l'injection de secrets pour les serveurs temps réel. Garantit que les étudiants ne codent jamais en dur les identifiants avant d'aborder les fonctionnalités authentifiées.

Leçon 2 • Structuration des gestionnaires d'événements en temps réel

Introduit des schémas de routage d'événements modulaires pour maintenir la maintenabilité du code serveur à mesure que le nombre de fonctionnalités augmente. Les étudiants refactorisent un gestionnaire monolithique en une architecture routée.

Leçon 3 • Test du serveur temps réel

Applique des stratégies de tests unitaires et d'intégration spécifiques aux serveurs WebSocket. Les étudiants écrivent des tests qui simulent des clients concurrents et vérifient l'exactitude des événements.

Leçon 4 • Boucle d'événements et concurrence de Node.js

Explique la boucle d'événements monothread, libuv et les E/S non bloquantes comme fondement des serveurs temps réel. Motive directement les choix architecturaux effectués plus loin dans le chapitre.

Leçon 1 • Construction d'une application de chat multi-salon

Applique tous les concepts de Socket.IO dans un projet guidé produisant un chat multi-salon fonctionnel. Renforce les salons, les accusés de réception et l'intégration client grâce à une construction pratique.

Leçon 2 • Accusés de réception et livraison fiable

Couvre les callbacks d'accusé de réception de Socket.IO et la logique de nouvelle tentative pour une livraison garantie des messages. Relie les schémas de fiabilité à des exigences réelles comme la confirmation de commande.

Leçon 3 • Intégration client de Socket.IO

Intègre le client Socket.IO dans un framework frontend, en gérant l'état de la connexion et les mises à jour de l'interface utilisateur. Les étudiants relient les événements serveur à des composants d'interface réactifs.

Leçon 4 • Salons, espaces de noms et diffusions ciblées

Enseigne la création de canaux de communication isolés à l'aide d'espaces de noms et de salons. Les étudiants implémentent des schémas de messagerie ciblée essentiels pour les applications multi-locataires.

Leçon 1 • Défis de l'état mutable partagé

Identifie les conditions de course, les lectures obsolètes et les écritures conflictuelles qui surviennent dans les systèmes concurrents en temps réel. Motive le besoin de schémas de gestion d'état disciplinés introduits ensuite.

Leçon 2 • Types de données répliquées sans conflit

Introduit les CRDT comme une approche mathématique pour fusionner des modifications concurrentes sans conflit. Les étudiants appliquent un compteur et un ensemble CRDT à une fonctionnalité de tableau blanc partagé.

Leçon 3 • Synchronisation d'état côté client

Couvre les techniques pour maintenir la cohérence de l'état client avec l'état serveur après des reconnexions et des événements manqués. Les étudiants implémentent des schémas de synchronisation delta et de récupération d'instantanés.

Leçon 1 • Limitation de débit et prévention des abus

Applique la limitation de débit, le limitation du nombre de connexions et la validation des charges utiles pour prévenir les attaques par déni de service et par injection. Les étudiants intègrent ces contrôles dans le serveur sécurisé.

Leçon 2 • Contrôle d'accès basé sur les rôles pour les événements

Étend l'authentification à l'autorisation par événement à l'aide de vérifications de rôles et de permissions. Les étudiants protègent les événements sensibles afin que seuls les rôles autorisés puissent les émettre ou les recevoir.

Leçon 3 • Fondamentaux de l'authentification basée sur les jetons

Passe en revue la structure, la signature et la vérification des JWT comme base pour l'authentification sans état en temps réel. Établit le vocabulaire et les mécaniques utilisés dans tout le chapitre.

Leçon 4 • Sécurisation des données en transit

Couvre la terminaison TLS, la gestion des certificats et la configuration WebSocket sécurisée (WSS). Garantit que tout le trafic temps réel est chiffré avant le déploiement.

Leçon 1 • Adaptateur Redis pour le clustering Socket.IO

Installe et configure l'adaptateur Redis de Socket.IO pour diffuser les événements sur toutes les instances du serveur. Les étudiants vérifient les diffusions inter-instances dans les salons dans une configuration multi-processus locale.

Leçon 2 • Intégration d'un courtier de messages

Introduit un courtier de messages dédié pour découpler les producteurs d'événements des consommateurs à grande échelle. Les étudiants publient des événements en temps réel via un courtier et les consomment dans les processus serveur.

Leçon 3 • Sessions persistantes et équilibrage de charge

Configure un proxy inverse avec prise en charge des sessions persistantes pour router les clients de manière cohérente vers la même instance de serveur. Les étudiants valident que l'appartenance aux salons persiste malgré le trafic équilibré.

Leçon 4 • Défis de passage à l'échelle propres aux WebSockets

Identifie pourquoi les connexions WebSocket avec état compliquent le passage à l'échelle horizontal par rapport aux HTTP sans état. Définit les problèmes que le reste du chapitre résout.

Leçon 1 • Notifications en temps réel et schémas de push

Implémente les notifications push initiées par le serveur pour les alertes, les flux et les fils d'activité. Les étudiants différencient les alertes en temps réel dans l'application de la livraison push externe.

Leçon 2 • Systèmes de présence et d'état d'activité

Construit un suivi de présence utilisateur qui montre qui est en ligne, inactif ou en train de modifier en temps réel. Les étudiants implémentent une présence basée sur des pulsations avec une détection gracieuse des déconnexions.

Leçon 3 • WebRTC pour la communication pair-à-pair

Introduit la signalisation WebRTC, la négociation ICE et les canaux de données pour les connexions directes entre pairs. Les étudiants construisent un serveur de signalisation et établissent un canal de données de navigateur à navigateur.

Leçon 4 • Transformation opérationnelle pour l'édition collaborative

Explique la théorie de la transformation opérationnelle et l'applique à l'édition de texte concurrente. Les étudiants construisent un éditeur de document partagé qui résout correctement les modifications simultanées.

Leçon 1 • Implémentation frontend et expérience utilisateur

Construit l'application cliente avec synchronisation d'état en temps réel, indicateurs de présence et support hors ligne. Les étudiants appliquent les schémas côté client des chapitres précédents à l'interface utilisateur du projet de fin d'études.

Leçon 2 • Implémentation backend et intégration

Construit le backend Node.js en temps réel, authentifié et évolutif, selon l'architecture planifiée. Les étudiants intègrent Redis, l'authentification et le routage des événements dans un serveur cohérent.

Leçon 3 • Déploiement et présentation du projet

Déploie le projet de fin d'études dans un environnement cloud avec des pipelines CI/CD et le présente aux pairs. Les étudiants démontrent des fonctionnalités en temps réel en direct et défendent leurs décisions architecturales.

Leçon 4 • Tests, surveillance et observabilité

Applique des tests unitaires, d'intégration et de charge au projet de fin d'études, puis ajoute la journalisation et les tableaux de bord de métriques. Les étudiants vérifient la fiabilité et les performances avant le déploiement.