hasina.dev
← Tous les billets

Retour sur notre migration vers l'architecture en îlots

12 min de lecture

Illustration d'une personne qui tape sur un ordinateur portable à un bureau en bois, à côté d'un sac en papier froissé

Note: J'ai écrit l'original de l'article en anglais. Cette traduction française vient de Claude. C'était pour la rapidité mais d'expérience, je sais que ça impacte un peu mon style d'écriture. Je referai proprement la traduction quand j'aurai un peu plus de temps. Bonne lecture!

En janvier 2026, on a migré tout le site de L'Équipe11 un peu de contexte pour les lecteurs non français : L'Équipe est le plus grand média sportif de France, avec des millions d'utilisateurs chaque mois de Nuxt 2 vers Node.js et Vue 3. Ça fait 6 mois maintenant, et on me pose beaucoup de questions sur ce travail lors de meetups et d'entretiens : le pourquoi et le comment. Même si j'en parle toujours avec plaisir, je pense que 15 minutes à divaguer sans slides ne rendront pas justice à toute la réflexion derrière. J'ai donc décidé de développer ici les différents points que je peux aborder, et de prendre du recul pour voir si c'était le bon choix ou non.

Le contexte

Bon, on a tourné sous Nuxt 2 et Vue 2 pendant longtemps. Quand Vue 2 est arrivé en fin de vie le 31 décembre 2023, suivi de Nuxt 2 le 30 juin 2024, la question de la migration n'était plus de savoir si, mais quand. Par bonne pratique, il vaut toujours mieux tourner sur des technologies à jour. On pensait à migrer bien avant le 30 juin, mais on hésitait. Le site était déjà très gros en soi, et on avait aussi des enjeux de performance. Nos partenaires publicitaires comptaient sur nous pour que tout soit disponible en permanence. La moindre indisponibilité pouvait coûter énormément d'argent. Il fallait donc être prudents.

Choisir l'architecture en îlots plutôt que Nuxt 3

Le choix par défaut pour un framework qu'on utilise, c'est simplement de le mettre à jour. Et la plupart du temps, c'est la meilleure idée. Ce n'était pas le cas ici. Nuxt 2 tourne sur Vue 2 et Nuxt 3 sur Vue 3 : c'est un vrai changement de paradigme, je dirais. À l'époque, on ne comptait plus les récits de guerre de devs qui avaient raté la migration, même sur de petits projets. Il n'y a pas que le framework, mais tout l'écosystème Vue autour, puisque beaucoup d'auteurs de packages n'avaient pas porté leurs packages vers Vue 3. Comme quelqu'un l'a dit, c'est une réécriture, pas une mise à jour. L'équipe Nuxt a créé Nuxt Bridge pour la migration, mais à l'époque, ça n'avait pas bonne presse non plus. Ça ne veut pas dire qu'on ne pouvait pas le faire. Mais ça voulait dire qu'il fallait être encore plus prudents.

Ce qui est beau avec une réécriture, c'est qu'on peut vraiment explorer d'autres solutions. Tant qu'à faire, pourquoi ne pas essayer complètement autre chose ? On voulait maximiser les performances, donc on est allés voir les autres frameworks JavaScript conçus pour ça. Nuxt 3 offrait de meilleures performances, mais le gain était incrémental, et pour certains, même négligeable. Je pense que si on avait choisi cette voie, on aurait été plutôt du côté incrémental que négligeable. Mais notre objectif, c'était un résultat spectaculaire.

C'est comme ça qu'au fil de nos recherches, on est tombés sur Astro et son architecture en îlots.22 Astro a rendu l'architecture en îlots populaire, mais ne l'a pas inventée : le terme vient de Katie Sylor-Miller chez Etsy en 2019, et Jason Miller, le créateur de Preact, l'a popularisé en 2020. Et une fois le concept compris, on a jugé que c'était peut-être la meilleure option.

Le concept

L'analogie n'est pas parfaite, mais imaginez qu'il est 9 h et que vous devez porter à pied un sac de riz de 60 kg jusqu'à un restaurant à 3 km. Ils doivent commencer à cuisiner à 10 h. 60 kg, c'est lourd sur cette distance. Vous risquez d'arriver en retard. Alors vous réfléchissez : ils n'ont pas besoin de tout le riz à 10 h, puisqu'ils ne vont pas tout cuisiner d'un coup. Ils n'en ont même pas la capacité. Et si je le divisais en 3 sacs de 20 kg ? J'y vais avec 20 kg, ils peuvent commencer à le cuisiner, et je reviens avec le reste plus tard.

