Parcours de formation : Transformer un monolithe en application GKE – Comprendre le monolithe

Standard

Bienvenue dans le premier tutoriel d'une série qui vous explique comment prendre un monolithe (ou une application monolithique), le séparer en modules, conteneuriser les modules et déployer les images de conteneurs sur un cluster Google Kubernetes Engine (GKE). Ne vous inquiétez pas si vous ne comprenez pas certains de ces termes. Vous découvrirez leur signification au fur et à mesure de votre progression dans la série.

Le parcours de formation comprend les tutoriels suivants :

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

Dans ce tutoriel, vous allez découvrir le monolith en effectuant les étapes suivantes :

1. Configurer l'application sur votre ordinateur local
2. Découvrir ses fonctionnalités dans votre navigateur
3. Examiner le code.

Qu'est-ce qu'un monolithe ?

Avant de mettre en service l'exemple de monolithe Cymbal Books, il est important de comprendre ce qu'est un monolithe.

Un monolithe est une application dans laquelle tous les composants sont interconnectés et ne peuvent pas être mis à l'échelle indépendamment. Par exemple, si un certain nombre d'utilisateurs accèdent soudainement à la page de connexion de l'application, vous ne pouvez pas mettre à l'échelle uniquement le composant de connexion de manière indépendante. Vous devez plutôt faire évoluer l'ensemble de l'application, y compris les composants non liés, tels que le catalogue de produits ou le système de traitement des commandes.

En revanche, lorsqu'une application est divisée en modules indépendants, chaque module peut être mis à l'échelle séparément en fonction de ses besoins en ressources. Si vous hébergez l'application modulaire sur un cluster GKE, GKE peut même automatiser le scaling pour vous.

Le terme monolithique ne signifie pas que le code est mal organisé. Un monolithe peut être bien structuré, et ses composants peuvent être implémentés dans des zones distinctes du code. Ce qui distingue un monolithe, c'est que ces composants ne peuvent pas s'exécuter ni évoluer de manière indépendante.

Coûts

Vous pouvez suivre ce tutoriel sans frais. Toutefois, si vous suivez les étapes du dernier tutoriel de cette série, des frais seront facturés 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, ainsi que 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

Ce tutoriel nécessite Python version 3.13 sur votre ordinateur local. Pour vérifier la version de Python installée sur votre machine, exécutez la commande suivante :

python3 --version

Si votre version de Python est antérieure à la version 3.13, téléchargez et installez la dernière version depuis le site Web officiel de Python.

Configurer votre environnement

Dans cette série de tutoriels, vous exécutez différentes versions de l'application à différents endroits :

• Version monolithique sur votre machine locale
• La version modulaire sur votre ordinateur local
• La version conteneurisée dans Cloud Shell, puis dans un cluster GKE

Dans cette section, vous allez configurer un environnement virtuel sur votre machine locale dans lequel le monolith peut s'exécuter.

Télécharger le code

1. Ouvrez un terminal sur votre ordinateur local.

2. Clonez le dépôt GitHub du tutoriel sur votre ordinateur local :

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
   

   Le dossier kubernetes-engine-samples/quickstarts/monolith-to-microservices contient les trois dossiers suivants : monolith/, modular/ et containerized/. Dans ce tutoriel, vous vous concentrez exclusivement sur les fichiers du dossier monolith/.

Créer et activer un environnement virtuel

Un environnement virtuel fournit un espace isolé pour exécuter l'application. Il empêche les bibliothèques Python que vous devez installer pour l'application d'interférer avec d'autres projets Python sur votre système.

Pour créer et activer un environnement virtuel, procédez comme suit :

1. Dans le terminal que vous avez ouvert dans la section précédente, accédez au dossier suivant dans le dépôt que vous avez cloné précédemment sur votre machine :

   cd kubernetes-engine-samples/quickstarts/monolith-to-microservices
   

2. Créez un environnement virtuel appelé book-review-env :

   python3 -m venv book-review-env
   

   Il est judicieux de créer un environnement virtuel, car il s'agit d'une zone dans laquelle vous pouvez exécuter l'application de manière isolée. Cela permet de s'assurer que les dépendances et les configurations de l'application n'entrent pas en conflit avec d'autres logiciels ou bibliothèques de votre système.

3. Activez l'environnement virtuel à l'aide de la commande correspondant à votre système d'exploitation :

   macOS et Linux

   source book-review-env/bin/activate
   

   Windows

   book-review-env\Scripts\activate
   

4. Installez les dépendances Python pour le monolith. Les dépendances sont des bibliothèques Python externes dont l'application a besoin pour fonctionner correctement. Ces bibliothèques sont listées dans le fichier requirements.txt. La commande suivante les installe toutes dans votre environnement virtuel :

   pip install -r monolith/requirements.txt
   

