Le programme de la formation

Cette formation propose une démarche pour concevoir des applications maintenables, résilientes et performantes. Elle aborde les principes d’architecture applicative sous un angle opérationnel, en mettant en relation les choix techniques, les objectifs métiers et l’organisation des équipes. Chaque module s’appuie sur des cas d’usage complets, avec une application démo développée au fil des étapes, en environnement Java ou .NET.

Introduction : une architecture orientée qualité

Une architecture logicielle efficace repose sur des critères de qualité clairement définis, tels que la maintenabilité, la testabilité, la résilience ou la performance. Ce module pose les fondations de l’architecture orientée qualité, en introduisant les paradigmes de développement, le rôle des objectifs partagés entre parties prenantes, et l’importance d’un vocabulaire commun (ubiquitous language) pour structurer les échanges.

• Définition des objectifs: maintenabilité, testabilité, résiliance, performances....

• Le principe du langage commun (ubiquitous language) pour éviter les malentendus.

• Les paradigmes: objet, fonctionnel, déclaratif.

• Différents types d'applications : I/O bounded, CPU bounded.

• Le paysage IT : les écosystèmes les plus répandus.

Structurer le code : des patterns pour réduire la dette technique

Le découpage du code a un impact direct sur la dette technique d’un projet. Ce module examine les principes de séparation des responsabilités et les patterns de conception (design patterns) essentiels à une architecture modulable et durable. Il s’appuie sur les apports des frameworks et bibliothèques (librairies), dans une logique de standardisation du développement.

• La séparation des responsabilités.

• Les design patterns essentiels.

• La préférence pour les applications stateless.

• L'apport des frameworks (cadriciels) et librairies.

• Les tests pour garanti

Application Monolithe vs Microservices : choisir en toute connaissance de cause

Chaque projet impose ses contraintes propres : complexité métier, exigences de déploiement, organisation des équipes. Ce module propose une méthode d’analyse des contextes métier (bounded contexts) et des dépendances fonctionnelles pour guider le choix entre architecture monolithique et approche microservices. Il explore également les modèles d’intégration possibles à travers la cartographie des contextes (Context Mapping).

• La délimitation des contextes métiers (bounded context).

• Les avantages et inconvénients respectifs des applications monolithiques et des architectures microservices.

• La cartographie des contextes (Context Mapping) pour identifier les dépendances et guider le choix des paterns d’intégration.

Gérer les données : SQL, NoSQL et au-delà

Le choix entre bases de données relationnelles (SQL) et non relationnelles (NoSQL) doit tenir compte des enjeux de cohérence, de disponibilité et de tolérance aux pannes, selon le théorème CAP. Ce module examine les approches d’accès aux données, les principes des transactions (ACID), ainsi que la structuration de la couche de persistance, en lien avec la performance et la scalabilité/évolutivité.

• Différents types de bases de données (Sql, NoSql) pour différents besoins.

• Le théorème CAP.

• L'apport d'un pool de connexions.

• L'accès aux données : bloquant ou non bloquant.

• Les transactions et les principes ACID.

• La couche de persistance.

Les messages : intégrer des services de manière asynchrone

Dans des architectures distribuées, les systèmes de messagerie offrent un mécanisme fiable pour orchestrer les échanges entre services. Ce module présente les modèles d’échange asynchrones basés sur la publication et l’abonnement (publish/subscribe), les approches push/pull, ainsi que des outils comme RabbitMQ ou Kafka.

• Principes et cas d'usages.

• Les mécanismes de réception des messages: push ou pull.

• Définition des besoins.

• Présentation de RabbitMQ et de Kafka.

Concevoir des APIs résilientes

Les interfaces de programmation d’applications (API) sont un vecteur central de communication entre composants logiciels. Ce module explore des modèles alternatifs (REST, GraphQL, gRPC) en fonction des objectifs de flexibilité, de performance ou de limitation de charge (overfetching). Il examine également les protocoles utilisés pour les échanges temps réel, comme WebSocket ou STOMP.

• SOAP ou gRpc pour exposer des opérations (RPC) et des communications inter-services ultra-rapides

• REST pour exposer des ressources.

• GraphQL comme alternative à REST, permettre des requêtes sur-mesure et éviter la limitation de charge (overfetching)

• Publish / suscribe avec WebSocket et STOMP.

Sécurité : protéger sans complexifier

Garantir la sécurité d’une application sans nuire à l’expérience utilisateur nécessite des arbitrages réfléchis. Ce module présente les principes de sécurisation des applications côté client ou côté serveur, les mécanismes d’authentification par session, cookie ou jeton (JWT – JSON Web Token), ainsi que les recommandations issues des bonnes pratiques OWASP.

• Quelques bonnes pratiques ergonomiques.

• Quelques bonnes pratiques d’éco-conception.

• Les formulaires.

• Server side rendering ou client side rendering.

• Réalisation d’IHM côté serveur.

• Les single page applications pour le développement côté client.

• La sécurité : par session, par cookie ou par jeton JWT.

Standardiser la livraison avec le déploiement continu

Ce module clôt la formation en abordant l’automatisation des déploiements (CI/CD), la conteneurisation avec Docker, et le pilotage via Kubernetes. Il introduit également des approches comme le serverless (fonction sans serveur), les méthodes de compilation (JIT, AOT), ainsi que les principes de la méthodologie des “15 Factors” pour des applications cloud-native.

• Les modes de compilation : JIT ou AOT.

• La méthodologie "15 factors".

• La conteneurisation: création d'image OCI, livraison sur Kubernetes.

• Le serverless (sans serveur) et le déploiement de fonctions.