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

Bienvenue dans le premier tutoriel d'une série qui vous explique comment prendre un monolith (ou une application monolithique), le séparer en modules, conteneuriser les modules et déployer les images de conteneur 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 machine locale.
2. Explorer ses fonctionnalités dans votre navigateur.
3. Examiner le code.

Qu'est-ce qu'un monolithe ?

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

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. Au lieu de cela, vous devez mettre à l'échelle 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 différentes zones 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, 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

Ce tutoriel nécessite Python version 3.13 sur votre ordinateur local. Pour vérifier quelle version de Python est installée sur votre ordinateur, 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 à partir du site Web officiel de Python.

Configurer votre environnement

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

• La version monolithique sur votre machine locale
• La version modulaire sur votre machine locale
• 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 monolithe pourra s'exécuter.

Télécharger le code

1. Ouvrez un terminal sur votre machine locale.

2. Clonez le dépôt GitHub du tutoriel sur votre machine locale :

   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é sur votre machine précédemment :

   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 garantit 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 sur la page d'informations qui, lorsqu'il est cliqué, affiche les avis sur le livre.
• La possibilité d'afficher des images de couvertures de livres.

La page d'accueil affiche trois livres, et un bouton "Afficher les détails" s'affiche à côté de chacun d'eux :

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 sur un livre, cliquez sur Afficher les détails. La page d'informations fournit plus de détails 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 sur le livre Le sablier de Zéphyr et le premier avis sur le livre :

   

Explorer 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

Voici les principaux dossiers et fichiers :

• 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 du monde réel 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 de code complexe. 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 créé à 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 facilitent la compréhension des concepts de modularisation et de conteneurisation. Pour les applications de niveau production qui utilisent Python, envisagez d'utiliser des alternatives à Flask, telles que 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 concurrence, 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 dans 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 y accédant dans un navigateur Web ou en envoyant 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 cadres mettent en évidence les gestionnaires de routes 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 :

• La 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 modèle 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 des avis sur les livres répond à cette requête en effectuant les étapes suivantes :

1. reconnaît que cette URL correspond à son modèle /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 "Détails du livre" affiche ensuite ces avis sous une forme lisible sur la page Web. Le monolithe Cymbal Books utilise une bibliothèque Python appelée Flask pour simplifier l'implémentation des gestionnaires de routes. Dans le prochain tutoriel, vous verrez que Flask et les gestionnaires de routes jouent un rôle crucial lorsque vous apprendrez comment le monolithique est converti 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 de base : 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 associée à un point de terminaison spécifique.
• Modularisation : les points de terminaison agissent comme des limites naturelles ou des 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 permet de préparer la modularisation de l'application Cymbal Books en modules indépendants dans le prochain tutoriel.

Tester les gestionnaires de routes du monolith

Pour savoir quel type de données chaque gestionnaire de route renvoie, accédez aux points de terminaison suivants dans votre navigateur :

• Gestionnaire de route de la page d'accueil : accédez à http://localhost:8080/ pour afficher une page HTML complète qui présente 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'utilisateur à 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 monolithe, vous verrez comment décomposer le monolithe en modules indépendants.