Exécuter et explorer Cymbal Books dans le navigateur

L'application Cymbal Books est volontairement simple et présente les fonctionnalités suivantes :

• Une page d'accueil qui affiche tous les livres de la bibliothèque.
• Page affichant des informations sur un livre.
• Bouton de la page d'informations qui, lorsque l'utilisateur clique dessus, affiche les avis sur le livre.
• La possibilité d'afficher des images de couvertures de livres.

La page d'accueil affiche trois livres, chacun accompagné d'un bouton "Afficher les détails" :

Maintenant que l'environnement virtuel est actif et que les dépendances de l'application sont installées dans cet environnement, exécutez l'application en procédant comme suit :

1. Sur votre machine locale, accédez au répertoire monolith :

   cd monolith/
   

2. Démarrez l'application :

   python3 mono.py
   

3. Ouvrez votre navigateur Web et accédez à la page d'accueil de l'application : http://127.0.0.1:8080.

4. Pour accéder à la page d'informations d'un livre, cliquez sur Afficher les détails. La page d'informations fournit plus d'informations sur un livre, comme son auteur et son année de publication.

5. Pour afficher la liste des avis sur le livre, sur une page d'informations, cliquez sur Afficher les avis. L'image suivante montre la page d'informations du livre Zephyr's Timepiece et le premier avis sur le livre :

   

Explorez les fichiers du dossier /monolith.

Prenez quelques instants pour examiner les fichiers du dossier /monolith :

monolith/
├── mono.py
├── data/
│   ├── book-1.json
│   ├── book-2.json
│   ├── book-3.json
│   ├── reviews-1.json
│   ├── reviews-2.json
│   └── reviews-3.json
├── images/
│   ├── fungi_frontier.jpg
│   ├── melodic_mechanics.jpg
│   └── zephyrs_timepiece.jpg
├── static/
│   ├── styles_for_details.css
│   └── styles_for_home.css
└── templates/
    ├── book_details.html
    └── home.html

Les dossiers et fichiers clés sont les suivants :

• Le dossier images/ contient les images de couverture de livre suivantes, qui sont affichées dans l'application :

  • fungi_frontier.jpg
  • melodic_mechanics.jpg
  • zephyrs_timepiece.jpg

• Le dossier data/ contient les fichiers JSON suivants. Ces fichiers contiennent des avis sur les trois livres de la bibliothèque Cymbal Books, ainsi que des informations sur chacun d'eux :

  • reviews-1.json, reviews-2.json, reviews-3.json
  • book-1.json, book-2.json, book-3.json

Bien que les applications réelles utilisent souvent des bases de données, le stockage des données de l'application dans des fichiers JSON simplifie son implémentation. L'application exemple Cymbal Book utilise des fichiers JSON pour que vous n'ayez pas à gérer du code complexe. Au lieu de cela, vous pouvez vous concentrer sur l'objectif principal de cette série de tutoriels, qui est d'apprendre à modulariser et à conteneuriser le monolithe.

Vous pouvez ignorer les dossiers suivants, car les fichiers qu'ils contiennent sont importants pour la mise en page et la conception de l'application, mais ne sont pas directement liés à la logique de l'application :

• static/ : contient les fichiers CSS qui définissent le style de l'application.
• templates/ : contient les fichiers HTML qui définissent la mise en page et le contenu de l'application.

Comprendre le monolithe en tant qu'application Flask

Le monolith de ce tutoriel est conçu à l'aide de Flask, une bibliothèque Python permettant de créer des applications Web. Toutefois, Flask n'est généralement pas utilisé dans les environnements de production, car il ne prend pas en charge la simultanéité, ce qui peut entraîner des goulots d'étranglement des performances en cas de charge importante. Une application Flask manque également de fonctionnalités robustes de gestion des exceptions et d'évolutivité.

L'application Cymbal Books utilise Flask, car sa simplicité et sa configuration minimale permettent de mieux comprendre les concepts de modularisation et de conteneurisation. Pour les applications de niveau production qui utilisent Python, envisagez d'utiliser des alternatives à Flask, comme FastAPI ou Django. Vous pouvez également utiliser des frameworks adaptés à d'autres langages, tels que Spring Boot pour Java ou Express.js pour Node.js. Ces frameworks peuvent offrir de meilleures capacités de simultanéité, d'évolutivité et de production pour répondre aux exigences des applications du monde réel.

Examiner mono.py

Toute la logique du monolithique est contenue dans un seul fichier appelé mono.py. Ce fichier crée une application Flask. Une application Flask s'exécute sur un serveur Web, écoute des URL spécifiques (appelées "points de terminaison") et répond aux requêtes envoyées à ces URL. Lorsqu'un utilisateur demande l'une de ces URL (en la consultant dans un navigateur Web ou en effectuant la requête de manière programmatique), Flask exécute le code correspondant pour traiter cette requête.

