Close

Microservices: understanding what it is and its benefits

Il n'y a pas si longtemps, les développeurs d'apps logicielles privilégiaient une architecture monolithique, qui se composait d'une seule unité autonome. Cette approche a bien fonctionné pour beaucoup d'entre eux jusqu'à ce que les apps gagnent en complexité. Lorsque vous modifiez une petite section de code dans un système monolithique, vous devez reconstruire l'ensemble du système, effectuer des tests sur l'ensemble du système et déployer une toute nouvelle version de l'app.

C'est alors que sont apparus les microservices : une approche qui décompose les systèmes logiciels en unités plus petites développées et déployées de manière autonome. L'architecture de microservices est propulsée par le mouvement DevOps qui cherche à livrer fréquemment des mises à jour, comme de nouvelles fonctionnalités, des corrections de bugs et des améliorations de sécurité. Dans de nombreux cas, les microservices sont également devenus un moyen pour les entreprises de réécrire des apps héritées à l'aide de langages de programmation modernes et de mises à jour d'une stack technique.

Les microservices sont un ensemble de petites unités qui livrent et déploient en permanence de grandes apps complexes.

Qu'est-ce que les microservices ?


Une architecture de microservices, également appelée simplement « microservices », est une approche permettant de créer une app sous la forme d'une série de services déployables indépendamment, décentralisés et développés de manière autonome. Ces services à couplage lâche sont déployables indépendamment et facilement maintenables. Alors qu'une app monolithique est conçue comme une unité unique et indivisible, les microservices divisent cette unité en un ensemble d'unités indépendantes qui contribuent à l'ensemble global. Ils font partie intégrante de DevOps, car c'est sur eux que reposent les pratiques de livraison continue qui permettent aux équipes de s'adapter rapidement aux exigences des utilisateurs.

Illustration de microservices

Un microservice est un service web responsable d'un élément de la logique de domaine. Plusieurs microservices se combinent pour créer une app, chacun fournissant une fonctionnalité pour un domaine. Les microservices interagissent entre eux à l'aide d'API, telles que REST ou gRPC, mais n'ont pas connaissance du fonctionnement interne des autres services. Cette interaction harmonieuse entre les microservices constitue une architecture de microservices.

Dans une architecture de microservices, les développeurs peuvent ensuite s'organiser en équipes plus petites spécialisées dans différents services, avec différents stacks et déploiements découplés. Par exemple, Jira est alimenté par plusieurs microservices, chacun offrant des fonctionnalités spécifiques, notamment la recherche de tickets, l'affichage des informations sur les tickets, les commentaires, les transitions de tickets, et bien plus encore.

Caractéristiques des microservices


Il n'existe pas de définition formelle d'une architecture de microservices, mais il est important de connaître certains modèles ou caractéristiques communs.

Dans une architecture de microservices, chaque composant peut être développé, déployé, exploité, modifié et redéployé sans compromettre le fonctionnement des autres services ou l'intégrité d'une app.

Avantages des microservices


Microservices provide many advantages. They simplify development and project management. Sometimes, they may eliminate the need for separate operations teams since developers can handle operations for the microservices they build. 

Some other benefits of microservices include:

Illustration de balance

Une évolutivité flexible

Étant donné que les microservices sont distribués par design et peuvent être déployés dans des clusters, ils permettent une mise à l'échelle horizontale dynamique à travers les limites de service. Si un microservice atteint sa capacité de charge, de nouvelles instances de ce service peuvent être rapidement déployées sur le cluster attenant afin de réduire la pression.

Illustration Agile

Agilité

Étant donné que les petites équipes indépendantes développent généralement un service au sein de microservices, cela encourage les équipes à adopter des pratiques Agile. Les équipes sont habilitées à travailler de manière autonome et à agir rapidement, ce qui réduit les temps de cycle de développement.

Illustration de boîte à outils

Flexibilité technologique

Les architectures de microservices ne suivent pas nécessairement une approche définie avec une chaîne d'outils, mais donnent aux équipes la liberté de sélectionner les outils qu'elles souhaitent.

Illustration de blocs empilés

Livraisons fréquentes

