Chapitre 17 : Exercices Pratiques

Introduction

Ce chapitre propose 40 exercices progressifs pour maîtriser le développement backend moderne. Chaque exercice est conçu pour renforcer un concept spécifique et s'appuie sur les chapitres précédents.

---

Niveau Débutant (Exercices 01-10)

Exercice 01 : Hello World API

Objectif : Créer un serveur Express basique avec une route GET /hello.

Contraintes :

• Retourner un JSON { "message": "Hello World", "timestamp": <current_time> }
• Utiliser TypeScript strict
• Ajouter un middleware de logging des requêtes

Livrables :

• src/exercises/01-hello-world.ts
• Tests avec Supertest

Exercice 02 : CRUD Utilisateur basique

Objectif : Implémenter un CRUD complet pour une entité User en mémoire.

Routes :

• POST /api/users — Créer un utilisateur
• GET /api/users — Lister tous les utilisateurs
• GET /api/users/:id — Obtenir un utilisateur
• PUT /api/users/:id — Mettre à jour un utilisateur
• DELETE /api/users/:id — Supprimer un utilisateur

Validation : name (string, required), email (email valide)

Exercice 03 : Validation avec Joi/Zod

Objectif : Ajouter une validation robuste avec Zod.

Schémas :

• User : name (3-50 chars), email (email valide), age (18-120)
• Product : name, price (>0), category (enum)
• Order : userId, products[], total (>0)

Comportement : Retourner 400 avec les erreurs détaillées

Exercice 04 : Middleware personnalisé

Objectif : Créer des middlewares réutilisables.

• requestLogger : Log méthode, URL, durée
• errorHandler : Catch global des erreurs
• rateLimiter : Limiter à 100 req/min par IP
• requestValidator : Valider body/params/query

Exercice 05 : Routes paramétrées

Objectif : Créer des routes avec paramètres et query strings.

• GET /api/products?category=X&minPrice=Y&maxPrice=Z&page=1&limit=10
• GET /api/products/:id/reviews
• POST /api/products/:id/reviews
• Support pagination, tri, filtres

Exercice 06 : Gestion d'erreurs HTTP

Objectif : Créer une classe d'erreur personnalisée.

• AppError avec statusCode, message, code, details
• NotFoundError, ValidationError, UnauthorizedError, ForbiddenError
• Middleware de traitement centralisé
• Format de réponse : { error: { code, message, details } }

Exercice 07 : Environnements et configuration

Objectif : Gérer la configuration multi-environnement.

• .env par environnement (dev, staging, prod)
• Validation des variables d'environnement
• Typage strict de la configuration
• Valeurs par défaut intelligentes

Exercice 08 : Logging structuré

Objectif : Mettre en place un système de logging.

• Utiliser Pino ou Winston
• Logs structurés JSON
• Niveaux : debug, info, warn, error, fatal
• Rotation des logs et rétention
• Correlation ID par requête

Exercice 09 : Upload de fichiers

Objectif : Gérer l'upload de fichiers.

• Upload simple avec multer
• Validation du type et taille (max 5MB)
• Stockage local et cloud (presigned URL S3)
• Compression d'images avec Sharp

Exercice 10 : Sérialisation et DTO

Objectif : Implémenter des DTOs pour la sérialisation.

• UserResponse sans mot de passe
• PaginatedResponse avec métadonnées
• Mapping automatique entité → DTO
• Exclure les champs sensibles

---

Niveau Intermédiaire (Exercices 11-20)

Exercice 11 : PostgreSQL avec TypeORM

Objectif : Connecter PostgreSQL avec TypeORM.

• Configuration de l'entité User
• Migrations automatiques
• CRUD avec TypeORM Repository
• Relations OneToMany/ManyToOne

Exercice 12 : Authentification JWT

Objectif : Implémenter l'authentification JWT.

• Register avec hash bcrypt
• Login avec génération JWT (access + refresh)
• Middleware de vérification JWT
• Refresh token rotation
• Blacklist des tokens révoqués

Exercice 13 : Cache Redis

Objectif : Mettre en cache les requêtes fréquentes.

• Cache middleware pour GET
• TTL configurable par route
• Invalidation sur POST/PUT/DELETE
• Cache stampede protection
• Pattern cache-aside

Exercice 14 : Pagination avancée

Objectif : Pagination avec cursor et offset.

• Pagination offset (page/limit)
• Pagination cursor (keyset)
• Pagination pour les relations
• Métadonnées : total, hasMore, cursors

Exercice 15 : Recherche full-text

Objectif : Implémenter la recherche avec PostgreSQL.

• Index GIN pour full-text search
• Ranking et highlight
• Filtres combinés (texte + catégorie + prix)
• Pagination des résultats

Exercice 16 : Rate limiting distribué

Objectif : Rate limiting avec Redis.

• Sliding window avec Redis
• Limites par utilisateur et par IP
• Headers RateLimit-*
• Réponse 429 avec Retry-After
• Quotas différenciés (gratuit/premium)

Exercice 17 : Import/Export CSV

Objectif : Importer et exporter des données en CSV.

• Parse CSV avec validation
• Export stream avec backpressure
• Import batch avec transactions
• Rapport d'erreurs d'import
• Gestion des fichiers volumineux

Exercice 18 : WebSockets

Objectif : Mettre en place des WebSockets.

• Connexion avec Socket.io
• Rooms et namespaces
• Événements personnalisés
• Authentification WebSocket
• Broadcast et unicast

Exercice 19 : Tests d'intégration

Objectif : Tester l'API complète.