Le sac de riz, c'est le JavaScript. Le restaurant, c'est votre navigateur. Les frameworks SPA ont tendance à envoyer d'emblée le JavaScript de toute la page et à tout hydrater, même les parties qui ne seront jamais interactives, pour que la navigation soit rapide ensuite. Même si mon analogie donne l'impression que l'un est meilleur que l'autre, ce n'est pas le cas. Tout dépend de votre cas d'usage. Bon, avec une petite préférence personnelle saupoudrée dessus. Pour nous, comme notre CTO l'a écrit, les données montraient que la plupart des gens lisaient juste une page, arrivés par un lien depuis un moteur de recherche ou les réseaux sociaux. On avait donc seulement besoin d'assez de JavaScript pour cette page. Et même ça, c'est trop : on pouvait se contenter du JavaScript du contenu affiché dans le viewport. C'était confus ? Je réessaie avec une image :

Schéma d'une page de navigateur découpée en îlots : en-tête, article, articles liés et footer en HTML statique ; menu mobile en client:media ; bouton panier en client:load ; carrousel en client:idle ; et, sous la ligne de flottaison, commentaires et newsletter en client:visible et une carte en client:only
une représentation minimale d'un navigateur, avec l'aimable participation de Claude

Cette image, c'est votre navigateur. La partie claire, c'est le viewport : ce que vous voyez à l'écran. Sous la ligne de flottaison, c'est ce qui est caché : il faut faire défiler pour y arriver.

Ce qu'on fait, c'est réfléchir au minimum nécessaire pour afficher quelque chose dans le navigateur. Certains éléments n'ont besoin d'aucune interaction, juste de contenu. Ils n'ont pas besoin de JavaScript, donc ils sont générés sur le serveur. Par exemple l'article et le footer.

On a ensuite décidé de construire le système sur l'architecture d'Astro, mais spécifiquement avec Vue. Pourquoi ne pas simplement utiliser Astro, alors ? Tout ce qu'on avait était déjà construit en Vue. Avec Astro, nos pages et nos layouts seraient devenus des fichiers .astro, et Vue n'aurait vécu qu'à l'intérieur des îlots. On voulait que toute l'app reste en Vue, jusqu'à la structure de la page, avec un système taillé pour notre plateforme.

Certains éléments ont besoin de JavaScript, mais seulement pour une taille d'écran précise. Comme on n'a pas besoin du menu mobile sur desktop, inutile d'y charger son JavaScript. On lui donne donc un attribut qu'on appelle client:media, ce qui veut dire qu'on n'active son interaction que quand l'écran a la bonne taille.

Certains éléments ont besoin d'interaction dès le chargement de la page. Les boutons, par exemple, doivent répondre le plus tôt possible, donc on les hydrate en premier. C'est pour ça qu'on donne au composant l'attribut client:load.

À l'inverse, il y a ceux qui peuvent attendre. Une fois que le navigateur a fini d'exécuter tout le reste (gros scripts, longs calculs), il devient inactif, et à ce moment-là, les composants non urgents peuvent être hydratés. C'est client:idle. J'ai mis un carrousel en exemple, mais ça peut aussi être des boutons dont je sais que l'utilisateur ne cliquera pas dessus dès le chargement de la page, parce qu'ils servent à quelque chose de précis, comme le bouton que j'ai mis en place pour signaler des erreurs dans le contenu généré par IA.

Il y a aussi des composants qui ne peuvent pas se charger sur le serveur, parce qu'ils ont besoin d'éléments côté client comme window ou le localStorage. Un exemple connu, c'est la carte : elle a besoin d'une bibliothèque tierce, donc elle ne peut se charger que côté client. D'où client:only. La norme ici, c'est d'écrire client:only="vue", mais comme on a décidé de rester en Vue pour toute l'app, je ne voyais pas trop l'intérêt de ce détail en plus.

Enfin, et surtout, c'est là que le viewport compte, et c'est mon préféré : client:visible. Le navigateur n'a pas besoin d'hydrater quelque chose que vous ne voyez pas. Dans une SPA classique, tous ces éléments sont hydratés au chargement. Mais ici, les composants en client:visible ne sont hydratés que lorsqu'ils sont réellement vus.

Nos réticences

Pour comprendre ce qu'on s'apprêtait à faire, il faut comprendre comment fonctionnent le navigateur et le serveur à partir des principes de base. On connaissait tous les articles de blog et tout ce qui s'était écrit sur le sujet, mais malgré tout, seule une poignée de grandes plateformes l'avaient adopté (The Guardian en fait partie). Personnellement, j'avais confiance dans les concepts, tout en me demandant si on n'avait pas raté quelque chose. Si on se plantait, la conséquence serait un revers financier pour toute l'entreprise, pendant au moins un trimestre entier.

On a donc fait la chose raisonnable. On était 5 développeurs et l'engineering manager. Comme les développeurs avaient tous déjà du pain sur la planche, l'engineering manager, Jean-Baptiste Labouré, a posé les fondations du projet avec un petit PoC. On se réunissait souvent pour faire le point. Tous les développeurs, moi compris, devaient tester le PoC sur leur propre domaine pour repérer d'éventuels problèmes à venir. On a intégré quelques composants sur notre temps libre pour le tester. On a rencontré quelques points bloquants, mais avec un peu de collaboration et de persévérance, on s'en est sortis. Ça a fait des allers-retours pendant des mois, parce qu'on avait des échéances sur d'autres sujets.

