Passer le développement frontend à l’échelle avec les micro-frontends
Retour aux analyses
Produit et technologie

Passer le développement frontend à l’échelle avec les micro-frontends

2023-12-10
6 min de lecture

À retenir

"Découper le monolithe frontend pour que des équipes autonomes puissent déployer indépendamment."

Le problème du monolithe frontend

Les équipes backend ont compris les microservices il y a des années. Elles ont décomposé leurs monolithes en services déployables indépendamment, chacun confié à une petite équipe, avec son propre cycle de livraison. Le résultat : des itérations plus rapides, des responsabilités plus claires et moins de goulots d’étranglement au déploiement.

Les équipes frontend, pour la plupart, n’ont pas bénéficié du même traitement. Même dans les organisations dotées d’architectures backend sophistiquées, le frontend reste souvent un seul dépôt, un seul pipeline de build et un seul artefact de déploiement. Chaque équipe qui touche à l’interface (équipe du tableau de bord, du paiement, de l’administration) commit dans la même base de code, attend le même pipeline de CI et déploie en même temps que les autres.

À petite échelle, cela fonctionne bien. Avec deux ou trois développeurs frontend, la coordination reste gérable. Mais avec cinq, huit ou douze équipes frontend qui travaillent sur différentes parties de la même application, le monolithe devient le goulot d’étranglement. Un test cassé dans le module de paiement bloque le déploiement de l’équipe du tableau de bord. La mise à jour d’une dépendance par une équipe casse les composants d’une autre. La planification des sprints devient une négociation sur des ressources partagées au lieu d’une priorisation indépendante.

C’est le piège du monolithe frontend, et les micro-frontends sont une manière d’en sortir.

Schéma d’architecture frontend

Ce que sont réellement les micro-frontends

Le concept est simple : décomposer le frontend en éléments plus petits, développés, testés et déployés indépendamment. Chaque élément appartient à une seule équipe et correspond à un domaine métier : le catalogue produits, le profil utilisateur, le parcours de paiement, le panneau d’administration.

Chaque micro-frontend peut avoir sa propre stack technologique, son propre pipeline de build et son propre calendrier de livraison. L’application conteneur, parfois appelée « shell » ou « host », gère le routage, la navigation partagée et l’assemblage des micro-frontends en une expérience utilisateur cohérente.

Plusieurs approches de mise en œuvre existent, avec chacune ses compromis :

Module Federation (Webpack 5 / Rspack)

C’est l’approche la plus répandue pour les applications basées sur React. Chaque micro-frontend est un build Webpack distinct qui expose des composants précis. L’application hôte charge ces composants à l’exécution depuis des URL séparées. Les équipes déploient indépendamment : lorsque l’équipe du paiement pousse une nouvelle version, l’application hôte la récupère automatiquement, sans redéploiement.

L’avantage est la performance. Les dépendances partagées (React, design system) sont chargées une seule fois et partagées entre tous les micro-frontends. L’expérience développeur est proche de celle d’un monolithe : le remplacement à chaud des modules fonctionne, les types TypeScript peuvent être partagés et le modèle mental est familier.

La limite est le couplage. Tous les micro-frontends doivent s’accorder sur la version de React et sur les principales dépendances partagées. Mettre à jour React exige une coordination entre toutes les équipes, exactement le type de coordination que les micro-frontends sont censés supprimer.

Single-SPA

Single-SPA adopte une autre approche. Chaque micro-frontend est une application entièrement indépendante, qui peut utiliser des frameworks totalement différents. Une équipe peut choisir React, une autre Vue, une autre Angular. L’orchestrateur single-spa monte et démonte les applications selon la route courante.

L’avantage est une vraie indépendance. Les équipes prennent leurs décisions technologiques sans se coordonner avec personne. Les mises à jour de framework sont des décisions locales.

Le coût est la performance. Chaque framework alourdit le bundle. Si trois micro-frontends utilisent trois versions différentes de React, l’utilisateur télécharge React trois fois. Pour des applications d’entreprise internes, où la taille du bundle compte moins, ce compromis peut être acceptable. Pour des applications grand public, il ne l’est généralement pas.

Composition côté serveur

Pour les applications où le SEO et la performance du chargement initial sont primordiaux, la composition côté serveur assemble les micro-frontends en périphérie (edge) ou sur le serveur avant d’envoyer le HTML au navigateur. C’est l’approche utilisée par des entreprises comme IKEA et Zalando pour leurs plateformes e-commerce.

Équipe de développement travaillant sur des composants

Quand les micro-frontends sont pertinents

Les micro-frontends ajoutent de la complexité. Ce n’est pas une critique : c’est un fait qui doit guider la décision d’adoption. Cette complexité n’est justifiée que lorsque la difficulté organisationnelle du monolithe dépasse le coût technique de la décomposition.