• Test container PostgreSQL
• Fixtures et factories
• Tests des endpoints CRUD
• Tests d'authentification
• Tests de cache
• Coverage > 80%

Exercice 20 : Documentation Swagger

Objectif : Documenter l'API avec OpenAPI/Swagger.

• Définitions des schémas
• Documentation des endpoints
• Exemples de requêtes/réponses
• Groupes de tags
• UI Swagger accessible

---

Niveau Avancé (Exercices 21-30)

Exercice 21 : Queue BullMQ

Objectif : Traitement asynchrone avec BullMQ.

• File d'attente avec Redis
• Jobs planifiés et récurrents
• Retry avec backoff exponentiel
• Workers parallèles
• Dashboard Bull Board

Exercice 22 : Kafka Producer/Consumer

Objectif : Messaging avec Kafka.

• Producer avec clé de partition
• Consumer group avec offset commit
• Topics avec réplication
• Schema Registry avec Avro
• Idempotent producer

Exercice 23 : API Gateway

Objectif : Créer une API Gateway.

• Reverse proxy avec http-proxy
• Rate limiting par service
• Authentification centralisée
• Circuit breaker
• Agrégation de réponses

Exercice 24 : Cache invalidation pattern

Objectif : Stratégies d'invalidation de cache.

• Write-through cache
• Write-behind cache
• Cache-aside avec invalidation
• Pub/sub pour invalidation distribuée
• Cache warming

Exercice 25 : Transactions distribuées

Objectif : Gérer les transactions distribuées.

• Saga pattern (choreography)
• Saga pattern (orchestration)
• Outbox pattern
• Compensation handlers
• Idempotency keys

Exercice 26 : Docker multi-stage

Objectif : Optimiser les images Docker.

• Multi-stage build
• Image alpine minimale
• Layer caching
• Security scanning
• Healthcheck

Exercice 27 : CI/CD Pipeline

Objectif : Mettre en place une CI/CD complète.

• GitHub Actions workflow
• Lint, typecheck, test
• Build et push Docker
• Déploiement staging/prod
• Tests de non-régression

Exercice 28 : Monitoring et métriques

Objectif : Monitoring avec Prometheus et Grafana.

• Métriques Prometheus (http_requests_total, etc.)
• Health check endpoints
• Structured logging
• Tracing distribué avec OpenTelemetry
• Dashboard Grafana

Exercice 29 : Graceful Shutdown

Objectif : Arrêt gracieux du serveur.

• Capture SIGTERM/SIGINT
• Drain des connexions actives
• Attente des workers en cours
• Fermeture des connexions DB/Redis/Kafka
• Timeout de shutdown forcé

Exercice 30 : Feature Flags

Objectif : Feature flags dynamiques.

• Flags stockés en base
• Middleware de feature flag
• A/B testing support
• Rollout progressif (% utilisateurs)
• Cache des flags avec invalidation

---

Niveau Expert (Exercices 31-40)

Exercice 31 : Kubernetes Deployment

Objectif : Déployer sur Kubernetes.

• Deployment avec rolling update
• Service ClusterIP et LoadBalancer
• ConfigMap et Secrets
• Horizontal Pod Autoscaler
• Probes (liveness, readiness, startup)

Exercice 32 : Helm Chart

Objectif : Créer un chart Helm.

• Template valeurs paramétrées
• Dependencies (PostgreSQL, Redis)
• Hooks pre/post install
• Tests Helm
• Repository de charts

Exercice 33 : Terraform Infrastructure

Objectif : Infrastructure as Code avec Terraform.

• Provider AWS/GCP/Azure
• Modules réutilisables
• Remote state avec locking
• Workspaces (dev/staging/prod)
• Terraform plan/apply automatisé

Exercice 34 : Service Mesh

Objectif : Service mesh avec Istio.

• Sidecar injection
• Traffic management
• mTLS entre services
• Circuit breaking
• Canary deployments

Exercice 35 : Base de données sharding

Objectif : Sharding distribué.

• Sharding par hash de clé
• Routage des requêtes
• Rebalance des shards
• Backup cohérent
• Requêtes cross-shard

Exercice 36 : Event Sourcing

Objectif : Architecture event sourcing.

• Event store avec PostgreSQL
• Projections et read models
• Snapshots pour performance
• CQRS pattern
• Event versioning

Exercice 37 : API GraphQL

Objectif : Implémenter une API GraphQL.

• Schéma GraphQL
• Resolvers avec DataLoader
• Subscriptions WebSocket
• Federation Gateway
• Rate limiting par requête

Exercice 38 : gRPC Service

Objectif : Services avec gRPC.

• Définition protobuf
• Unary et streaming RPC
• Interceptors (auth, logging)
• Load balancing
• Health checking

Exercice 39 : Chaos Engineering

Objectif : Tests de résilience.

• Chaos Monkey avec Gremlin/Litmus
• Fault injection (latence, crash)
• Network partition testing
• Recovery validation
• Runbook automation

Exercice 40 : Plateforme complète

Objectif : Assembler tous les concepts.

• Architecture microservices complète
• CI/CD avec déploiement canary
• Monitoring et alerting
• Auto-scaling et auto-healing
• Documentation et runbooks

---

Barème et Notation

Critères d'évaluation (par exercice)

Grille de notation

Conseils

1. Lisez attentivement l'énoncé avant de coder
2. Commencez par les tests pour clarifier le contrat
3. Utilisez les patterns vus dans les chapitres précédents
4. Soyez attentif aux edge cases
5. Commentez vos choix architecturaux
6. Versionnez chaque exercice dans un commit séparé
7. N'hésitez pas à consulter les corrigés (Chapitre 19)