L'un des principaux avantages des microservices est la fréquence et la rapidité des cycles de livraison. En tant qu'élément clé de l'intégration continue et de la livraison continue (CI/CD), les microservices permettent aux équipes de tester de nouvelles fonctionnalités et de revenir en arrière en cas de problème. Cela facilite la mise à jour du code et accélère la commercialisation de nouvelles fonctionnalités.

Défis liés aux microservices


Microservices-based architecture has many benefits, but it also comes with challenges. 

One challenge of microservices is that the independent services generate their logs. This is a disadvantage compared to monoliths' centralized logs, which provide a single source of truth for developers and operations teams. Monitoring and infrastructure management are also more complicated since many moving pieces exist. Testing and debugging are challenging because, unlike monoliths, no integrated development environment (IDE) exists.

Atlassian's Compass can help with all these challenges. Compass facilitates collaboration and allows companies to manage the complexities of distributed architectures as they scale. It does this by bringing the disconnected information together in a central, searchable location.

Développement tentaculaire

Lorsque vous migrez un monolithe vers des microservices, vous augmentez la complexité. En effet, vous avez plus de services dans un plus grand nombre d'emplacements créés par plusieurs équipes. Par conséquent, il est difficile de voir comment les différents composants sont liés les uns aux autres, à qui appartient un composant spécifique et comment éviter les répercussions négatives sur des composants dépendants. Si cette multiplication n'est pas gérée, elle freine le développement et dégrade les performances opérationnelles. À mesure qu'un système se développe, il nécessite une équipe opérationnelle expérimentée pour gérer les redéploiements constants et les changements fréquents dans l'architecture.

Manque de responsabilité claire

Une architecture de microservices ajoute de la confusion quant aux différentes responsabilités. Une équipe DevOps peut exécuter une combinaison d'API, de bibliothèques de composants, d'outils de surveillance et d'images Docker pour permettre aux utilisateurs de déployer une app. Il est important d'avoir un aperçu des informations sur les composants, y compris leurs propriétaires, leurs ressources et l'évolution des relations entre les autres composants. La communication et la coordination entre de nombreuses équipes doivent être précises afin que toutes les personnes impliquées puissent facilement trouver les connaissances nécessaires à la compréhension d'un produit.

Coûts d'infrastructure exponentiels

Chaque nouveau microservice ajouté au déploiement en production entraîne son propre coût en termes de suite de tests, de playbooks de déploiement, d'infrastructure d'hébergement, d'outils de surveillance, et bien plus encore.

Frais organisationnels supplémentaires

Un niveau supplémentaire de communication et de collaboration est nécessaire à la coordination des mises à jour et des interfaces entre les équipes d'architecture de microservices.

Débogage

Il peut être difficile de déboguer une app qui contient plusieurs microservices, chacun ayant son propre ensemble de journaux. Un seul processus métier peut s'exécuter sur plusieurs machines à différents moments, ce qui complique encore le débogage.

Réponse aux incidents

Il est important de disposer d'informations sur la réponse aux incidents de microservices, notamment qui utilise le microservice, où et comment le microservice a été déployé, et qui contacter en cas de problème.

Microservices et DevOps : du pareil au même


Compte tenu de la complexité et des dépendances croissantes des microservices, les pratiques DevOps de déploiement, de surveillance et d'automatisation du cycle de vie sont considérées comme faisant partie intégrante des architectures de microservices. C'est pourquoi les microservices sont souvent considérés comme la première étape vers l'adoption d'une culture DevOps, assurant les avantages suivants :

  • Automatisation
  • Évolutivité supérieure
  • Facilité de gestion
  • Agilité
  • Livraison et déploiement plus rapides

Technologies et outils clés pour une architecture de microservices


Un conteneur désigne simplement l'empaquetage d'une app et de toutes ses dépendances, ce qui permet des déploiements faciles et cohérents. Étant donné que les conteneurs n'ont pas la charge de leur propre système d'exploitation, ils sont plus petits et plus légers que les machines virtuelles traditionnelles. Ils peuvent être mis en place et supprimés plus rapidement, ce qui en fait une solution idéale pour les petits services que l'on trouve dans les architectures de microservices.