Des règles empiriques tirées des projets que nous avons livrés :

  • 3 équipes frontend indépendantes ou plus : en dessous de ce seuil, la coordination dans un monolithe reste gérable. Au-dessus, les conflits de déploiement et les goulots d’étranglement de fusion commencent à consommer un temps d’ingénierie significatif.
  • Des cadences de livraison différentes : si l’équipe marketing doit mettre à jour la landing page tous les jours alors que le produit principal est livré toutes les deux semaines, les imposer au même cycle de livraison crée une friction inutile.
  • Des produits acquis : après une acquisition, il faut souvent intégrer une application nouvellement acquise à une plateforme existante. Les micro-frontends permettent d’intégrer l’interface acquise sans la réécrire.
  • Une migration progressive : vous passez d’une application Angular vieillissante à React ? Les micro-frontends permettent de reconstruire une section à la fois pendant que le reste de l’application continue de tourner sans changement.

Les micro-frontends n’ont pas de sens pour les petites équipes, les produits en phase initiale ou les applications dont l’interface appartient entièrement à une seule équipe. La charge de gestion de plusieurs pipelines de build, des versions de dépendances partagées et de la communication entre micro-frontends a un coût. Pour une équipe de quatre développeurs, un monolithe bien structuré, aux frontières de modules claires, est presque toujours le meilleur choix.

Visualisation d’une architecture modulaire

Le design system comme liant

Le plus gros risque des micro-frontends est la fragmentation visuelle. Si chaque équipe construit ses propres boutons, ses propres champs de formulaire, sa propre palette de couleurs, l’expérience utilisateur se dégrade en un patchwork incohérent, qui donne l’impression de cinq produits différents assemblés.

La solution est un design system partagé, une bibliothèque de composants que chaque micro-frontend utilise. Ce n’est pas facultatif. C’est l’investissement le plus important dans une architecture de micro-frontends.

Le design system doit appartenir à une équipe dédiée (ou à une guilde tournante) et être publié sous forme de paquet versionné. Les micro-frontends se fixent sur une version précise et mettent à jour à leur propre rythme. On obtient de la cohérence sans couplage : les équipes ont les mêmes boutons et la même typographie tout en gardant des déploiements indépendants.

En pratique, nous publions les design systems à la fois sous forme de paquets npm et de documentation Storybook. Chaque composant est testé visuellement avec Chromatic, pour que les modifications du design system ne cassent pas par inadvertance les micro-frontends qui en dépendent.

Bibliothèque de composants du design system

Performance et considérations pratiques

La performance des architectures de micro-frontends demande une attention délibérée. Sans elle, on finit par livrer plus de JavaScript, faire plus de requêtes réseau et offrir une expérience plus lente que le monolithe remplacé.

Les points clés :

  • Déduplication des dépendances partagées : utiliser le shared scope de Module Federation pour que des bibliothèques comme React et votre design system soient chargées exactement une fois, et non une fois par micro-frontend.
  • Chargement différé (lazy loading) : ne charger un micro-frontend que lorsque l’utilisateur navigue vers sa route. Le module de paiement n’a pas à figurer dans le bundle initial si l’utilisateur parcourt le catalogue produits.
  • Préchargement : anticiper la navigation de l’utilisateur et précharger le micro-frontend le plus probable pendant les temps morts. Cela masque la latence réseau du chargement d’un bundle séparé.
  • Gestion de l’état partagé : l’état partagé entre micro-frontends doit rester minimal. Utiliser des événements ou un mécanisme léger de publication/abonnement plutôt qu’un store Redux partagé. Chaque micro-frontend doit posséder son propre état et communiquer par des contrats bien définis.

La pratique frontend de GTEMAS

Chez GTEMAS, nous avons livré des architectures de micro-frontends pour des clients grands comptes de la fintech, de l’e-commerce et de la logistique. Notre approche standard utilise Module Federation avec un design system partagé publié via Storybook. Nous mettons en place des pipelines CI/CD indépendants par micro-frontend avec GitHub Actions, et des tests de régression visuelle automatisés avec Chromatic.

Nous ne recommandons pas les micro-frontends pour tous les projets. Pour beaucoup de clients, un monorepo bien structuré avec Turborepo ou Nx offre une indépendance suffisante aux équipes, sans la charge d’exploitation de déploiements multiples. La bonne architecture dépend de la taille des équipes, de la fréquence de livraison et des difficultés précises que vous cherchez à résoudre.

Déploiement de l’équipe frontend de GTEMAS

Si votre équipe frontend grandit et que la coordination des déploiements devient le goulot d’étranglement, la discussion sur les micro-frontends mérite d’avoir lieu. Nous pouvons vous aider à évaluer si la décomposition a du sens dans votre situation et, le cas échéant, à concevoir une architecture qui apporte l’indépendance sans sacrifier l’expérience utilisateur.

Parlez à notre équipe d’architecture frontend.

Besoin d’un conseil en ingénierie ?

Dites à l’équipe GTEMAS ce que vous construisez et échangez-en avec un expert.

Parler à un expert