Parcours de formation: transformer un monolithe en application GKE - Modulariser le monolithe

Il s'agit du deuxième tutoriel d'un parcours de formation qui vous explique comment modulariser et conteneuriser une application monolithique.

Le parcours de formation comprend les tutoriels suivants :

  1. Présentation
  2. Comprendre le monolithe
  3. Modulariser le monolithe (ce tutoriel)
  4. Préparer l'application modulaire pour la conteneurisation
  5. Conteneuriser l'application modulaire
  6. Déployer l'application dans un cluster GKE

Dans le tutoriel précédent, Comprendre le monolithe, vous avez découvert une application monolithique appelée Cymbal Books. Vous avez exécuté le monolith sur votre machine locale et appris que différentes parties du monolith communiquent entre elles via leurs points de terminaison.

Dans ce tutoriel, vous allez découvrir comment diviser le monolith en modules pour le préparer à la conteneurisation. Vous n'avez pas besoin d'effectuer vous-même les étapes de modularisation, car le code a déjà été mis à jour pour vous. Votre tâche consiste à suivre le tutoriel et à explorer la version modulaire de l'application dans le dépôt pour voir en quoi elle diffère du monolithe d'origine.

Coûts

Vous pouvez suivre ce tutoriel sans frais. Toutefois, les étapes du dernier tutoriel de cette série entraînent des frais sur votre compteGoogle Cloud . Les coûts commencent lorsque vous activez GKE et déployez l'application Cymbal Books sur un cluster GKE. Ces coûts incluent les frais par cluster pour GKE, comme indiqué sur la page des tarifs, et les frais d'exécution des VM Compute Engine.

Pour éviter des frais inutiles, assurez-vous de désactiver GKE ou de supprimer le projet une fois ce tutoriel terminé.

Avant de commencer

Avant de commencer ce tutoriel, assurez-vous d'avoir suivi le premier tutoriel, Comprendre le monolithe. Dans ce tutoriel, vous allez exécuter la version modulaire de Cymbal Books sur votre ordinateur local. Pour ce faire, vous devez avoir déjà configuré votre environnement. Si vous avez déjà suivi le premier tutoriel, vous avez cloné un dépôt GitHub. Les trois versions de l'application Cymbal Books se trouvent dans ce dépôt, dans les dossiers suivants :

  • monolith/
  • modular/
  • containerized/

Vérifiez que ces dossiers se trouvent sur votre ordinateur avant de continuer. Assurez-vous également que l'environnement virtuel book-review-env est actif. Si vous avez besoin d'aide pour l'activer, consultez Créer et activer un environnement virtuel dans le premier tutoriel. L'activation de l'environnement garantit que la version modulaire de l'application dispose de tout ce dont elle a besoin pour s'exécuter.

Qu'est-ce que la modularisation ?

Dans ce tutoriel, vous allez apprendre à modulariser l'application monolithique afin de la préparer à la conteneurisation. La modularisation est le processus de transformation d'un monolithe en application modulaire. Comme vous l'avez appris dans le tutoriel précédent, la caractéristique distinctive d'un monolithe est que ses composants ne peuvent pas s'exécuter ni évoluer indépendamment. Une application modulaire est différente : sa fonctionnalité est divisée en modules qui peuvent s'exécuter et évoluer indépendamment.

Bien que la modularisation et la conteneurisation soient souvent effectuées ensemble, elles sont traitées comme des étapes distinctes dans cette série de tutoriels pour vous aider à comprendre clairement chaque concept. Ce tutoriel explique comment modulariser un monolithique. Un tutoriel ultérieur explique comment conteneuriser l'application modulaire.

Modularisation incrémentielle

Dans les environnements de production, vous modularisez généralement un composant à la fois. Vous modularisez le composant, intégrez le module au monolithe et vous assurez que tout fonctionne avant de travailler sur le composant suivant. Cet état hybride, dans lequel certains composants sont modularisés tandis que d'autres restent partie intégrante du monolithe, est appelé microlithe. Toutefois, dans ce tutoriel, tous les composants de l'application sont modularisés en même temps pour fournir un exemple complet de la façon de modulariser une application.

Modulariser le monolithe

