À retenir
- Une architecture modulaire découpe l'application en blocs aux responsabilités et aux frontières clairement définies.
- Pour la plupart des PME, le monolithe modulaire offre la modularité sans la complexité d'exploitation des microservices.
- Le bon découpage se juge à la maintenance : une évolution ne doit toucher qu'un module.
Qu'est-ce qu'une architecture modulaire en développement web ?
L'architecture modulaire consiste à organiser une application web en modules, chacun chargé d'un domaine précis et exposant aux autres une interface limitée. Dans une application de gestion commerciale, on trouvera par exemple un module pour le catalogue, un autre pour les clients, un troisième pour les commandes et un dernier pour la facturation. Chaque module détient ses règles et ses données, et les autres ne s'en servent qu'à travers les fonctions qu'il met à disposition.
Deux principes guident ce découpage. Le premier est la cohésion : ce qui change pour les mêmes raisons doit se trouver au même endroit. Le second est le faible couplage : un module doit dépendre le moins possible du fonctionnement interne des autres. Lorsque ces deux principes sont respectés, modifier le calcul des remises ne demande d'intervenir que dans le module des commandes, sans risque de casser l'espace client ou les exports comptables.
La modularité n'est donc pas une question de nombre de fichiers ni de technologie. Une application peut être répartie en centaines de fichiers et rester un enchevêtrement où tout dépend de tout, tandis qu'une autre, plus compacte, sera parfaitement découpée. C'est la clarté des frontières entre les domaines qui fait une bonne architecture web, et c'est elle qui conditionne le coût de chaque évolution future.
Monolithe, monolithe modulaire et microservices : trois façons d'organiser une application
Le débat sur l'architecture modulaire est souvent présenté comme un choix entre le monolithe et les microservices. En pratique, trois organisations se distinguent, et la plus utile aux PME est souvent celle dont on parle le moins.
Le monolithe désigne une application déployée d'un seul bloc, avec une base de code et en général une base de données uniques. Ce n'est pas un défaut en soi : un monolithe est simple à déployer, à héberger et à surveiller. Il devient un frein lorsque son code n'a pas de frontières internes et que chaque modification produit des effets inattendus ailleurs.
Le monolithe modulaire conserve un déploiement unique, mais impose à l'intérieur des modules nettement séparés, qui ne communiquent que par des interfaces définies. Il réunit la simplicité d'exploitation du monolithe et la lisibilité d'une architecture découpée. Les microservices, enfin, séparent chaque domaine en un service indépendant, déployé à part, doté de sa propre base de données et dialoguant avec les autres par le réseau. Cette indépendance a un prix : supervision, gestion des pannes partielles, cohérence des données entre services et automatisation des déploiements deviennent des sujets à part entière.
Le tableau ci-dessous compare ces trois approches sur les critères qui comptent pour une entreprise.
| Critère | Monolithe sans découpage | Monolithe modulaire | Microservices |
|---|---|---|---|
| Déploiement | Un seul bloc | Un seul bloc | Un déploiement par service |
| Base de données | Partagée sans règles | Partagée, données rattachées à un module | Une base par service |
| Exploitation | Simple | Simple | Complexe : réseau, supervision, pannes partielles |
| Coût d'une évolution | Croissant avec le temps | Maîtrisé | Maîtrisé par service, élevé pour les évolutions transverses |
| Équipe adaptée | Projet très réduit | Une équipe, PME, outil métier | Plusieurs équipes autonomes |
Le monolithe modulaire a un autre avantage : il prépare le terrain. Si un module doit un jour être isolé, par exemple parce qu'il subit une charge très différente du reste, ses frontières sont déjà tracées et son extraction en service indépendant devient un chantier circonscrit.
Ce que la modularité change pour la maintenance
Le bénéfice d'une architecture modulaire se mesure surtout après la mise en ligne, lorsque l'application doit évoluer au rythme de l'entreprise. Une demande métier se traduit alors par une intervention localisée : on sait où se trouve le code concerné, on peut le tester isolément et on limite le risque de régression sur les autres fonctions.
La modularité facilite également les tests automatisés, puisque chaque module peut être vérifié avec ses propres scénarios, ainsi que l'arrivée d'un nouveau développeur, qui peut comprendre un domaine sans devoir assimiler l'ensemble de l'application. Elle permet enfin de remplacer une brique devenue obsolète, comme un module de paiement ou de génération de documents, sans réécrire le reste du logiciel.
Elle se combine naturellement avec l'organisation en couches. Le découpage par domaines indique quoi ranger ensemble, tandis que le modèle MVC appliqué côté serveur sépare, à l'intérieur de chaque module, les données, la logique et l'affichage. Les deux approches répondent à des questions différentes et se renforcent l'une l'autre.
Comment choisir l'architecture de votre application
Le choix d'une architecture ne se fait pas sur des critères de mode. Il dépend de la taille de l'équipe qui maintiendra l'outil, des contraintes de charge et du budget d'exploitation que l'entreprise accepte d'y consacrer. Les questions suivantes permettent de trancher dans la plupart des projets de PME.
- Combien de personnes feront évoluer l'application ? Les microservices répondent d'abord à un problème d'organisation entre plusieurs équipes autonomes. Avec une seule équipe ou un prestataire unique, ils ajoutent de la coordination sans contrepartie.
- Certaines fonctions subissent-elles une charge très différente ? Si un module doit absorber des pics bien supérieurs au reste, comme un moteur de recherche public ou un traitement de fichiers volumineux, l'isoler peut se justifier. Sinon, un déploiement unique suffit.
- Quel budget d'exploitation est acceptable ? Chaque service indépendant demande son hébergement, sa supervision et ses déploiements. Ce coût récurrent doit être comparé au bénéfice réel attendu.
- Quels systèmes faut-il connecter ? ERP, CRM, comptabilité ou outils de signature électronique : chaque intégration mérite un module dédié, afin qu'un changement chez un éditeur tiers reste confiné à un seul endroit du code.
- Comment l'outil va-t-il évoluer ? Une application appelée à s'enrichir pendant des années gagne à être découpée dès le départ, même si sa première version est modeste.
Pour la grande majorité des outils métier, intranets et extranets de PME, ces questions conduisent au même résultat : un monolithe modulaire bien structuré, déployé simplement, dont les frontières internes permettront d'isoler un service plus tard si le besoin apparaît.
Exemple en PHP : séparer les responsabilités d'un module utilisateur
L'exemple suivant, volontairement simple, montre comment un module de gestion des utilisateurs répartit ses responsabilités entre trois classes. La première représente les données, la deuxième se charge de leur enregistrement et la troisième porte la logique applicative.
Fichier : CodyUser.php
<?php
class User {
private $username;
private $email;
public function __construct($username, $email) {
$this->username = $username;
$this->email = $email;
}
public function getUsername() {
return $this->username;
}
public function getEmail() {
return $this->email;
}
}
?>
Fichier : CodyUserRepository.php
<?php
include 'CodyUser.php';
class UserRepository {
public function registerUser($username, $email) {
// Ici, vous pourriez intégrer une logique de vérification ou d'enregistrement dans une base de données
return new User($username, $email);
}
}
?>
Fichier : CodyUserService.php
<?php
include 'CodyUserRepository.php';
class UserService {
private $userRepository;
public function __construct(UserRepository $userRepository) {
$this->userRepository = $userRepository;
}
public function displayUserDetails($username, $email) {
$user = $this->userRepository->registerUser($username, $email);
echo "Username: " . $user->getUsername() . "\n";
echo "Email: " . $user->getEmail() . "\n";
}
}
?>
Fichier : index.php
<?php
include 'CodyUserService.php';
$userRepository = new UserRepository();
$userService = new UserService($userRepository);
$userService->displayUserDetails("john_doe", "john@example.com");
?>
Chaque classe a une responsabilité unique. Le service reçoit le dépôt de données par son constructeur, ce qu'on appelle l'injection de dépendances : il ignore donc comment les utilisateurs sont enregistrés. Pour passer d'un simple objet en mémoire à une base de données, il suffit de modifier CodyUserRepository.php, par exemple avec une requête PDO préparée, sans toucher au service ni à la page qui l'appelle.
Le même principe guide les évolutions suivantes. Une validation des adresses e-mail trouve sa place dans le service ou dans une classe dédiée, avant l'appel au dépôt. Côté sécurité, les entrées doivent être validées et nettoyées, les requêtes préparées pour prévenir les injections SQL, et les mots de passe stockés avec une fonction de hachage adaptée. Dans une application réelle, ces classes s'inscrivent dans un module plus large, avec ses propres tests et ses propres règles d'accès.
Architecture modulaire et sobriété numérique
La modularité rejoint les principes de sobriété sur deux points précis. Elle permet d'abord de ne charger et de n'exécuter que ce dont chaque page a besoin, au lieu d'embarquer l'ensemble des fonctions à chaque requête. Elle favorise ensuite la réutilisation : un module bien conçu sert plusieurs écrans sans que son code soit dupliqué, ce qui réduit la quantité de code à maintenir.
Son apport le plus important tient pourtant à la durée de vie du logiciel. Une application dont les briques peuvent être mises à jour ou remplacées une à une évite la refonte complète, qui mobilise des mois de développement et de ressources. Cette logique rejoint celle du logiciel léger, conçu pour l'usage réel plutôt que pour une liste de fonctionnalités : un outil limité à ce qui sert, découpé proprement, reste plus simple et moins coûteux à faire vivre.
Concevoir l'architecture de votre outil métier
L'architecture se décide au début du projet, au moment où elle coûte le moins cher à bien faire. Chez Codyweb, nous développons en PHP natif des outils métier, intranets et extranets sur mesure dont le découpage suit les domaines de l'entreprise, afin que chaque évolution reste localisée et que le code demeure lisible par d'autres développeurs que ses auteurs. Notre expertise en développement web sur mesure repose sur ce principe : un code dont l'entreprise garde la maîtrise.
- vote(s)