Chapitre 1316 minIntermédiaire
Choisir l'architecture de ton projet E6
Par Josselyn C., prof de BTS SIO. Mis à jour le .
À la fin de ce chapitre, tu sauras
- choisir une architecture adaptée au besoin, à l'équipe et à l'épreuve ;
- vérifier qu'une réalisation couvre les situations de l'annexe II.E ;
- justifier tes choix d'architecture devant la commission ;
- repérer et corriger les erreurs d'architecture classiques.
4 exercices corrigés
Choisir une architecture, c'est partir du besoin (qui utilise l'application, où, avec quelles données et quelles règles) et des contraintes (taille de l'équipe, délais, compétences, exigences de l'épreuve) pour retenir l'organisation la plus simple qui y répond. Ce chapitre donne une méthode en cinq questions, l'applique à des réalisations d'E6, liste les questions que pose la commission sur l'architecture et les erreurs qui coûtent des points, puis termine par des cas corrigés et un aide-mémoire du cours.
La méthode en cinq questions
| Question | Ce qu'elle décide | Exemple pour ResaSalles |
|---|---|---|
| 1. Qui utilise l'application, et depuis où ? | Le ou les types de clients : navigateur, poste fixe, mobile | Salariés depuis leur poste ou en déplacement, accueil avec une imprimante de badges |
| 2. Quelles données, partagées par qui ? | Le tiers données, la nécessité d'un serveur | Salles et réservations partagées par 120 personnes : une base centrale |
| 3. Quelles règles de gestion ? | La couche service, et où elle s'exécute | Durée, capacité, chevauchement : sur le serveur, une seule fois |
| 4. Quels échanges avec l'extérieur ? | Les API à exposer ou à appeler, les systèmes externes | Annuaire de l'entreprise, messagerie |
| 5. Quelles contraintes ? | La complexité acceptable | Un binôme, six mois, l'heure de réalisation de l'E6, l'annexe II.E |
La réponse aux questions 1 et 4 détermine les tiers (chapitre 9) et les clients (chapitre 10). La réponse à la question 3 détermine les couches (chapitre 6). La question 5 rappelle qu'on choisit l'architecture la plus simple qui répond au besoin, pas la plus impressionnante.
Des besoins aux architectures
| Si le besoin est… | Architecture raisonnable |
|---|---|
| Une application web interne, quelques écrans, une seule interface | Application rendue par le serveur en MVC (PHP et PDO, ou Express et EJS), en couches |
| Une interface très interactive (planning, glisser-déposer), ou plusieurs clients prévus | SPA React + API Express, en couches |
| Un poste avec du matériel local (imprimante d'étiquettes, lecteur de cartes, balance) | Client lourd C# WinForms, de préférence branché sur une API |
| Des utilisateurs sur le terrain, avec appareil photo ou hors connexion | Application mobile + API |
| Des données échangées avec un partenaire ou un autre logiciel | Une API REST documentée (OpenAPI), ou des webhooks |
| Une tâche planifiée (rappels, imports nocturnes) | Un script ou une fonction planifiée qui appelle les mêmes services |
| Des dizaines d'équipes, des charges très différentes selon les fonctions | Microservices (hors de portée d'un projet de BTS) |
Deux réalisations complémentaires pour l'E6
L'environnement exigé à l'E6 SLAM demande, sur l'ensemble de tes réalisations, un cadre applicatif (framework), au moins deux langages, des appels à des services applicatifs distants et au moins trois des quatre situations d'exécution : poste fixe, navigateur, terminal mobile, serveur (les exigences détaillées). Deux réalisations bien choisies les couvrent :
| Réalisation 1 | Réalisation 2 | |
|---|---|---|
| Application | Application de bureau de l'accueil (badges, réservations pour les visiteurs) | Réservation de salles par les salariés |
| Architecture | Client lourd C# WinForms qui appelle l'API | SPA React + API Node.js et Express, en couches, base MySQL |
| Situations couvertes | Poste fixe | Navigateur, serveur |
| Service distant | Appel de l'API REST en HTTPS | L'API elle-même, appelée par le front |
| Langages | C# | JavaScript, SQL |
Le framework, c'est ici Express côté API (ou ASP.NET Core si ton API est en C#), et .NET avec WinForms côté poste de travail. Du PHP natif seul n'en fournit pas : si ta réalisation web est en PHP sans framework, l'autre doit en utiliser un.
Autre combinaison classique : une application web en PHP et PDO rendue par le serveur (serveur et navigateur, en client léger) et un client lourd C# qui appelle une petite API Express. L'important est de pouvoir montrer, schéma à l'appui, où s'exécute chaque partie de ton code.
Ton architecture pendant l'épreuve
L'E6 ne te demande pas de présenter ton projet : la commission rédige une expression des besoins sur l'une de tes deux réalisations, et tu dois la traiter (le déroulement de l'E6). Ton architecture intervient à trois moments.
- Dans le dossier. Les éléments techniques joints aux fiches descriptives montrent l'architecture de chaque réalisation : le diagramme de conteneurs avec technologies, versions et protocoles, le diagramme de déploiement (chapitre 12), l'arborescence commentée du code, couche par couche. La commission s'en sert pour écrire un besoin réaliste.
- À l'entretien de la phase 1. Tu présentes ton analyse du besoin, les spécifications techniques et la démarche envisagée. C'est le moment de situer l'évolution dans ton architecture : « la règle va dans
ReservationService.reserver, la colonne dans la tablesalle, l'affichage dans le composantReserverSalle», et de justifier les outils choisis. - Pendant la réalisation, la recette et l'entretien d'explicitation. L'architecture te sert de carte pour coder vite : la méthode « de la base vers l'écran » du chapitre 3 s'applique à toutes les piles (base, Repository, service, contrôleur et route, vue ou composant, test). Ensuite, tu racontes le trajet de ta modification à travers les couches et tu montres le test qui la prouve.
Pour t'y préparer, entraîne-toi sur chaque réalisation à décrire le trajet d'une fonctionnalité de bout en bout (« quand l'utilisateur clique sur Réserver, la requête arrive dans la route POST /api/reservations, le contrôleur la vérifie, le service applique les quatre règles, le Repository insère la ligne ») et à justifier deux ou trois choix avec leur alternative : pourquoi une API plutôt qu'une connexion directe, pourquoi une SPA plutôt que des pages rendues par le serveur.
Les questions de la commission sur l'architecture
| Question | Ce qu'on attend |
|---|---|
| « Quelle est l'architecture de ton application ? » | Le nombre de tiers et leurs technologies, puis l'organisation du code en couches, schéma à l'appui |
| « Où se trouvent les règles de gestion ? » | Un fichier et une méthode précis : ReservationService.reserver |
| « Pourquoi ne pas avoir mis le SQL dans le contrôleur ? » | Séparation des responsabilités, un seul endroit pour les requêtes préparées, testabilité, possibilité de changer de base |
| « Que se passe-t-il si on veut une application mobile ? » | Elle appelle la même API ; aucune règle n'est recopiée |
| « Comment testes-tu tes règles ? » | Tests unitaires du service avec de faux Repository, sans base (chapitre 7) |
| « Ton application est-elle sécurisée contre l'accès direct à la base ? » | La base n'accepte que les connexions du serveur d'application, avec un compte aux droits réduits ; les clients passent par l'API authentifiée |
| « Pourquoi pas des microservices ? » | Critères : équipe, charge, données liées ; un monolithe en couches suffit et reste plus simple (chapitre 11) |
Les erreurs d'architecture qui coûtent des points
| Erreur | Pourquoi c'est un problème | Correction |
|---|---|---|
| SQL dans les vues ou les formulaires | Injection possible partout, problème N+1, code impossible à relire | Tout le SQL dans les Repository ou les modèles |
| Règles de gestion dans le contrôleur ou le formulaire | Recopiées à chaque nouvelle interface, non testables | Une couche service |
| Règles vérifiées seulement dans le front | Contournables avec curl | Vérification dans l'API, le front n'est qu'un confort |
| Client lourd connecté directement à la base avec un compte administrateur | Identifiants sur chaque poste, droits illimités | Passer par une API, ou au minimum un compte aux droits réduits |
| Mot de passe de la base dans le code et dans Git | Fuite à la première publication du dépôt | Variables d'environnement, fichier de configuration exclu de Git |
| Un schéma « Front, Back, BDD » sans technologie ni protocole | La commission ne comprend pas l'application | Diagramme de conteneurs complet |
| Confondre MVC et 3 tiers | Montre une compréhension superficielle | Couches = code, tiers = exécution |
| Une architecture plus complexe que le besoin (microservices, Kubernetes) | Démarrage long, risque le jour de l'épreuve, choix difficile à justifier | La solution la plus simple qui répond au besoin |
Lire une architecture à l'écrit E7
L'écrit E7 de l'option SLAM ne te demande pas de concevoir une architecture, mais il te fait lire du code et des schémas d'applications réelles : un extrait de contrôleur, une classe d'accès aux données, une requête, un diagramme. Savoir dans quelle couche chercher fait gagner du temps :
- un contrôle d'accès manquant (un utilisateur qui modifie la fiche d'un autre) se cherche dans le contrôleur, un middleware ou le service ;
- une injection SQL se cherche dans la couche d'accès aux données, là où une valeur est concaténée dans une requête ;
- une faille XSS se cherche dans la vue, là où une donnée est affichée sans échappement ;
- une fuite de données dans une API se cherche dans ce que le contrôleur renvoie (un objet complet au lieu d'un DTO).
Le cours Épreuve E7 SLAM détaille ces questions.
Cas corrigés
Exercice 1 sur 4 Cas 1 : proposer une architecture Réussi À revoir
Un club de handball de 300 licenciés veut une application pour gérer les inscriptions des joueurs aux matchs du week-end. Les entraîneurs composent les équipes depuis un ordinateur ; les joueurs indiquent leur disponibilité depuis leur téléphone, souvent dans les vestiaires ; le trésorier exporte chaque mois les présences vers un tableur. L'application est développée par un binôme d'étudiants de BTS SIO.
- Propose une architecture (tiers, clients, organisation du code) et justifie-la.
- Combien de situations d'exécution de l'annexe II.E couvre-t-elle ?
- Où places-tu la règle « un joueur ne peut pas être sélectionné dans deux équipes le même jour » ?
Voir la réponseMasquer la réponse de l'exercice 1
- Une API REST (Node.js et Express, ou PHP) en couches, avec une base MySQL : elle porte les règles et les données partagées par tous. Deux clients : une interface web pour les entraîneurs (SPA React, ou pages rendues par le serveur), et une application mobile (ou une interface web adaptée au téléphone) pour les joueurs. L'export du trésorier est une route de l'API qui renvoie un fichier CSV. Un monolithe suffit : un binôme, une charge modeste, des données liées (joueurs, équipes, matchs).
- Avec une SPA et une application mobile : navigateur, terminal mobile et serveur, soit trois situations, plus l'appel de l'API comme service distant. Avec une simple interface web adaptée au téléphone au lieu d'une application mobile, le code ne s'exécute plus sur le terminal mobile : il reste navigateur et serveur.
- Dans la couche service de l'API (
SelectionService.selectionner), qui interroge le Repository pour savoir si le joueur est déjà sélectionné ce jour-là. Pas dans l'interface des entraîneurs : la règle doit tenir quel que soit le client.
Tu avais trouvé ?
Exercice 2 sur 4 Cas 2 : critiquer une architecture Réussi À revoir
Voici la description de la réalisation d'une étudiante : « GestStock est une application WinForms installée sur les 12 postes du magasin. Elle se connecte au serveur MySQL avec le compte root, dont le mot de passe est dans le fichier App.config. Chaque formulaire contient ses requêtes SQL. Le calcul du prix de vente (prix d'achat, marge, remise selon la catégorie de client) est fait dans le formulaire de vente et dans le formulaire de devis. »
Relève les problèmes d'architecture et de sécurité, et propose une architecture cible.
Voir la réponseMasquer la réponse de l'exercice 2
Problèmes :
- Compte root : chaque poste a tous les droits sur le serveur MySQL, y compris supprimer les bases ou créer des comptes.
- Mot de passe dans
App.config, lisible sur les 12 postes et sans doute versionné dans Git. - Architecture 2 tiers : le port 3306 est ouvert à tout le magasin, n'importe quel outil peut interroger la base en contournant l'application.
- SQL dans les formulaires : aucune séparation, risque d'injection à vérifier partout, requêtes recopiées.
- Règle de prix recopiée dans deux formulaires : une modification de la remise risque de n'être faite qu'à un endroit, et les devis ne correspondront plus aux ventes.
Architecture cible :
- À court terme, sans tout réécrire : un compte MySQL dédié aux droits réduits, des DAO ou Repository qui regroupent le SQL, une classe
PrixServiceutilisée par les deux formulaires, des formulaires qui ne contiennent plus que l'affichage. - À moyen terme : une API (ASP.NET Core ou Express) qui porte les services et l'accès aux données ; l'application WinForms l'appelle en HTTPS ; MySQL n'accepte plus que les connexions du serveur de l'API.
Tu avais trouvé ?
Exercice 3 sur 4 Cas 3 : situer une évolution Réussi À revoir
L'expression des besoins de ton E6 demande d'ajouter à ResaSalles (version SPA + API) la règle : « une salle équipée pour la visioconférence ne peut pas être réservée pour moins de 3 participants ». Elle demande aussi d'afficher une icône de caméra à côté des salles équipées dans la liste déroulante. Liste les fichiers à modifier, dans l'ordre, et le test à écrire.
Voir la réponseMasquer la réponse de l'exercice 3
- Base et Repository : rien à modifier,
SalleRepository.trouverParIdrenvoie déjà la colonnevisio. Vérifie-le en lisant la requête. - Service (
reservation.service.js) : après la vérification de capacité,if (salle.visio && participants < 3) throw new ErreurMetier('Une salle de visioconférence se réserve pour 3 personnes au moins');. - Contrôleur et route : rien, l'
ErreurMetierest déjà traduite en422par le gestionnaire d'erreurs. - Front : dans
ReserverSalle.jsx, ajouter l'icône dans le texte de l'option quands.visioest vrai. La liste des salles renvoyée parGET /api/sallesdoit contenirvisio; si ce n'est pas le cas, ajouter la colonne dans la requête du Repository et dans la réponse du contrôleur. - Test : dans
reservation.service.test.js, un fauxsalleRepositoryqui renvoie une salle avecvisio: 1et une demande de 2 participants doit être refusée (statut: 422) ; une demande de 3 participants doit passer.
C'est la démonstration attendue : la règle est à un seul endroit, le reste de l'application n'a presque pas bougé, et un test prouve qu'elle fonctionne.
Tu avais trouvé ?
Exercice 4 sur 4 Cas 4 : QCM de synthèse Réussi À revoir
Une seule bonne réponse par question.
- Une application Express organisée en routes, contrôleurs, services et Repository, qui interroge MySQL, est : a) une architecture en couches ; b) une architecture en microservices ; c) une architecture 1 tiers ; d) une application serverless.
- L'injection de dépendances consiste à : a) injecter du SQL dans une requête ; b) fournir à une classe les objets dont elle a besoin au lieu qu'elle les crée ; c) installer les dépendances avec npm ; d) ajouter des dépendances entre les tables.
- Dans le modèle C4, un « conteneur » est : a) un conteneur Docker ; b) une classe ; c) un programme ou un stockage qui s'exécute séparément ; d) un serveur physique.
- Le principal risque d'un client lourd connecté directement à la base est : a) la lenteur de l'interface ; b) la présence des identifiants de la base sur chaque poste ; c) l'impossibilité d'utiliser des requêtes préparées ; d) l'absence de MVC.
Voir la réponseMasquer la réponse de l'exercice 4
- a) Une architecture en couches (et 3 tiers si l'on compte le navigateur, le serveur Node.js et MySQL).
- b) Le plus souvent par le constructeur.
- c) Une application web, une API, une application de bureau ou mobile, une base de données.
- b) N'importe quel utilisateur peut récupérer les identifiants et contourner les règles de l'application.
Tu avais trouvé ?
Aide-mémoire du cours
| Notion | En une phrase | Chapitre |
|---|---|---|
| Séparation des responsabilités | Chaque partie du code s'occupe d'un seul sujet | 1 |
| Couplage faible, cohésion forte | Des parties qui dépendent peu les unes des autres, et dont le contenu sert un même but | 1 |
| MVC | Le modèle gère données et règles, la vue affiche, le contrôleur reçoit l'action et coordonne | 2 |
| Contrôleur frontal | Le point d'entrée unique qui reçoit toutes les requêtes et les aiguille | 3 |
| Post/Redirect/Get | Après un POST réussi, rediriger vers une page en GET | 2 |
| MVP, MVVM | Variantes : vue passive pilotée par un présentateur ; vue liée à un ViewModel | 2 |
| Architecture en couches | Présentation, service (métier), accès aux données ; les appels descendent | 6 |
| Contrôleur mince | Il lit la requête, appelle le service, répond ; aucune règle de gestion | 6 |
| DAO, Repository | Des classes qui regroupent l'accès aux données, par table ou par objet métier | 7 |
| Injection de dépendances | Fournir à une classe ses dépendances, le plus souvent par le constructeur | 7 |
| Racine de composition | Le seul endroit qui crée et branche toutes les pièces | 7 |
| Architecture hexagonale | Le métier au centre, des ports (interfaces) et des adaptateurs (technologies) | 8 |
| 2 tiers, 3 tiers, n-tiers | Le nombre de niveaux d'exécution qui communiquent par le réseau | 9 |
| Client léger, riche, lourd | Pages du serveur ; application JavaScript dans le navigateur ; application installée | 9 |
| SPA + API | Un front qui s'exécute dans le navigateur et appelle une API en JSON | 10 |
| Monolithe, microservices, serverless | Un bloc déployé d'un coup ; des services indépendants ; des fonctions exécutées à la demande | 11 |
| Modèle C4 | Quatre niveaux de zoom : contexte, conteneurs, composants, code | 12 |
| ADR | Une décision d'architecture, son contexte et ses conséquences, dans un court fichier versionné | 12 |