Garder un module autonome : repérer les dépendances qui compliquent les changements
Un module perd son autonomie quand ses règles et ses données se dispersent. Voici les signes à examiner et les moyens de garder des frontières compréhensibles.
Article
Une application peut se déployer en un bloc et garder des modules distincts. Exemple avec l’inscription et la facturation, leurs données et leurs échanges.
Vous ajoutez à l’inscription une case de consentement à la lettre d’information, et la facturation doit changer elle aussi. Aucune facture ne dépend pourtant de ce consentement. Une cause fréquente est une grande classe Client partagée par toute l’application : identité, connexion, consentements et règles de paiement y vivent ensemble, et la facturation l’importe en entier. Elle dépend alors d’informations dont elle n’a pas besoin. Il suffit, par exemple, que le consentement devienne un paramètre obligatoire du constructeur de Client : chaque endroit de la facturation qui fabrique un Client, à commencer par ses tests, doit changer.
Un monolithe modulaire traite ce problème sans créer de service séparé. L’application reste déployée en un seul bloc, mais elle est découpée en modules. Chacun est responsable de ses données et de ses règles, et les autres ne s’adressent à lui que par un contrat : quelques opérations publiques dont le sens est fixé.
L’exemple porte sur deux modules d’une application fictive, l’inscription et la facturation : ce que chacun possède et le contrat qui les relie, puis un changement qui reste d’un seul côté et un autre qui doit traverser la frontière, enfin les contrôles qui font respecter cette frontière, et ce qu’elle ne sépare pas.
Kamil Grzybek définit un monolithe comme un système qui a exactement une unité de déploiement, et il précise que ce mot ne dit rien de sa qualité. Une application livrée comme un seul programme peut donc avoir des modules nets, ou un code où tout dépend de tout. À l’inverse, des services déployés séparément peuvent rester très dépendants les uns des autres. Grzybek appelle monolithe modulaire un monolithe conçu de façon modulaire : chaque module couvre un domaine du métier, dispose de tout ce qu’il lui faut pour remplir sa fonction et n’est accessible que par une interface définie, son contrat.
Le schéma ci-dessous sépare trois décisions. La première découpe le métier en domaines : la conception pilotée par le domaine (Domain-Driven Design, ou DDD) traite un grand modèle en le divisant en contextes délimités, chacun avec son propre vocabulaire. La deuxième organise le code à l’intérieur d’un module. CQRS y distingue deux modèles : un modèle d’écriture, qui reçoit les commandes et décide d’accepter ou de refuser chaque modification selon les règles métier, et un modèle de lecture, conçu pour répondre aux requêtes sans rien modifier. La séparation porte sur les responsabilités, décider ou restituer, et pas seulement sur le fait qu’une opération écrive ou lise. La troisième fixe le nombre de programmes déployés. Ces décisions sont distinctes : changer l’une n’oblige pas à changer les autres. Prenez-les pourtant ensemble, avec des domaines DDD, CQRS dans chaque module qui porte des règles métier et un seul déploiement : l’absence de découpage métier et de séparation entre commandes et requêtes est la première cause à soupçonner quand un code dérive vers un état où tout dépend de tout. Martin Fowler est plus réservé : il juge que CQRS ajoute une complexité risquée pour la plupart des systèmes et le limite à certaines parties. Le conseil vaut pour chaque domaine à règles, où CQRS sert de cadre d’organisation, pas pour un écran qui ne fait que créer, lire, modifier et supprimer des fiches. Cet article s’attache surtout à la première et à la troisième décision.
Dans l’application fictive, Alice crée un compte, puis reçoit des factures. L’inscription possède son compte, ses moyens de connexion et ses consentements. La facturation possède les brouillons, les factures émises et leurs règlements. Les deux modules tournent dans le même processus et sont livrés ensemble.
Les deux modules parlent d’Alice comme d’une cliente, mais ils n’en retiennent pas la même chose. L’inscription doit savoir comment l’authentifier ; la facturation, à quelle entité et à quelle adresse émettre une facture. Ces informations n’évoluent pas selon les mêmes règles : si Alice change d’adresse aujourd’hui, sa facture de mars garde l’adresse à laquelle elle a été émise. Le même article de Fowler cite « Customer » parmi les mots qui changent de sens d’un contexte à l’autre dans une grande organisation.
Les deux modules peuvent donc partager un identifiant d’Alice sans partager un modèle de client. Pour chaque facture, la facturation conserve une copie datée des informations qui lui servent, un instantané du destinataire, au lieu de relire le compte d’Alice à chaque consultation. Chaque donnée a ainsi un seul propriétaire :
| Donnée | Propriétaire | Accès du voisin |
|---|---|---|
| Compte, authentification, consentements | Inscription | Aucun accès aux tables ; consultation nécessaire par contrat explicite |
| Destinataire retenu pour une facture | Facturation | Résultat consultable par l’interface de facturation |
| Brouillon et facture émise | Facturation | Commande ou requête publique du module |
Dans la version modulaire, la facturation ne reçoit plus la grande classe Client du début. Quand une facture doit être préparée pour Alice, le code qui conduit ce cas d’utilisation, appelé ici le parcours applicatif, obtient de l’inscription les informations nécessaires par son interface publique, puis demande à la facturation de créer un brouillon. Cette demande peut être un appel direct, ou passer par un bus interne qui achemine les commandes vers le module concerné ; le contrat reste le même. Voici un contrat illustratif ; il ne prescrit ni langage ni protocole réseau :
Facturation.creerBrouillon(
demandeId,
destinataire: { identifiant, nomLegal, adresse, versionSource },
lignes: [{ designation, quantite, prixUnitaireCentimes }]
) -> { factureId, revision, statut }
Facturation.consulter(factureId) -> ResumeFacture
Le destinataire transmis est l’instantané de la section précédente. Dans ce contrat fictif, versionSource indique de quelle version du profil d’Alice il provient. Le module de facturation vérifie les montants, les champs requis et ses règles de création, puis conserve cet instantané avec son document. Le parcours ne lui donne aucun moyen de lire librement la table des comptes. Grzybek insiste sur ces contrats entre modules ; dans cet exemple, le contrat sert surtout à empêcher la facturation de devenir un lecteur implicite de toutes les tables de l’inscription.
Le premier paramètre, demandeId, répond à un autre risque. Si le parcours ne reçoit pas la réponse et renvoie la même demande, la facturation reconnaît l’identifiant et ne crée pas un second brouillon. Cette protection contre une reprise involontaire est une forme d’idempotence.
Ajoutons maintenant la case de consentement à la lettre d’information. Elle modifie l’inscription seule : elle n’apparaît ni dans ce contrat ni dans les tables de la facturation, qui ne voit plus la classe Client : le problème du début a disparu.
Une autre règle traverse la frontière, et elle le doit : rendre obligatoire un numéro fiscal pour certains destinataires. Cette règle concerne la facture elle-même, donc le contrat de création change. La modularité ne promet pas que tout changement restera enfermé dans un seul module. Elle cherche à limiter chaque changement aux modules qu’il concerne.
Faire évoluer ce contrat demande trois précisions : les destinataires concernés, la provenance du numéro et le sort des brouillons déjà créés sans lui. Pendant la migration, le nouveau champ peut rester techniquement optionnel pour que les anciens appels restent valides. Ce caractère optionnel ne doit pas faire croire que la règle métier est satisfaite. Un ancien appel est accepté dans un périmètre défini, par exemple pour les destinataires que la règle ne vise pas, ou refusé avec une erreur exploitable, qui dit quelle information manque.
Ce découpage tient tant que personne ne contourne le contrat. Les classes internes et les dépôts de données de chaque module restent donc invisibles depuis les autres, et un contrôle d’architecture le vérifie automatiquement : il interdit par exemple à inscription d’importer facturation.interne, et un import de ce type fait échouer la vérification.
Ce contrôle ne voit pas tout : une requête SQL écrite dans la facturation pour lire la table des comptes est une simple chaîne de caractères, et ni le compilateur ni le contrôle des imports n’y voient forcément une dépendance. Une base commune ne sépare pas non plus les droits des modules si tout le processus s’y connecte avec le même compte. Selon les contraintes, des conventions, un contrôle des requêtes ou des rôles distincts dans la base peuvent renforcer la frontière. Le plus sûr est d’annoncer la protection effectivement obtenue, sans présenter l’organisation du code comme une isolation de sécurité.
La recette de la frontière comprend donc trois essais : un import interdit est rejeté ; une création de brouillon passe par le contrat public ; l’ajout du consentement ne demande aucune modification de la facturation. Ce dernier essai examine un changement réel ; ce n’est pas une mesure universelle du découplage.
Les modules partagent encore la mémoire du processus, ses ressources et un calendrier de livraison. Une fuite de mémoire ou une surcharge dans la facturation peut ralentir ou arrêter l’inscription, et une correction urgente de l’une ne part qu’avec une livraison de toute l’application. La frontière rend les responsabilités lisibles ; elle ne contient pas toutes les pannes.
Revenons à la case de consentement. Dans l’application découpée en modules, elle ne touche que l’inscription, parce que la facturation reçoit seulement ce que son contrat demande ; le numéro fiscal, lui, change ce contrat, parce qu’il concerne la facture. Tout cela tient dans un seul déploiement. Commencez par ce découpage tant qu’il répond aux contraintes du produit ; le contrôle des dépendances l’aide à tenir dans le temps. Si la charge, l’isolation des pannes ou un calendrier de livraison propre à un module deviennent nécessaires, extraire ce module en service devient une décision à justifier par ces besoins, au lieu d’être la condition préalable à toute modularité.
Explorer
Choisis dans l’index d’après les étiquettes de cet article — les plus proches d’abord, hors de sa série. Rien n’est écrit à la main : un article publié demain avec les mêmes étiquettes y prendra place.
Un module perd son autonomie quand ses règles et ses données se dispersent. Voici les signes à examiner et les moyens de garder des frontières compréhensibles.
Pour changer de fournisseur de courriels sans modifier la facturation, isolez son code dans la messagerie derrière un contrat d’envoi stable.
Rendre le code modulaire ne demande pas forcément de créer des services. Une interface claire et des dépendances maîtrisées peuvent déjà isoler les changements.
Laisser un commentaire
Votre commentaire sera relu avant d'être publié.