Éléments clés d’une architecture en microservices

Oguzhan Yigit
Publié par Oguzhan
Catégorie : Microservices
02/07/2020

L’essor des solutions PaaS et des plateformes cloud en général contribuent à la démocratisation des architectures en microservices. Derrière ce mot à la mode, l’architecture en microservices est basée sur des concepts dont les objectifs sont clairs. Si je ne devais en mentionner que 3, je choisirais :

  • Simplifier le développement d’applications et réduire la complexité des applications classiques à 3-tiers
  • Faciliter et améliorer l’évolutivité
  • Adopter une démarche DevOps pleine de sens.

Dans cet article, je souhaite expliquer comment les microservices peuvent aider à répondre aux 3 points mentionnés ci-dessus. Pour ce faire, je vais présenter ce que peuvent apporter les applications en microservices en comparaison des architectures traditionnelles N-tiers. Je tiens également à souligner que microservices et serverless vont très souvent de paire sur les plateformes PaaS. La combinaison des deux est la base d’une architecture flexible, maintenable et hautement disponible.

 

Simplifier le développement d’applications

Les applications évoluent

Les applications monolithiques sont conçues comme une unité autonome. Très souvent, le code est organisé en quelques couches pour séparer les interfaces utilisateur des règles métier et des données. Néanmoins, au fil du temps, les besoins de l’entreprise changent, évoluent et se développent. Et plus le temps passe, plus les applications monolithiques souffrent d’un héritage de fonctionnalités devenues inutiles et d’une forte dette technique. Les liens entre les processus métier se renforcent. Il en résulte une maintenance plus complexe et des difficultés pour ajouter de nouvelles fonctionnalités.

 

Les personnes changent

Il faut du temps et des personnes compétentes pour développer des applications. Plus l’application est complexe, plus elle a des fonctionnalités, plus nous avons besoin d’une équipe taillée. Et forcrément, plus nous avons de chances que l’équipe en charge du développement change. Même avec une documentation parfaite, un processus d’intégration minutieux et une bonne ambiance, il est devient de plus en plus difficile d’inclure de nouveaux membres au sein de l’équipe car l’application est trop complexe. Au cours de mon expérience, j’ai également remarqué que les gens s’ennuient plus rapidement lorsqu’ils travaillent sur une application monolithique très complexe. Avec le temps, la qualité diminue et le stress augmente.

 

La technologie évolue plus rapidement que jamais

Les technologies évoluent. Elles peuvent apporter des nouveautés, de meilleures performances, une meilleure évolutivité ou tout simplement, elles peuvent réduire les coûts de développement. Il peut être difficile de profiter des nouvelles technologies dans une application monolithique. Je me souviens de certaines applications où seule une mise à jour de version de framework était un énorme défi. Pire, parfois, une réécriture complète s’imposait !

 

Comment les microservices aident-ils à relever ces défis?

Amélioration de la maintenabilité et de l’évolutivité

A la base d’une architecture en microservices, il y a la définition d’un microservice : c’est un service petit, indépendant et faiblement couplé. Par conséquent, la complexité d’un microservice est relativement faible. Parce qu’un microservice est uniquement responsable de la persistance de son propre état et de ses propres données, il peut facilement être géré par une équipe de petite taille. Dans une architecture en microservices, Il est donc possible de partager la responsabilité des microservices entre plusieurs équipes a taille humaine. Et bien sûr, les petits services indépendants sont plus faciles à maintenir ou à modifier.

Ces microservices doivent très souvent interagir entre eux. Souvent, la communication entre ces microservices repose sur des API ou des systèmes de messagerie d’application (par exemple Azure Service Bus). De cette façon, les microservices sont indépendants et faiblement couplés. La création de nouvelles fonctionnalités se fait en ajoutant de nouveaux microservices qui sont eux même indépendants. Les risques de régression sont donc limités. La complexité tient davantage au nombre de microservices dans l’ensemble de l’application qu’à l’intérieur d’un microservice lui-même et encore moins au nombre de lignes de code écrites.

 

Conserver la motivation de l’équipe

L’architecture en microservices nous permet de développer des applications avec des équipes distinctes, petites et autonomes. Chaque équipe est en charge d’un domaine métier ou technique. C’est l’occasion de donner aux personnes des objectifs clairs et une haute responsabilité sur un périmètre maîtrisé et surtout maîtrisable. En mettant l’intelligence de la solution au cœur de l’architecture plutôt que sur la ligne de code nous ajoutons de l’intérêt au travail des collaborateurs, et forcément, cela se ressent au quotidien.

De plus, la taille des équipes et la faible complexité des composants de l’architecture, rendent la solution plus accessible. Ainsi, si un nouveau membre doit venir compléter l’équipe de développement, son intégration est simplifiée.

 

Être à la pointe de la technologie

Chaque service peut s’exécuter sous différentes plates-formes, langues ou même version de framework. Et néanmoins, ces microservices peuvent cohabiter et communiquer. Cela permet de bénéficier de la technologie la plus adaptée à chaque besoin et surtout, de pouvoir profiter des montées de version des frameworks sans impacter l’existant. Par ailleurs, je pense que c’est aussi un moyen de garder une équipe motivée. De toute évidence, les personnes aiment tester et jouer avec les dernières stacks techniques. En quelque sorte, en leur proposant de travailler avec des technologies récentes on leur offre l’opportunité de travailler sur un projet “cool” dans une entreprise cool. Dans un monde où l’ingénieur en informatique est un élément de plus en plus rare, et où l’on souhaite coûte que coûte conserver ses collaborateurs, cela à toute son importance.

 

