Article

Modularité et microservices : deux décisions à distinguer

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.

Le moteur de tarifs d’une boutique doit passer d’une remise fixe à des règles promotionnelles. Or les commandes lisent ses tables de coefficients, et les factures recalculent elles-mêmes ses remises : remplacer le moteur oblige à modifier tout le parcours d’achat. La tentation est d’en faire un service séparé pour l’isoler. Le problème se pose pourtant avant le choix entre appel local et service réseau : le moteur expose à ses utilisateurs des décisions qui devraient rester les siennes.

Modularité et microservices relèvent de deux décisions distinctes. La première fixe ce qu’un module cache et ce qu’il promet à ceux qui l’appellent ; elle se prend dans le code. La seconde fixe comment le module est déployé : dans le même programme que ses appelants, ou à part, derrière le réseau. Séparer le moteur en service sans changer ce qu’il expose ne corrigerait rien : les commandes liraient toujours ses coefficients, cette fois à travers le réseau.

L’article garde d’abord ce moteur de tarifs dans le même processus que ses appelants pour examiner le contrat qu’il doit offrir, un changement interne qui ne touche personne, un changement qui modifie légitimement ce contrat, et les moyens de faire respecter la frontière. Le passage au réseau vient en dernier, avec ce qu’il ajoute.

Ce que la commande doit recevoir

Dans cet exemple fictif, un module regroupe des règles et leurs données, et les autres parties du code ne l’utilisent que par son interface publique, son contrat. La commande n’a pas besoin de connaître la table interne des remises. Elle a besoin d’une offre qu’elle peut présenter au client, puis faire accepter. Le premier contrat devient :

Tarification.proposer(lignes, segmentClient, instantDeReference)
  -> Offre {
    offreId, lignesChiffrees, totalCentimes, devise,
    valableJusqua, versionRegles
  }

La commande fournit les lignes, le segment du client et l’instant pour lequel les prix sont calculés. Elle reçoit une offre identifiée, valable jusqu’à une échéance, qui indique aussi la version des règles qui l’ont produite. Une offre O42 indique deux articles à 40 euros, une remise totale de 8 euros, soit 10 % de 80 euros, et un total de 72 euros. Le module garantit la cohérence de ses lignes et de son total. La commande conserve l’offre acceptée ; la facture utilise les valeurs contractuelles de la vente, sans relancer le moteur avec les règles du jour.

Changer l’intérieur sans changer l’appelant

La première implémentation calcule cette remise fixe de 10 %. La suivante utilise une table de promotions avec des dates et des segments de clientèle. Si elle rend toujours une offre respectant le même contrat, le module de commande ne change pas. Les essais vérifient les totaux, les arrondis en centimes, la devise, l’expiration et les cas de refus ; ils ne dépendent pas du nom des tables internes.

C’est le critère de découpage que David Parnas proposait en 1972 : chaque module cache derrière son interface une décision de conception susceptible de changer, ici la façon de calculer les remises. Cacher cette décision ne veut pas dire cacher le sens métier. Le contrat doit au contraire rendre visibles les propriétés dont les consommateurs ont besoin pour agir correctement : le total, la devise, l’échéance.

Un changement qui modifie légitimement le contrat

Une difficulté apparaît si la promotion ne vaut que pour les cent premières ventes. Calculer une offre à 72 euros ne réserve pas automatiquement une place dans ce quota : deux clients pourraient recevoir chacun une offre fondée sur la dernière place disponible. Le contrat doit désormais préciser si l’offre réserve le droit à la remise, pour combien de temps, et comment le consommer. Ce changement touche légitimement la commande, parce qu’il modifie ce qu’elle peut promettre au client.

L’exemple retient une offre garantie jusqu’à son échéance, avec une capacité promotionnelle réservée. L’acceptation consomme cette offre une seule fois, et elle enregistre la commande à laquelle l’offre a servi. Une offre expirée est refusée, et le client reçoit une nouvelle proposition à accepter. Une offre déjà consommée demande de distinguer deux cas : une nouvelle vente qui tenterait de la réutiliser est refusée, mais la répétition de la même acceptation doit retrouver le résultat déjà enregistré et la commande associée, sans créer une seconde vente. Savoir seulement que l’offre est « consommée » ne dirait pas pour quelle commande. Le module de commande doit donc transmettre offreId et l’identifiant de sa commande à l’acceptation, et savoir traiter ces refus.

