J'ai vu des équipes formées pour travailler sur des « microservices » conçus à l'avance.

À mon humble avis, ce n'est pas la meilleure façon de faire du développement logiciel. Scaler juste pour distribuer des tâches, ou scaler pour scaler, crée des tâches inutiles et des efforts gaspillés.

Une architecture décidée avant le début du travail est un pari sur une connaissance que l'équipe n'a pas encore. Le pari coûte cher. Et le coût apparaît lentement : dans le code, dans le calendrier et dans le moral de l'équipe.

À quoi ressemblent les six premiers mois ?

Dans leurs six premiers mois, ces dépôts contiennent souvent plus de cas d'usage d'intégration que de features tournées vers les utilisateurs métier. Surtout du code technique, peu ou pas de valeur métier.

Le mécanisme est simple. Les règles métier sont la partie du système que l'équipe comprend le moins au début. Elles arrivent donc en dernier. Un nouveau service doit recevoir des données d'autres services, leur en envoyer, gérer leurs pannes et mapper leurs formats. Cette tuyauterie est la première chose que l'équipe écrit, parce que c'est la seule chose que le service peut faire avant de savoir quel doit être son comportement métier.

Le résultat ressemble à du progrès. Les dépôts se remplissent, les pipelines passent au vert et les déploiements partent. Pourtant, les utilisateurs attendent toujours la première feature qui compte pour eux.

Pourquoi de mauvaises frontières coûtent-elles si cher ?

Ces pratiques sont une cause majeure de la création de systèmes distribués complexes avec des frontières inadaptées.

Une frontière, c'est l'endroit où l'on sépare les données et le comportement. Quand une frontière coupe une opération métier en deux, chaque requête traverse le réseau, chaque changement touche plusieurs dépôts et plusieurs déploiements, et chaque panne se cache entre deux services. De mauvaises frontières détournent l'attention des besoins des utilisateurs. Elles mènent au « debugging hell » : les équipes passent des jours à résoudre des problèmes techniques, et la frustration grandit tout au long du chemin.

Trouver la bonne frontière est difficile pour tout le monde. Udi Dahan le dit sans détour : « Finding service boundaries is really damn hard… There is no flowchart! » Eric Evans appelle la frontière d'un modèle un bounded context. Et le travail pour la trouver consiste à comprendre le domaine, pas à compter des services.

Une deuxième force est à l'œuvre. Melvin Conway a observé en 1968 que les organisations conçoivent des systèmes qui reflètent leurs structures de communication. Quand c'est l'organigramme qui dessine les services, les frontières suivent les équipes. Redessiner des frontières mal posées dès le départ est extrêmement difficile, voire impossible, car il faut toucher à l'organisation, à l'infrastructure et à la configuration.

Comment reconnaître un big ball of mud qui grandit ?

Un service avec plus de méthodes liées à l'intégration que de méthodes liées au métier est un signe fort d'un « big ball of mud » distribué qui grandit. Brian Foote et Joseph Yoder ont donné ce nom en 1997 à un système dont la structure s'est érodée jusqu'à devenir un fouillis. Étalez ce fouillis sur un réseau, et il devient bien plus difficile à voir et à changer.

Faites cette vérification sur vos services actuels :

  1. Listez les méthodes de chaque service.
  2. Classez chaque méthode : intégration (appels à d'autres services, mapping, retries) ou métier (règles sur les commandes, les utilisateurs ou les paiements).
  3. Comptez les deux groupes pour chaque service.
  4. Si les méthodes d'intégration gagnent, arrêtez d'ajouter des services.
  5. Cherchez une opération métier étalée sur plusieurs services, et fusionnez ces services.

La vérification prend un après-midi. Elle vous dit si l'architecture sert le métier ou si elle sert le diagramme.

Que faire à la place ?

Un monolithe modulaire est une alternative plus viable. Il tourne comme une seule unité déployable, avec une seule base de données. Ses frontières sont imposées sous forme de modules dans le code. Les appels entre modules sont donc de simples appels de fonction, et un défaut dans un module ne voyage pas à travers un réseau.

Changer une frontière dans un monolithe modulaire, c'est déplacer du code. Changer une frontière entre deux services, c'est renégocier une API, un déploiement et souvent une équipe. MonolithFirst, de Martin Fowler, défend l'idée de commencer par un monolithe et de le découper une fois que les lignes de découpe sont claires.

La décision de créer des microservices doit être différée, évaluée à fond et challengée, vu les risques sévères de couplage fort. Différez, prouvez et challengez la décision. Chaque découpage doit répondre à une question à laquelle le monolithe ne sait pas répondre.

Imposez les frontières à l'intérieur du monolithe avec ce que votre langage vous donne déjà : les packages, les règles de visibilité, et une vérification au build qui échoue quand un module va fouiller dans les détails internes d'un autre. La frontière existe alors dans le code avant d'exister sur le réseau. Quand un découpage devient nécessaire, le module avec l'interface la plus propre est le premier candidat.

Quand les microservices sont-ils la bonne décision ?

La réponse n'est pas « jamais ». Les microservices conviennent quand le domaine est compris, quand ses frontières ont tenu face à de vrais changements, et quand des parties du système doivent être déployées ou scalées indépendamment du reste. James Lewis et Martin Fowler décrivent ce style autour du déploiement indépendant et de la gestion décentralisée des données. Et ces propriétés viennent avec le coût de coordination que le monolithe évitait.

Microservices Patterns, de Chris Richardson, présente la décomposition par capacité métier comme point de départ. Ce point de départ, c'est le métier, pas l'organigramme. Quand les frontières viennent du métier, un service a une raison d'exister avant d'avoir un dépôt.

Un signal utile : un module qui change à son propre rythme, avec ses propres utilisateurs, et dont les pannes ne doivent pas arrêter le reste du système. Voilà des raisons pour lesquelles une frontière de déploiement peut se rentabiliser. Un module qui change toujours en même temps que ses voisins n'est pas encore un service, quoi qu'en dise son dossier.

💡La frontière est la partie la plus difficile à changer. Méritez-la avant de la tracer !

Continuez à apprendre ! Continuez à lire ! Santé !

Ressources et bibliographie

Publié d'abord sur LinkedIn : le post d'origine