Dans cette section, vous allez découvrir comment le monolith Cymbal Books a été divisé en modules distincts. Des étapes sont fournies pour vous aider à comprendre le processus de modularisation afin que vous puissiez l'appliquer à vos propres applications. Toutefois, vous n'avez pas besoin d'effectuer ces étapes dans ce tutoriel, car le dépôt cloné inclut déjà la version modulaire de l'application :

  1. Identifier les différentes fonctions de l'application
  2. Créer les modules
  3. Activer la communication entre les modules
  4. N'autorisez chaque module à accéder qu'aux données dont il a besoin.

Identifier les différentes fonctions de l'application

La première étape de la modularisation du monolithe Cymbal Books consiste à identifier ses principales fonctions. Dans l'exemple d'application Cymbal Books, le monolithe comporte les quatre fonctions distinctes suivantes :

  • Diffuser la page d'accueil
  • Afficher les détails d'un livre
  • Diffuser des avis sur des livres
  • Diffuser des images de couverture de livres

Créer les modules

Comme vous l'avez vu dans le tutoriel précédent, le monolithe est une application Flask unique qui implémente les quatre fonctions identifiées dans la section précédente en tant que gestionnaires de routes. Pour modulariser l'application, vous prenez chaque gestionnaire de route et le placez dans sa propre application Flask. Au lieu d'une application Flask avec quatre gestionnaires de route, vous avez quatre applications Flask, chacune avec un seul gestionnaire de route à l'intérieur.

Le schéma suivant illustre cette transformation d'une seule application Flask en quatre applications Flask distinctes :

Transformation du monolithe en application modulaire

Dans l'application modulaire, chaque application Flask s'exécute indépendamment et écoute sur un port différent (8080, 8081, 8082, 8083), comme indiqué dans le diagramme. Cette configuration est nécessaire, car lorsque vous testerez l'application modulaire plus tard dans ce tutoriel, vous exécuterez tous les modules sur la même machine. Chaque application a besoin d'un numéro de port différent pour éviter les conflits.

Le module de la page d'accueil a deux responsabilités : il sert la page d'accueil et communique avec les autres modules pour collecter les données qui doivent être affichées sur une page Web. Chacun des autres modules est axé sur une seule fonction : diffuser des avis, des informations ou des images. Ces modules ne communiquent pas entre eux. Ils ne répondent qu'aux requêtes du module de la page d'accueil.

Bien que le module de la page d'accueil ait un rôle de coordination supplémentaire, l'application reste véritablement modulaire, car vous pouvez mettre à jour n'importe quel module sans affecter les autres. La grande application Flask unique a été divisée en quatre parties, chacune gérant une partie spécifique des fonctionnalités de l'application.

Activer la communication entre les modules

Une fois les modules créés, l'étape suivante consiste à s'assurer qu'ils peuvent communiquer entre eux. Dans l'application Cymbal Books, cette logique de communication a déjà été implémentée pour vous. Dans le dossier modular/ du code que vous avez téléchargé, vous pouvez voir que chacune des principales fonctionnalités de l'application (diffusion de la page d'accueil, des détails des livres, des avis et des images) est implémentée en tant qu'application Flask distincte. Chacune de ces applications définit son propre point de terminaison HTTP, et les modules communiquent en envoyant des requêtes HTTP à ces points de terminaison.

La modularisation du monolithe Cymbal Books a été simple. Le monolithique comporte des composants bien définis qui sont implémentés en tant que gestionnaires de routes, et chaque gestionnaire de routes possède un point de terminaison bien défini. Lorsque ces gestionnaires de routes sont placés dans des applications Flask distinctes, ils conservent leur capacité à communiquer via leurs points de terminaison. Le simple fait de placer les gestionnaires de routes dans des applications Flask distinctes crée les modules et leur permet de communiquer entre eux.

Une approche courante pour la communication entre les modules consiste à implémenter des API REST, qui permettent aux modules de s'envoyer des requêtes HTTP. C'est ainsi que cela fonctionne dans Cymbal Books : chaque module définit des points de terminaison REST à l'aide des outils intégrés de Flask. Une autre approche populaire est gRPC, qui permet aux modules d'appeler directement les fonctions des autres modules.