La capture d'écran suivante montre le fichier mono.py. Les cases mettent en évidence les gestionnaires de routage de l'application. Alors qu'un gestionnaire sert la page d'accueil visible par l'utilisateur, les autres sont principalement utilisés pour la communication entre les modules, en fournissant des données au format JSON ou des fichiers d'images statiques. Vous trouverez plus d'informations sur ces points de terminaison dans les sections suivantes.

Dans la capture d'écran, les cadres mettent en évidence les gestionnaires de routes de l'application. Un gestionnaire de route se compose de deux parties :

• Ligne @app.route() qui définit un format d'URL (tel que /book/<id>/reviews).
• Fonction qui s'exécute lorsque le point de terminaison est appelé.

Un point de terminaison est une URL qui correspond au format défini dans la ligne @app.route().

Par exemple, lorsqu'un utilisateur clique sur Afficher les avis sur la page d'informations d'un livre, l'application envoie une requête à http://localhost:8080/book/1/reviews. Le gestionnaire de route "book reviews" répond à cette requête en effectuant les étapes suivantes :

1. reconnaît que cette URL correspond à son format /book/<id>/reviews.
2. Récupère les avis sur le livre 1 à partir d'un fichier JSON.
3. renvoie ces avis au frontend au format JSON.

Le composant de détails du livre affiche ensuite ces avis sous une forme lisible par l'humain sur la page Web. Le monolithe Cymbal Books utilise une bibliothèque Python appelée Flask pour simplifier l'implémentation des gestionnaires de routage. Dans le prochain tutoriel, vous verrez que Flask et les gestionnaires de routes jouent un rôle crucial lorsque vous apprendrez à convertir le monolith en application modulaire.

Pourquoi les points de terminaison du monolith sont-ils importants pour la modularisation ?

Les points de terminaison jouent un rôle essentiel dans les applications Flask, y compris l'application Cymbal Books. Toutefois, leur importance va au-delà de la conception monolithique, car la compréhension des points de terminaison est essentielle pour diviser l'application en modules indépendants. Voici pourquoi :

• Fonctionnalités essentielles : les points de terminaison implémentent les fonctionnalités principales de l'application, comme l'affichage de pages ou la récupération de données. Chaque fonctionnalité est liée à un point de terminaison spécifique.
• Modularisation : les points de terminaison agissent comme des limites naturelles, ou lignes de faille, pour diviser l'application en modules plus petits. Comme vous le verrez dans le prochain tutoriel, chaque module de la version modulaire de l'application correspond à une fonctionnalité avec ses propres points de terminaison.
• Communication : dans une conception modulaire, les points de terminaison permettent aux modules autonomes de communiquer entre eux. Comprendre comment les points de terminaison sont implémentés dans mono.py prépare le terrain pour la modularisation de l'application Cymbal Books en modules indépendants dans le prochain tutoriel.

Tester les gestionnaires de routes du monolith

Pour voir le type de données renvoyées par chaque gestionnaire de route, accédez aux points de terminaison suivants dans votre navigateur :

• Gestionnaire de routage de la page d'accueil : accédez à http://localhost:8080/ pour afficher une page HTML complète qui affiche le catalogue de livres.
• Gestionnaire de route des détails du livre : accédez à http://localhost:8080/book/1 pour afficher une page HTML contenant des informations sur un livre spécifique. La page récupère les données JSON d'un livre sur le serveur et les présente sous une forme lisible par l'humain à l'aide d'un modèle HTML. Essayez d'afficher les détails d'autres livres en modifiant le numéro d'ID (1, 2 ou 3) dans l'URL.
• Gestionnaire de route des avis sur les livres : accédez à http://localhost:8080/book/3/reviews pour afficher les données JSON des avis sur les livres. Ces données sont traitées dans un format lisible lorsque vous cliquez sur Show Reviews sur la page d'informations du livre Mécanique mélodique.
• Gestionnaire de route d'image : accédez à http://localhost:8080/images/fungi_frontier.jpg pour afficher un fichier image. La page d'accueil et les pages d'informations sur les livres appellent ce point de terminaison pour afficher les images de couverture des livres.

Résumé

Dans ce tutoriel, vous avez configuré et exécuté l'application monolithique Cymbal Books. Vous avez ensuite appris que le monolithe est implémenté en tant qu'application Flask, qui écoute des URL spécifiques, appelées points de terminaison, et répond aux requêtes effectuées sur ces URL.

Étapes suivantes

Dans le tutoriel suivant, Modulariser le monolithique, vous verrez comment décomposer le monolithique en modules indépendants.