Avec la prolifération des services et des conteneurs, il est essentiel d'orchestrer et de gérer de grands groupes de conteneurs. Docker est une plateforme de conteneurisation populaire et un environnement d'exécution qui permet aux développeurs de créer, de déployer et d'exécuter des conteneurs. Cependant, l'exécution et la gestion des conteneurs à grande échelle constituent un défi avec Docker seul. Kubernetes et d'autres solutions comme Docker Swarm, Mesos, HashiCorp Nomad aident à gérer la conteneurisation à grande échelle.

La conteneurisation et le déploiement de conteneurs constituent un nouveau modèle d'infrastructure distribuée. Docker et Kubernetes intègrent un service dans un conteneur complet qui peut être rapidement déployé et supprimé. Ces nouveaux outils d'infrastructure sont complémentaires à l'architecture de microservices. Les microservices peuvent être conteneurisés, facilement déployés et gérés à l'aide d'un système de gestion de conteneurs.

Qu'est-ce que les microservices ?


Une architecture de microservices, également appelée simplement « microservices », est une approche permettant de créer une app sous la forme d'une série de services déployables indépendamment, décentralisés et développés de manière autonome. Ces services à couplage lâche sont déployables indépendamment et facilement maintenables. Alors qu'une app monolithique est conçue comme une unité unique et indivisible, les microservices divisent cette unité en un ensemble d'unités indépendantes qui contribuent à l'ensemble global. Ils font partie intégrante de DevOps, car c'est sur eux que reposent les pratiques de livraison continue qui permettent aux équipes de s'adapter rapidement aux exigences des utilisateurs.

Illustration de microservices

Un microservice est un service web responsable d'un élément de la logique de domaine. Plusieurs microservices se combinent pour créer une app, chacun fournissant une fonctionnalité pour un domaine. Les microservices interagissent entre eux à l'aide d'API, telles que REST ou gRPC, mais n'ont pas connaissance du fonctionnement interne des autres services. Cette interaction harmonieuse entre les microservices constitue une architecture de microservices.

Dans une architecture de microservices, les développeurs peuvent ensuite s'organiser en équipes plus petites spécialisées dans différents services, avec différents stacks et déploiements découplés. Par exemple, Jira est alimenté par plusieurs microservices, chacun offrant des fonctionnalités spécifiques, notamment la recherche de tickets, l'affichage des informations sur les tickets, les commentaires, les transitions de tickets, et bien plus encore.

L'avenir des microservices


What tools do people commonly use in microservices?

Businesses often use containerization tools such as Kubernetes and Docker. They also frequently use API gateways between microservices and their clients. These gateways perform API traffic functions such as authentication, access control, and load balancing.

How do microservices differ from monolithic architecture?

Monoliths are large codebases that function as one system. They require system downtime for updates and debugging. Microservices architectures are distributed applications with smaller, independent chunks of functionality. Developers can upgrade, improve, and debug these modules without taking the entire application offline. This simplifies scaling and aids development velocity.

How do microservices impact DevOps?

Those who understand DevOps know that continuous integration and continuous delivery (the DevOps CI/CD pipeline) are the mainstays of DevOps methodologies. The modular nature of microservices aligns perfectly with this approach. Microservices empower developers to swiftly create, test, and deploy small, frequent releases.

Join the Atlassian Community for more microservices articles and discussions.

Naviguez dans vos microservices grâce à Compass

Lorsque vous travaillez avec une architecture de microservices, Atlassian Compass gère la complexité d'une architecture distribuée évolutive. Il s'agit d'une plateforme de partage d'expériences extensible qui rassemble des informations déconnectées sur tous les résultats d'ingénierie et la collaboration des équipes dans un emplacement central et interrogeable. En plus de vous aider à limiter la prolifération de vos microservices grâce au catalogue de composants, Compass peut vous aider à établir des bonnes pratiques et à évaluer l'intégrité de votre logiciel à l'aide de cartes de performance, et vous fournir des données ainsi que des analyses sur l'ensemble de votre chaîne d'outils DevOps à l'aide d'extensions basées sur la plateforme Atlassian Forge.

Illustration de microservices Compass