Pourquoi la communication est simple dans Cymbal Books

Chaque module de l'application modulaire est une application Flask distincte qui s'exécute dans un serveur Web. Par exemple, le module de page d'accueil sert la page d'accueil, tandis que le module d'informations sur le livre sert les informations sur le livre. La communication entre les modules est simple, car les serveurs Web sont conçus pour gérer les requêtes et les réponses HTTP. Chaque module expose des points de terminaison que les autres modules peuvent utiliser pour demander des données.

N'autorisez chaque module à accéder qu'aux données dont il a besoin.

Pour modulariser correctement le monolith, vous devez vous assurer que chaque module n'a accès qu'aux données dont il a besoin. Ce principe, connu sous le nom d'isolation des données, est un élément essentiel pour créer une architecture véritablement modulaire.

Une erreur fréquente lors de la modularisation consiste à autoriser plusieurs modules à accéder aux mêmes données, comme une seule base de données. Ce type d'implémentation peut entraîner les problèmes suivants :

  • Couplage étroit : si la structure des données partagées change (par exemple, si une table de base de données est renommée ou si une colonne est ajoutée), chaque module qui s'appuie sur ces données doit être mis à jour. Une modularisation appropriée permet d'éviter ce problème.
  • Problèmes de tolérance aux pannes : lorsque plusieurs modules utilisent la même source de données, les échecs d'exécution dans un module (requêtes non valides ou trafic excessif, par exemple) peuvent perturber d'autres modules. Une défaillance dans une partie du système peut entraîner des défaillances dans d'autres parties du système.
  • Goulots d'étranglement des performances : une source de données unique et partagée peut devenir un goulot d'étranglement, ce qui signifie qu'elle peut ralentir l'ensemble de l'application lorsque plusieurs modules tentent d'interagir avec elle.

Pour éviter ces problèmes, chaque module doit avoir sa propre source de données.

Si Cymbal Books avait utilisé une base de données pour stocker ses données, vous auriez dû répliquer ou partitionner la base de données pour appliquer l'isolation des données et vous assurer que chaque module n'accède qu'aux données dont il a besoin. La réplication consiste à conserver des copies distinctes de la base de données pour chaque module, tandis que le partitionnement limite l'accès à des tables ou des lignes spécifiques. Les deux approches empêchent les modules d'interférer avec les données des autres modules.

Le schéma suivant compare l'architecture monolithique de l'application de livres à son architecture modulaire :

Schéma montrant comment les versions monolithique et modulaire de l'application gèrent les données

L'implémentation du monolithique ne respecte pas le principe d'isolation des données, car les fonctions du monolithique accèdent à un seul répertoire data/.

En revanche, l'application modulaire permet d'isoler les données dans une certaine mesure en les divisant en répertoires distincts et en veillant à ce que chaque module n'interagisse qu'avec les données qui lui sont attribuées :

  • Le module d'informations sur le livre n'obtient les données que du répertoire details_data/.
  • Le module d'avis sur les livres n'obtient les données que du répertoire reviews_data/.
  • Le module d'images n'obtient les données que du répertoire images/.

Dans un prochain tutoriel, vous verrez comment la conteneurisation de l'application peut améliorer l'isolation des données.

Ce que vous venez de voir

Dans le secteur du développement de logiciels, vous rencontrez souvent les termes microservices et systèmes distribués. Cette section explique comment ces termes s'appliquent à l'implémentation modulaire de Cymbal Books.

Microservices

Les microservices sont des modules autonomes qui effectuent des tâches spécifiques. Ces modules communiquent avec d'autres modules via des interfaces telles que des points de terminaison.

Chaque module de la version modulaire de Cymbal Books correspond à cette définition et peut donc être considéré comme un microservice. Lorsque l'application modulaire est conteneurisée dans un tutoriel ultérieur, le code qui s'exécute dans un conteneur peut également être appelé microservice, car il s'agit du même code qui s'exécute dans un module.

Systèmes distribués

Un système distribué se compose de modules indépendants qui communiquent sur un réseau pour atteindre un objectif commun. Ces modules peuvent s'exécuter sur différentes machines, mais ils fonctionnent ensemble comme un seul système.

