Les microservices attirent de plus en plus l’attention des architectes. Concrètement, l’idée principale est de découper une application monolithique en morceaux composables. Ces morceaux communiqueront ensemble pour que l’ajout de nouvelles fonctionnalités soit plus rapide, facilitant ainsi la maintenance. Chaque composant est développé séparément, et l’application est le produit de tous ces microservices combinés. Il faut noter que les microservices comportent de nombreux avantages, mais aussi des points faibles non négligeables. En les utilisant là où il ne faut pas, nous risquons d’avoir plus d’inconvénients que d’avantages et de ne pas profiter de toute la puissance qu’ils offrent.
Quelques erreurs à éviter
Des erreurs sont régulièrement commises, nous pouvons notamment évoquer :
Le découpage
Découper une application monolithique en microservices n’est pas chose aisée. Si l’application est mal découpée et les microservices mal modélisés, cela peut créer de nombreux problèmes, notamment de couplage. À titre d’exemple, certaines équipes de développement débutantes en microservices découpent et redécoupent l‘application en services jusqu’au point où chaque méthode est isolée dans un ”nanoservice”. Les échanges entre ces ”nanoservices” seront extrêmement complexes, donc difficiles à comprendre et à surveiller, les performances seront mauvaises et le nombre de serveurs nécessaires sera important. Au final, les inconvénients finissent par surpasser les avantages.
Monitoring
Pouvoir observer le comportement de chaque service est très important. Cela s’avère très facile quand le système ne compte que quelques services, mais lorsque les services se multiplient, ainsi que les connexions entre eux, il devient alors difficile de tout superviser. L’utilisation de logs est classiquement utilisée pour monitorer ce genre de services ; pour localiser un log, l’équipe doit vérifier chaque microservice, ce qui peut vite s’avérer compliqué si le système en compte de nombreux. Une solution est alors d’avoir un système de logs centralisé afin de voir de quel service provient chaque log.
Du monolithique aux microservices
Amazon et Netflix sont des exemples d’entreprises qui ont su transformer leurs applications monolithiques en architecture microservices. Passer d’une application monolithique aux microservices est la manière la plus efficace de mettre en place des microservices. L’idée est de partir d’une application existante et de la découper progressivement en différents services. On peut également ajouter de nouvelles fonctionnalités en développant de nouveaux services si nécessaire.
Cette approche a l’avantage de ne pas attendre qu’une application soit trop grande pour profiter des bénéfices des microservices. La migration peut se faire de manière relativement simple comparé à d’autres changements d’architecture.
Cette option est également utile lorsque le volume de code en question est tel qu’il devient un obstacle à sa maintenance et à son déploiement rapide. Il est alors souvent nécessaire de découper l’application progressivement, afin de permettre une adoption pas à pas des microservices. Il faut noter que les bénéfices seront eux aussi progressifs.
Des changements sont également à opérer côté organisationnel. Cette approche ouvre en effet de nouvelles possibilités : les différentes parties d’une entreprise peuvent désormais communiquer entre elles facilement, en partant du principe qu’elles utilisent toutes des microservices.
Enfin, afin d’éviter de se retrouver avec une application qui ne répond plus aux besoins des utilisateurs, il est nécessaire de garder en mémoire la raison pour laquelle l’architecture actuelle avait été choisie.
Les microservices pour une nouvelle application
Les microservices peuvent aussi être utilisés lors de la création d’une nouvelle application. Pour éviter toutes erreurs, certaines conditions doivent être respectées. Utiliser directement les microservices pour créer votre application, nécessite une bonne connaissance métier du client afin d’effectuer un découpage adéquat. Cela demande du temps, au risque de ralentir les développements alors que la plupart des bénéfices ne seront pas visibles immédiatement. Dans certains cas, il est plutôt recommandé de commencer par faire une application monolithique, qui sera ensuite découpée une fois une taille critique atteinte.
Conclusion
Les microservices permettent une organisation décentralisée, en petites équipes, fonctionnant indépendamment les unes des autres, évitant la plupart des problèmes que peuvent rencontrer les projets conséquents. Il faut cependant bien prendre en compte les contraintes des microservices afin de faire les bons choix et d’en optimiser tous les bénéfices. Les microservices sont naturellement adaptés aux applications de taille importante, régulièrement mises à jour. Il ne faut pas oublier que les microservices sont une architecture distribuée et, pour accéder à la partie métier de l’application, il est nécessaire d’être relié d’une manière ou d’une autre au réseau contenant les microservices nécessaires à l’utilisation de l’application.
Par Cherifa GHERSI
Architecte logiciel et développeur Front-end chez SOAT