Puis est venu le moment de décider. On a fait un tour de table pour en discuter. La plupart d'entre nous étaient réticents le jour où la solution avait été proposée. Mais ça faisait déjà quelques mois qu'on testait le PoC, et il fallait bien aboutir à un moment. Le jour de la décision, on a demandé à chaque développeur son niveau de confiance. Sur une échelle de un à cinq, personne n'a atteint cinq, mais tout le monde était au-dessus de la moyenne. Ce qui me préoccupait, c'étaient les choses qu'on ne sait pas qu'on ne sait pas encore. On a donc décidé d'avancer et de gérer ce qui viendrait. Ça fait partie du métier : toujours trouver une solution.

Et c'est ainsi qu'on s'est lancés dans cette architecture.

Comment ça s'est passé ?

Quand on a pris la décision, on a d'abord affecté un développeur à plein temps dessus, pour repérer les obstacles et poser les bases de chaque domaine. Il y a travaillé pendant 3 mois et a résolu beaucoup de problèmes au niveau des fondations. Puis on l'a rejoint et on s'y est mis à fond de septembre 2025 à janvier 2026. Comme je m'y attendais, il y a bien eu des problèmes qu'on n'a découverts qu'une fois assez avancés dans l'architecture. Par exemple, le direct. Il devait se mettre à jour toutes les 15 secondes, et pour ça, il fallait rafraîchir la liste. Le problème, c'est que la liste était le conteneur de toute la page. On devait donc rafraîchir une énorme partie de la page.

On a utilisé l'IA, mais à l'époque, elle n'était pas aussi bonne qu'aujourd'hui. La plupart d'entre nous étaient sur GitHub Copilot, même si un lead était déjà sur Claude Code. L'IA a donc aidé, mais pas autant qu'elle le ferait si on devait faire le travail aujourd'hui.

On a mis en production le 13 janvier 2026. Malgré tous les tests, il y a eu un nombre conséquent de remontées d'erreurs les jours suivants. Heureusement, rien de majeur côté publicité. À la fin de la deuxième semaine, on avait corrigé 98 % des régressions. Les 2 % restants, c'étaient des choses qu'on ne découvrirait que des mois plus tard. On garde encore l'ancien site qui tourne sur un serveur quelque part, pour comparer d'éventuelles incohérences. On prévoit de l'éteindre d'ici la fin de l'année.

Les résultats en termes de performance ont été phénoménaux. J'en ai parlé dans une de mes études de cas. Mais tout n'a pas été rose. La DX de la nouvelle architecture s'est dégradée dans une certaine mesure. Mais c'était un compromis qu'on avait accepté. On venait de créer une solution très sur mesure pour une grosse plateforme. Les frameworks comme Nuxt ont une équipe dédiée qui travaille spécifiquement sur l'expérience développeur, pour qu'il soit agréable de s'en servir. On n'avait pas cette équipe dédiée, car les ressources étaient surtout concentrées sur le projet. Malgré tout, le bilan reste positif grâce au gain de performance, et on a progressé lentement mais sûrement sur la DX depuis.

Il n'y a pas vraiment eu de régression majeure, mais on a eu deux fuites mémoire : l'une corrigée en février, et l'autre seulement récemment, quand on a eu Fable 5 pour en retrouver l'origine.

Est-ce que ça en valait la peine ? Absolument, mais je ne le recommanderais pas à tout le monde. On avait un défi de performance bien précis, et une réécriture était inévitable quelle que soit la décision. Je suis toujours partant pour prendre le chemin ennuyeux. Si quelque chose a marché pour la plupart des gens, il y a de fortes chances que ça marche pour vous aussi. Si vous m'engagez pour travailler sur vos performances, j'épuiserai toutes les méthodes standard avant de passer à des alternatives. Mais dans tous les cas, c'est une question de choix. Si le tape-à-l'œil, c'est votre truc, ça peut marcher aussi.

J'espère que vous avez appris quelque chose ici ! Si vous avez besoin d'aide sur votre projet ou si vous avez des questions, n'hésitez pas à m'écrire. Je répondrai avec plaisir.

Notes

  1. un peu de contexte pour les lecteurs non français : L'Équipe est le plus grand média sportif de France, avec des millions d'utilisateurs chaque mois

    ↩
  2. Astro a rendu l'architecture en îlots populaire, mais ne l'a pas inventée : le terme vient de Katie Sylor-Miller chez Etsy en 2019, et Jason Miller, le créateur de Preact, l'a popularisé en 2020.

    ↩

Ce billet t'a parlé ?