L'application modulaire Cymbal Books correspond également à cette définition : ses modules s'exécutent indépendamment et échangent des données via HTTP, mais ils fonctionnent ensemble comme un seul système. Dans la section suivante, vous exécuterez tous les modules sur une seule machine pour plus de simplicité, mais ce n'est pas obligatoire. Chaque module pourrait tout aussi bien s'exécuter sur un serveur différent. C'est pourquoi la version modulaire de l'application Cymbal Books peut être classée comme système distribué.

Tester l'implémentation modulaire

Maintenant que vous avez vu comment le monolithe Cymbal Books est transformé en application modulaire dont les modules sont des applications Flask, vous pouvez tester l'application et constater que chaque module s'exécute indépendamment.

Dans ce tutoriel, vous allez exécuter les modules sur la même machine. Toutefois, vous pouvez également exécuter chaque module sur un serveur distinct : comme chaque module est autonome, il peut communiquer avec les autres modules via leurs points de terminaison.

Configurer votre environnement

Pour vous préparer aux tests, procédez comme suit :

  1. Dans votre terminal, accédez au répertoire modular du dépôt cloné :

    cd modular

  2. Assurez-vous que l'environnement virtuel book-review-env est actif. Si vous avez besoin d'un rappel sur les étapes d'activation, consultez Créer et activer un environnement virtuel.

Démarrer l'application Flask

Le dossier /modular contient un script Bash qui démarre toutes les applications Flask simultanément. Chaque module de l'application écoute sur un port unique, tel que 8080 ou 8081 :

  • Application Flask de la page d'accueil (home.py) : port 8080
  • Application Flask pour les détails du livre (book_details.py) : port 8081
  • Application Flask d'avis sur les livres (book_reviews.py) : port 8082
  • Application Flask "Images" (images.py) : port 8083

Chaque module doit écouter un numéro de port unique, car ils s'exécutent tous sur la même machine. Si chaque module se trouvait sur un serveur différent, chacun pourrait écouter sur le même numéro de port sans créer de conflits de ports.

Exécutez le script bash avec cette commande :

bash ./start_services.sh

Le script crée un fichier journal distinct pour chaque application Flask (par exemple, home.py.log, book_details.py.log) afin de vous aider à identifier les problèmes de démarrage. Une fois le script exécuté, le message suivant s'affiche :

All services have been started. Access the app at http://localhost:8080/

Tester chaque application Flask

Testez les modules en accédant aux URL suivantes dans votre navigateur :

  • Page d'accueil : http://localhost:8080/ affiche la page d'accueil de l'application Cymbal Books modularisée. Cette page récupère les informations sur les livres, les avis et les images en envoyant des requêtes aux autres modules.
  • Détails du livre : http://localhost:8081/book/1 renvoie les détails du livre dont l'ID est 1. Cette réponse est une donnée JSON que l'application met ensuite en forme et affiche de manière plus lisible.
  • Avis sur les livres : http://localhost:8082/book/1/reviews récupère et renvoie les avis sur le livre dont l'ID est 1. Les avis sont au format JSON. Le module de la page d'accueil demande ces données et les intègre à la page d'informations sur le livre.
  • Images : http://localhost:8083/images/fungi_frontier.jpg diffuse l'image de la couverture du livre Fungi Frontier. Si l'URL est correcte, l'image devrait se charger directement dans votre navigateur.

Arrêter les applications Flask

Lorsque vous avez terminé les tests, arrêtez toutes les applications Flask avec cette commande :

kill $(cat home.py.pid book_details.py.pid book_reviews.py.pid images.py.pid)

Résumé

Ce tutoriel vous a montré comment modulariser le monolithe Cymbal Books. Le processus comprend les étapes suivantes :

  1. Identifier les différents composants de l'application
  2. Créer les modules
  3. S'assurer que chaque module n'a accès qu'aux données dont il a besoin

Vous avez ensuite testé l'implémentation modulaire sur votre machine locale.

Étapes suivantes

Dans le prochain tutoriel, Préparer l'application modulaire pour la conteneurisation, vous apprendrez à préparer l'application modulaire pour la conteneurisation en mettant à jour les points de terminaison afin d'utiliser les noms de service Kubernetes au lieu de localhost.