Un troisième changement se situe entre les deux : un nouvel algorithme d’arrondi. Une nouvelle offre peut alors coûter un centime de plus ou de moins, comme elle varie déjà avec les promotions : les consommateurs n’ont pas à changer pour autant. Deux cas les concernent en revanche : une offre déjà garantie, dont le montant doit être conservé jusqu’à son échéance, et une règle d’arrondi que le contrat lui-même énonce. Les consommateurs sont à réexaminer quand leur garantie contractuelle change, pas à chaque variation des résultats. Le tableau réunit les trois cas :

ChangementTarificationCommande et facture
Table interne des règlesImplémentation et tests internesContrat inchangé
Nouvel algorithme d’arrondiVérifier la compatibilité des résultats promisRévision nécessaire si la promesse monétaire change
Quota promotionnel réservéRéservation, expiration, consommationAccepter une offre identifiée et traiter son refus

Le tableau donne un test de modularité plus utile que le nombre de classes : quelle connaissance oblige chaque consommateur à changer ? Une interface qui exposerait toutes les étapes du moteur conserverait presque le même couplage que l’accès direct aux tables.

Faire respecter cette frontière dans le même processus

Rien de ce qui précède ne demande un réseau. Le paquet public contient le contrat Offre et les opérations autorisées ; les dépôts et les règles de promotion restent internes. Au démarrage, l’application relie chaque contrat à son implémentation, ici l’implémentation locale du moteur. Des contrôles de dépendances empêchent les commandes d’importer les détails internes, tandis que les tests de contrat vérifient le sens des résultats.

Ces moyens forment une gradation, que le schéma suivant prolonge jusqu’aux services réseau : des conventions, puis des contrôles imposés par les outils, puis la séparation en programmes distincts.

Conventions et contrôles de modules peuvent rester dans le même programme ; les services séparés ajoutent l’autonomie de déploiement et les échanges réseau.
Conventions, contrôles et services répondent à des besoins différents. Le réseau ne crée pas à lui seul un bon contrat.

Ce qui fait tenir le module ensemble, sa cohésion, vient de ce que les règles de tarification évoluent pour les mêmes raisons. Elle ne se déduit pas du simple regroupement des fichiers dans un dossier nommé « pricing ». Un grand objet partagé qui exposerait les promotions, les comptes et les factures déplacerait les dépendances au lieu de les réduire.

Le passage au réseau ajoute un autre contrat

James Lewis et Martin Fowler décrivent les microservices comme une application découpée en petits services, chacun exécuté dans son propre processus et déployable indépendamment. Ils les distinguent des bibliothèques, appelées dans le même programme par de simples appels de fonction en mémoire, et rappellent qu’un appel distant coûte plus cher qu’un appel dans le processus.

Extraire Tarification peut donc permettre un déploiement ou un dimensionnement indépendant. Cela ajoute un délai, une disponibilité séparée et de nouvelles façons de rompre l’échange entre la commande et la tarification : un message perdu, une réponse qui n’arrive pas, un service arrêté pendant que l’autre continue. L’incertitude existait déjà dans un seul processus : si l’application s’arrête après l’enregistrement de l’acceptation et avant la suite du parcours, la reprise ne connaît pas le résultat. Le réseau multiplie les occasions de cette situation. Dans tous les cas, la commande doit retrouver par l’identifiant de l’offre le résultat déjà enregistré ; elle ne peut pas supposer que la remise n’a pas été consommée.

L’exemple montre ce que le réseau suppose déjà acquis : l’offre doit posséder un sens autonome avant l’extraction. Le réseau n’invente ni cette frontière ni la garantie de quota.

Revenons au moteur de tarifs. Le passage de la remise fixe aux promotions n’a modifié que la tarification, parce que la commande ne voyait que l’offre ; le quota a modifié le contrat, parce qu’il change ce que la commande promet. Tout s’est décidé dans un seul processus, comme dans un monolithe modulaire. Si le besoin est de remplacer les règles de prix sans retoucher les commandes et les factures, l’interface locale y répond. Si le calendrier de livraison ou l’isolation exigent davantage, un dossier d’extraction examine ce que coûterait un service. Ces deux décisions sont à distinguer parce qu’elles se vérifient sur des effets différents : la modularité sur les consommateurs qu’un changement oblige à modifier, la distribution sur ce qui peut être livré, dimensionné ou tomber en panne séparément.

Explorer

Sur le même sujet

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.

Laisser un commentaire

Elle n'est jamais affichée ni publiée. Elle sert à regrouper vos commentaires et, si vous vous inscrivez un jour avec elle, à vous les rendre.

Votre commentaire sera relu avant d'être publié.