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 diviser 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 à la conteneurisation
5. Conteneuriser l'application modulaire
6. Déployer l'application dans un cluster GKE

Dans ce tutoriel, vous allez découvrir le monolithe en procédant comme suit :

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 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 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 la mise à l'échelle 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 être mis à l'échelle indépendamment.

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 Google Cloud compte. 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 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 machine locale. 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 à partir du site Web officiel de Python.

Configurer votre environnement

Dans cette série de tutoriels, vous allez exécuter 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 où le monolithe peut 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 allez vous concentrer 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.

Procédez comme suit pour créer et activer un environnement virtuel :

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 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 monolithe. Les dépendances sont des bibliothèques Python externes sur lesquelles l'application s'appuie pour fonctionner correctement. Ces bibliothèques sont listées dans le fichier requirements.txt, et 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 intentionnellement simple et présente les fonctionnalités suivantes :

• Une page d'accueil qui affiche tous les livres de la bibliothèque
• Une page qui affiche des informations sur un livre
• Un bouton sur la page d'informations qui, lorsque vous cliquez dessus, 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 avec 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 monolithique :

   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, telles que son auteur et son année de publication.

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

   

Explorer les fichiers du dossier /monolith

Prenez le temps d'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 principaux dossiers et fichiers sont les suivants :

• Le dossier images/ contient les images de couverture de livre suivantes, qui s'affichent 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 chaque livre :

  • 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 de code complexe. Vous pouvez plutôt vous concentrer sur l'objectif principal de cette série de tutoriels, qui consiste à 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 ils ne sont pas directement pertinents pour 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 monolithe 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 élevée. 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 qualité production qui utilisent Python, envisagez 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 simultanéité, d'évolutivité et de production pour répondre aux exigences des applications réelles.

Examiner mono.py

Toute la logique du monolithe 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 adressées à ces URL. Lorsqu'une personne demande l'une de ces URL, soit en la consultant dans un navigateur Web, soit en effectuant la requête par programmation, Flask exécute le code correspondant pour gérer cette requête.

La capture d'écran suivante montre le fichier mono.py. Les cases 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'image statiques. Vous trouverez plus d'informations sur ces points de terminaison dans les sections suivantes.

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

• La ligne @app.route() qui définit un format d'URL (tel que /book/<id>/reviews).
• La 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 une page d'informations sur un livre, l'application envoie une requête à http://localhost:8080/book/1/reviews. Le gestionnaire de routes des avis sur les livres répond à cette requête en procédant comme suit :

1. Reconnaît que cette URL correspond à son modèle /book/<id>/reviews
2. Obtient les avis sur le livre 1 à partir d'un fichier JSON
3. Renvoie ces avis au frontend au format JSON

Le composant d'informations sur le 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 tutoriel suivant, vous verrez que Flask et les gestionnaires de routes jouent un rôle essentiel lorsque vous découvrirez comment le monolithe est converti en application modulaire.

Pourquoi les points de terminaison du monolithe sont 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 principales fonctionnalités de l'application, telles que 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 tutoriel suivant, 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 tutoriel suivant.

Tester les gestionnaires de routes du monolithe

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

• Gestionnaire de routes 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 routes des informations sur le livre : accédez à http://localhost:8080/book/1 pour afficher une page HTML contenant des informations sur un livre en particulier. 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 informations d'autres livres en modifiant le numéro d'ID (1, 2 ou 3) dans l'URL.
• Gestionnaire de routes des avis sur les livres : accédez à http://localhost:8080/book/3/reviews pour afficher les données JSON des avis sur le livre. Ces données sont traitées dans un format lisible lorsque vous cliquez sur Show Reviews sur la page d'informations du livre pour Melodic Mechanics.
• Gestionnaire de routes des images : 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 afin d'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 adressées à ces URL.

Étape suivante

Dans le tutoriel suivant, Modulariser le monolithe, vous verrez comment diviser le monolithe en modules indépendants.