Meilleur montée à l’échelle

Les besoins évoluent

Les applications monolithiques sont hébergées sur des serveurs taillés pour supporter une charge définie. Il peut être difficile de dimensionner correctement les environnements nécessaire, en particulier dans un contexte on-premise. Parce que les coûts des ressources diminuent d’années en années, la facilité consiste à surdimensionner la plupart des composants. Cependant, nous ne sommes toujours pas à l’abri d’atteindre les limites de cet environnement surdimensionné. En principe, la scalabilité verticale est facilement réalisable dans la plupart des architecture. En revanche, elle ne peut pas répondre à tous les cas d’usages couverts par la scalabilité horizontale. Et c’est toujours très compliqué d’implémenter une scalabilité horizontale on-premise. Imaginez que l’activité de l’application varie en raison de différents paramètres (période de l’année, buzz, sortie de nouveaux produits …), alors vous devez adapter votre capacité pour absorber cette charge. Les applications classiques à 3 niveaux ne sont pas conçues pour cela.

 

Comment les microservices améliorent-ils la gestion de la charge ?

Quelle que soit le type d’architecture, nous ne sommes pas à l’abri de devoir gérer des pics de demandes. Avec une architecture en microservices, l’applicatif est divisée en composants qui peuvent s’exécuter sur différents serveurs et/ou différentes piles technologiques. Pour gérer les pics de demandes, il devra probablement gérer un ensemble de microservices qui doivent être coordonnés, pas un seul. Les microservices vont vous offrir une meilleure granularité car la scalabilité peut être gérée au niveau du microservice lui même. Vous n’avez donc pas à repenser l’ensemble de votre application mais uniquement un ensemble de microservices. En parallèle, vous n’avez pas besoin de payer une capacité pour l’ensemble de l’infrastructure mais uniquement pour les services nécessaires. Dans l’ensemble, cela signifie que vous avez moins de contraintes mais avez toujours besoin d’avoir une vue bien définie des microservices impliqués.

C’est en utilisant des composants serverless dans une architecture en microservices que l’on tire profit d’une scalabilité optimale. Les fournisseurs cloud l’ont d’ailleurs très bien compris, et les services serverless offerts proposent généralement des solutions de scalabiltié horizontale automatique ou configurable en quelques clics. Lorsque vous utilisez ce type de solution, vous n’avez pas à vous soucier de l’hébergement de serveurs, ce qui facilite le défi de la scalabilité.

 

Conformité avec une démarche DevOps

DevOps est une méthodologie qui rapproche les développeurs (Dev) et les IT Ops (Ops) afin d’améliorer la livraison des logiciels. Elle permet une livraison continue.

Par essence, une application monolithique est difficile à déployer. A chaque nouvelle version, l’ensemble de l’application et de la stack technique est passée au peigne fin. Même si le déploiement est automatisé, l’application entière est complètement testée encore et encore. Par conséquent, davantage d’utilisateurs et de développeurs clés doivent être disponibles pour valider ces tests. Pensez également à l’environnement de test : il est toujours provisionné et nécessite la présence de toute la pile de l’application. A mesure que l’application grandit, apporte de nouvelles fonctionnalités ou évolue,  le déploiement se complexifie. Certaines grandes organisations sont même bloquées avec des versions de produits vieillissantes, car le processus de migration ou de montée de version est trop complexe. Et personne ne souhaite prendre le risque d’avancer à l’aveugle, résultant sur des études de migration interminables ou infructueuses.

 

Comment les microservices s’intègrent-ils à une démarche DevOps?

Tout d’abord, DevOps et microservices sont tous deux des concepts relativement récents et en forte adoption. Les microservices sont devenus populaires et plus facile à réaliser grâce aux plateformes cloud, et nativement ces plateformes sont de plus en plus conçues pour une démarche DevOps. De ce fait, les microservices sont nativement pensés pour être déployables via des pipelines de déploiement automatisés. C’est surtout plus facile d’automatiser les tests et le déploiement de ce type de composant. Par exemple, une des caractéristiques des microservices est qu’ils sont petits et indépendants. Ils sont conçus pour n’avoir aucune dépendance de plate-forme ou de composant, de sorte que les tests et le déploiement peuvent être effectués indépendamment au niveau de chaque microservice. Pensez-y, vous pouvez changer, corriger, construire ou déployer un petit morceau de votre application et vous n’aurez pas à gérer de déploiement “big bang” !

 

Conclusion

Est-il plus simple de gérer ou mettre en oeuvre une architecture en microservices ? Pas nécessairement. Elle donne beaucoup plus de flexibilité à plusieurs niveaux mais nécessite un meilleur pilotage, une meilleure gestion des services et une vue globale de la plateforme. Et comme les plateformes cloud (par exemple les service PaaS de la plateforme Microsoft Azure) apportent de plus en plus de solutions de type microservices, il semble très intéressant de se pencher sur ce type de solution rapidement.