Refonte architecturale d'une plateforme monolithique de pilotage en utilisant des microservices

Ce travail s'inscrit dans le domaine de l'ingénierie logicielle, plus précisément dans la transformation architecturale des systèmes d'information. Il s'intéresse à la refonte d'une plateforme monolithique de pilotage en adoptant une architecture basée sur des microservices. Cette étude est particulièrement utile pour les étudiants en génie logiciel, les ingénieurs en développement logiciel, ainsi que pour les professionnels impliqués dans la modernisation des systèmes d'information et la mise en œuvre de pratiques DevOps.

La question

Le projet traite du problème de rigidité et de difficulté d'évolution des systèmes d'information traditionnels, notamment ceux construits selon une architecture monolithique. Ces architectures, bien que souvent robustes au départ, deviennent rapidement un frein à l'agilité et à la rapidité de livraison des logiciels. Dans un contexte concurrentiel comme celui des télécommunications, où l'adaptabilité et la réactivité sont cruciales, il est nécessaire de repenser ces systèmes pour mieux répondre aux besoins changeants des utilisateurs et du marché.

La question centrale est donc : comment transformer une plateforme monolithique de pilotage de déploiement réseau en une architecture microservices, afin d'améliorer la fréquence des livraisons, la stabilité des versions, et la capacité d'adaptation aux évolutions ?

Concepts de base

Pour comprendre cette transformation, plusieurs concepts fondamentaux doivent être maîtrisés :

• Architecture monolithique : un système où toutes les fonctionnalités sont regroupées dans une seule application indivisible. Cette approche peut engendrer des difficultés de maintenance, de scalabilité et de déploiement.
• Architecture microservices : une approche qui divise une application en plusieurs services indépendants, chacun gérant un domaine fonctionnel spécifique. Chaque microservice est autonome, déployable indépendamment, et communique avec les autres via des interfaces bien définies.
• Domain Driven Design (DDD) : une méthode pour modéliser le domaine métier en le divisant en sous-domaines appelés "Bounded Contexts". Cette approche facilite la définition claire des responsabilités de chaque microservice.
• Développement à base de composants : structuration du logiciel en composants réutilisables et indépendants, favorisant la modularité.
• Polyglot persistence : utilisation de différents types de bases de données adaptées aux besoins spécifiques de chaque microservice, par exemple bases relationnelles ou NoSQL.
• DevOps : une culture et un ensemble de pratiques visant à rapprocher les équipes de développement et d'exploitation pour accélérer les cycles de livraison et améliorer la qualité logicielle.
• SCRUM : une méthodologie agile de gestion de projet qui organise le développement en sprints itératifs, favorisant la collaboration et l'adaptation continue.
• Conteneurs (Docker) : technologie permettant d'isoler et de déployer facilement les microservices dans des environnements standardisés.

Approche

Le projet a adopté une démarche progressive et méthodique pour la transformation de la plateforme :

• Un diagnostic initial de l'architecture monolithique existante a permis d'identifier ses limites, notamment en termes de rigidité, de difficulté de maintenance et de déploiement.
• La spécification des besoins fonctionnels a été réalisée en identifiant clairement les acteurs et en modélisant les cas d'utilisation. Cette étape a permis de découper la plateforme en sous-domaines fonctionnels.
• Une urbanisation fonctionnelle a été effectuée pour répartir les fonctionnalités en microservices cohérents, chacun correspondant à un domaine métier précis.
• La méthodologie SCRUM a été choisie pour organiser le développement en sprints, permettant une livraison incrémentale et une adaptation rapide aux retours.
• Trois microservices principaux ont été développés successivement : administration, portefeuille, et reporting. Pour chacun, la conception logicielle, le modèle de données, la réalisation et les tests unitaires ont été détaillés.
• Les microservices ont été isolés dans des conteneurs Docker pour faciliter leur déploiement et leur gestion.
• L'intégration des microservices a été assurée par un service de découverte (Eureka), une API Gateway pour la gestion des accès, et des mécanismes de communication synchrones et asynchrones (REST, RabbitMQ).
• Un système de monitoring applicatif a été mis en place, incluant le traçage distribué avec Spring Cloud Sleuth, la supervision statique avec Twitter Zipkin, et l'indexation des logs via la stack ELK (Elasticsearch, Logstash, Kibana).
• Enfin, le déploiement a été réalisé sur une plateforme Cloud Foundry, avec une surveillance des ressources allouées aux conteneurs.

Résultats

Le projet a permis de démontrer qu'une architecture microservices bien conçue peut répondre aux besoins d'agilité et d'évolutivité d'une plateforme de pilotage réseau. Les microservices développés ont montré une meilleure modularité, une facilité de déploiement indépendante, et une meilleure adaptation aux évolutions fonctionnelles.

Le monitoring avancé a permis de suivre précisément les performances et les temps de réponse, facilitant la détection rapide des anomalies et l'amélioration continue.

L'utilisation de conteneurs Docker et du PaaS Cloud Foundry a simplifié le déploiement et la gestion des services, tout en optimisant l'utilisation des ressources.

Limites et questions ouvertes

Le travail souligne que la transformation vers une architecture microservices nécessite un investissement initial important en termes de conception, développement et mise en place des outils de supervision et d'intégration. La complexité de la communication entre microservices, notamment la gestion des pannes et la tolérance aux erreurs, reste un défi à maîtriser.

De plus, la migration progressive d'un système monolithique vers des microservices peut engendrer des phases de coexistence complexes, qui demandent une organisation rigoureuse.

Enfin, le projet ne traite pas en détail des aspects liés à la sécurité des microservices, ni des impacts à long terme sur la maintenance et l'évolution continue du système.

Glossaire

• Architecture monolithique : modèle d'application où toutes les fonctionnalités sont regroupées dans un seul bloc indivisible.
• Microservices : architecture logicielle décomposant une application en services indépendants et spécialisés.
• Domain Driven Design (DDD) : approche de modélisation centrée sur le domaine métier et ses sous-domaines.
• DevOps : pratiques visant à rapprocher développement et exploitation pour accélérer la livraison logicielle.
• SCRUM : méthode agile de gestion de projet basée sur des itérations courtes appelées sprints.
• Conteneur Docker : technologie d'isolation et de déploiement d'applications dans des environnements standardisés.
• API Gateway : point d'entrée unique pour accéder aux différents microservices d'une application.
• Service de découverte (Eureka) : composant permettant aux microservices de s'enregistrer et de se localiser mutuellement.
• Traçage distribué : technique pour suivre les appels entre microservices afin d'analyser les performances et les erreurs.
• Stack ELK : ensemble d'outils (Elasticsearch, Logstash, Kibana) pour la collecte, l'indexation et la visualisation des logs.
• Polyglot persistence : utilisation de plusieurs types de bases de données adaptées aux besoins spécifiques des microservices.