Parcours de formation: transformer un monolithe en application GKE - Déployer l'application dans un cluster GKE

Il s'agit du cinquième et dernier tutoriel d'un parcours de formation qui vous apprend à 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
  4. Préparer l'application modulaire pour la conteneurisation
  5. Conteneuriser l'application modulaire
  6. Déployer l'application sur un cluster GKE (ce tutoriel)

Dans le tutoriel précédent, Conteneuriser l'application modulaire, vous avez préparé l'application modulaire Cymbal Books pour le déploiement. Vous avez conteneurisé les modules de l'application, testé les conteneurs obtenus et transféré les images de conteneur vers Artifact Registry.

Dans ce tutoriel, vous allez déployer l'application conteneurisée sur un cluster Google Kubernetes Engine. Cette étape permet de transformer l'application Cymbal Books en un système modulaire et évolutif qui s'exécute sur un cluster Kubernetes.

Coûts

Les étapes de ce tutoriel entraînent des frais sur votre compte Google Cloud. Les coûts commencent lorsque vous activez GKE et déployez l'application exemple Cymbal Books. 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

Avant de commencer ce tutoriel, assurez-vous d'avoir terminé les tutoriels précédents de la série. Pour obtenir une présentation de l'ensemble de la série et des liens vers des tutoriels spécifiques, consultez Parcours de formation : Transformer un monolithe en application GKE – Présentation.

En particulier, vous devez avoir effectué les étapes du tutoriel précédent, Conteneuriser l'application modulaire.

Configurer le cluster GKE

Avant de pouvoir déployer l'application modulaire Cymbal Books, vous devez d'abord créer un cluster GKE. Ce cluster fournit l'infrastructure dans laquelle les conteneurs de votre application s'exécuteront.

Dans ce tutoriel, vous allez utiliser la gcloud CLI pour créer le cluster. Vous pouvez également utiliser la consoleGoogle Cloud , qui fournit une interface utilisateur graphique (IUG) pour créer et gérer des ressources Google Cloudtelles que des clusters GKE.

Créer et valider un cluster GKE

Un cluster GKE fournit les ressources de calcul nécessaires pour exécuter vos conteneurs dans Kubernetes. Suivez ces étapes pour créer un cluster à l'aide de la gcloud CLI.

  1. Accédez à la consoleGoogle Cloud .

  2. Dans la console, cliquez sur le bouton Activer Cloud Shell : Activer Cloud Shell

    Une session Cloud Shell s'ouvre dans un cadre situé en bas de la console.

  3. Définissez votre projet par défaut dans la Google Cloud CLI :

    gcloud config set project PROJECT_ID

    Remplacez PROJECT_ID par l'ID du projet que vous avez créé ou sélectionné dans la section Sélectionner ou créer un projet du tutoriel précédent. Google Cloud Un ID de projet est une chaîne unique qui permet de différencier votre projet de tous les autres projets dans Google Cloud. Pour trouver l'ID du projet, accédez au sélecteur de projet. Sur cette page, vous pouvez consulter les ID de projet de chacun de vos projets Google Cloud.

  4. Créez un cluster GKE :

    gcloud container clusters create CLUSTER_NAME \
    --zone=ZONE \
    --num-nodes=2

    Remplacez les éléments suivants :

    • CLUSTER_NAME : nom de votre cluster, par exemple cymbal-cluster.

    • ZONE : zone dans laquelle vous souhaitez créer le cluster, par exemple us-central1-a ou europe-west1-b. Pour obtenir la liste complète des zones disponibles, consultez Régions et zones.

  5. Récupérez les identifiants du cluster afin que la CLI kubectl puisse s'y connecter :

    gcloud container clusters get-credentials CLUSTER_NAME \
    --zone=ZONE

    Cette commande met à jour votre fichier de configuration Kubernetes, qui est stocké par défaut dans ~/.kube/config. Ce fichier de configuration contient les identifiants dont kubectl a besoin pour interagir avec votre cluster GKE.

  6. Vérifiez que kubectl est connecté au cluster en listant les nœuds du cluster :

    kubectl get nodes

    Si la configuration réussit, cette commande liste les nœuds de votre cluster GKE. Étant donné que vous avez créé le cluster avec --num-nodes=2, vous devriez voir des informations sur deux nœuds, semblables à ce qui suit :

    NAME                                         STATUS    ROLES    AGE    VERSION
gke-nov18-default-pool-6a8f9caf-bryg   Ready     <none>   30s    v1.30.8-gke.1128000
gke-nov18-default-pool-6a8f9caf-ut0i   Ready     <none>   30s    v1.30.8-gke.1128000

    Dans cet exemple, les deux nœuds sont à l'état Ready. Cet état signifie que le cluster GKE est prêt à héberger vos charges de travail conteneurisées.

Déployer l'application

Maintenant que vous avez créé un cluster GKE, vous pouvez y déployer l'application Cymbal Books. Pour déployer une application sur un cluster, vous devez appliquer le fichier manifeste Kubernetes au cluster.

Appliquer le fichier manifeste Kubernetes

Dans Cloud Shell, déployez l'application sur le cluster GKE en exécutant les commandes suivantes :

  1. Accédez au répertoire racine de l'application conteneurisée :

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

  2. Appliquez le fichier manifeste Kubernetes :

    kubectl apply -f kubernetes_manifest.yaml

La commande précédente demande à Kubernetes de créer les ressources spécifiées dans le fichier kubernetes-manifest.yaml. Ces ressources incluent des services, un déploiement et des pods.

Vous avez rencontré les services pour la première fois dans la section Modifier le code modulaire du tutoriel Préparer l'application modulaire pour la conteneurisation. Dans ce tutoriel, vous avez mis à jour le code de l'application pour utiliser les noms de service au lieu de localhost. Cette mise à jour permet à Kubernetes de router les requêtes entre les modules et garantit que les modules peuvent communiquer entre eux au sein d'un cluster. Maintenant, lorsque vous appliquez le fichier manifeste, Kubernetes crée les services à l'intérieur du cluster.

Un déploiement est un objet de l'API Kubernetes qui vous permet d'exécuter plusieurs instances dupliquées de pods répartis entre les nœuds d'un cluster. La section suivante explique ce que sont les pods.

Qu'est-ce qu'un pod Kubernetes ?

Dans le tutoriel précédent, vous avez créé une image de conteneur pour chaque module de l'application Cymbal Books. Par exemple, vous avez créé des images de conteneur basées sur les modules home_app et book_details_app.

Lorsque vous utilisez la commande kubectl apply pour déployer le fichier manifeste Kubernetes, Kubernetes extrait vos images de conteneur d'Artifact Registry dans le cluster. Dans le cluster, les images de conteneurs deviennent des conteneurs, et les conteneurs s'exécutent dans des pods.

Un pod est un environnement isolé dans lequel les conteneurs s'exécutent. Il effectue les tâches suivantes :

  • Alloue le processeur et la mémoire : un pod fournit les ressources dont les conteneurs ont besoin pour fonctionner.
  • Fournit une mise en réseau : chaque pod possède sa propre adresse IP. Cela permet au pod de communiquer avec d'autres pods.

Les pods s'exécutent sur des nœuds, qui sont les machines qui fournissent la puissance de calcul du cluster. Kubernetes attribue automatiquement des pods aux nœuds et les répartit entre les nœuds du cluster pour réduire le risque de surcharge d'un nœud. Cette distribution aide le cluster à utiliser efficacement ses ressources de calcul et de mémoire.

Vérifier le déploiement

Après avoir appliqué le fichier manifeste Kubernetes avec la commande kubectl apply, vérifiez que l'application a bien été déployée sur le cluster. Pour vérifier le déploiement, assurez-vous que les pods et les services fonctionnent correctement.

Vérifier les pods

Pour afficher les pods de votre cluster, exécutez la commande suivante :

kubectl get pods

Cette commande liste les pods et leur état actuel. Recherchez la colonne ÉTAT pour vérifier que tous les pods sont marqués comme Running, ce qui indique qu'ils sont en cours d'exécution et prêts à traiter les requêtes. Le résultat attendu ressemble à ce qui suit :

NAME                             READY   STATUS    RESTARTS   AGE
home-app-67d59c6b6d-abcde        1/1     Running   0          30s
book-details-app-6d8bcbc58f-xyz  1/1     Running   0          30s
book-reviews-app-75db4c4d7f-def  1/1     Running   0          30s
images-app-7f8c75c79c-ghi        1/1     Running   0          30s

L'état d'un pod apparaît initialement comme Pending lors de sa création et du démarrage de ses conteneurs. Si un pod reste à l'état Pending pendant une période prolongée, il est possible que le cluster ne dispose pas de suffisamment de ressources pour que ce pod passe à l'état Running. Si l'état d'un pod est CrashLoopBackOff, il peut y avoir un problème avec le conteneur. La procédure de dépannage est fournie plus loin dans le tutoriel.

Vérifier les services

Les services permettent la communication entre les pods et permettent aux clients externes (par exemple, les utilisateurs, les scripts automatisés ou les outils de surveillance) d'accéder à l'application. Pour afficher les services de votre cluster, exécutez la commande suivante :

kubectl get services

Le résultat de cette commande ressemble à ceci :

NAME               TYPE           CLUSTER-IP      EXTERNAL-IP       PORT(S)        AGE
home-app-service   LoadBalancer   10.12.3.4       35.185.1.2        80:30837/TCP   30s
details-service    ClusterIP      10.12.3.5       <none>            80/TCP         30s
reviews-service    ClusterIP      10.12.3.6       <none>            80/TCP         30s
images-service     LoadBalancer   10.12.3.7       34.125.6.3        80:32014/TCP   30s

Voici les champs clés à observer dans le résultat :

  • TYPE : ce champ indique comment le service est exposé. Les services de type LoadBalancer fournissent un accès externe à l'application.
  • EXTERNAL-IP : pour un service de type LoadBalancer, le champ EXTERNAL-IP affiche l'adresse IP publique que les utilisateurs peuvent saisir dans leur navigateur Web pour accéder à l'application. Pour un service de type ClusterIP, ce champ est vide, car les services ClusterIP ne sont accessibles qu'au sein du cluster.

Tester le déploiement

Après avoir déployé l'application Cymbal Books sur le cluster GKE, vérifiez que l'application est accessible et que les conteneurs peuvent communiquer entre eux.

Accéder à l'application

Pour vérifier que l'application est accessible, procédez comme suit :

  1. Récupérez l'adresse IP externe de home-app-service :

    kubectl get services

    Recherchez la colonne **EXTERNAL-IP** dans le résultat, puis notez l'adresse IP associée à home-app-service.

  2. Ouvrez un navigateur Web et saisissez l'URL suivante :

    http://EXTERNAL-IP

    Remplacez EXTERNAL-IP par l'adresse IP que vous avez trouvée à l'étape précédente.

  3. Vérifiez que la page d'accueil de l'application Cymbal Books se charge correctement.

Vérifier la communication entre les services

Les conteneurs de l'application Cymbal Books s'appuient sur les services pour échanger des informations. Pour vous assurer que les conteneurs peuvent communiquer efficacement, procédez comme suit :

  1. Récupérez l'adresse IP externe de home-app-service comme décrit précédemment.

  2. Utilisez l'interface de l'application pour tester les interactions entre les conteneurs. Pour ce faire, vérifiez que les fonctionnalités suivantes fonctionnent en cliquant sur tous les liens disponibles dans l'interface de l'application :

    • Vérifiez les images de couverture des livres : assurez-vous qu'elles se chargent correctement sur la page d'accueil et sur la page d'informations des livres. Si c'est le cas, les conteneurs home_app et book_details_app communiquent correctement avec le conteneur images_app.
    • Afficher les détails d'un livre : accédez à la page d'informations d'un livre depuis la page d'accueil. Si les informations d'un livre s'affichent, cela signifie que le conteneur home_app communique correctement avec book_details_app.
    • Afficher les critiques de livres : cliquez sur un lien de critique de livre pour vérifier que le conteneur home_app peut communiquer avec le conteneur book_reviews_app.

Votre application s'exécute désormais sur un cluster GKE.

Félicitations ! Vous avez vu comment transformer une application monolithique en un système modulaire et conteneurisé qui s'exécute sur un cluster GKE actif. Au cours de ce tutoriel, vous avez appris à diviser un code étroitement couplé en modules indépendants, à créer et à transférer des images de conteneur vers un dépôt, à définir des fichiers manifestes Kubernetes et à déployer votre application du registre vers GKE. Il s'agit d'une réussite majeure, qui reflète les étapes concrètes suivies par les équipes pour moderniser les applications pour le cloud.

Dépannage

Si l'application ne répond pas ou si les conteneurs ne communiquent pas, suivez les étapes de dépannage ci-dessous pour diagnostiquer et résoudre les problèmes courants.

Vérifier l'état de vos pods

Commencez par lister tous les pods de votre cluster pour déterminer s'ils s'exécutent comme prévu :

kubectl get pods

Examinez le résultat pour vérifier que chaque pod est à l'état Running. Si un pod n'est pas en cours d'exécution, notez son nom pour l'inspecter plus en détail.

Inspecter les journaux des pods

Si un pod ne traite pas correctement les requêtes, consultez ses journaux pour rechercher les éventuels messages d'erreur :

kubectl logs POD_NAME

Remplacez POD_NAME par le nom du pod que vous souhaitez inspecter. Cette commande est utile pour identifier les problèmes de démarrage ou les erreurs d'exécution.

Décrivez un pod pour obtenir des informations détaillées.

Si un pod reste dans un état non Running pendant plus de cinq minutes (par exemple, s'il est dans un état Pending, ContainerCreating ou CrashLoopBackOff), vous pouvez afficher des informations détaillées sur l'état et les événements du pod à l'aide de la commande suivante :

kubectl describe pod POD_NAME

Remplacez POD_NAME par le nom du pod pour lequel vous souhaitez obtenir des informations détaillées.

La section Events de la sortie peut indiquer que des contraintes de ressources ou des problèmes d'extraction d'images empêchent le pod de démarrer correctement.

Vérifier la configuration du service

Assurez-vous que vos services sont correctement configurés, en particulier celui qui expose le module Home avec une adresse IP externe. Affichez la liste des services à l'aide de la commande suivante :

kubectl get services

Si vous remarquez que le module Service pour la maison possède une adresse EXTERNAL-IP listée comme Pending, exécutez la commande suivante :

kubectl describe service SERVICE_NAME

Remplacez SERVICE_NAME par le nom du service de module domotique.

Cette commande fournit plus de détails sur la configuration du service et vous aide à identifier les retards dans l'attribution de l'adresse IP externe ou d'autres problèmes de configuration.

Vérifier les événements du cluster

Vous pouvez examiner les événements du cluster pour déterminer si un problème affecte plusieurs composants de votre cluster :

kubectl get events

Cette commande peut déterminer si des problèmes de ressources ou de réseau plus généraux affectent votre déploiement.

Effectuer un nettoyage des ressources

L'exécution d'un cluster GKE entraîne des coûts. Une fois ce tutoriel terminé, nettoyez vos ressources pour éviter des frais supplémentaires. Suivez ces étapes pour supprimer le cluster et, éventuellement, l'ensemble du projet.

Supprimer le cluster GKE

Pour supprimer le cluster GKE, exécutez la commande suivante :

gcloud container clusters delete CLUSTER_NAME
    --zone=ZONE

Remplacez les éléments suivants :

  • CLUSTER_NAME : nom du cluster que vous avez créé, par exemple cymbal-cluster.

  • ZONE : zone dans laquelle le cluster a été créé, par exemple us-central1-a.

Lorsque vous y êtes invité, confirmez la suppression.

Vérifier que le cluster est supprimé

Pour vous assurer que le cluster a bien été supprimé, exécutez la commande suivante :

gcloud container clusters list

Le cluster ne devrait plus apparaître dans le résultat. Si c'est le cas, patientez quelques instants et réessayez.

(Facultatif) Supprimer le projet Google Cloud

Si vous avez créé un projet Google Cloud spécifiquement pour ce tutoriel et que vous n'en avez plus besoin, vous pouvez le supprimer entièrement. Google Cloud La suppression du projet entraîne la suppression de toutes les ressources et arrête la facturation pour le projet :

  1. Dans la console Google Cloud , ouvrez la page Gérer les ressources.
  2. Sélectionnez le projet que vous souhaitez supprimer.
  3. Cliquez sur Supprimer le projet et suivez les instructions pour confirmer.

Résumé de la série

Félicitations ! En suivant ce parcours de formation, vous avez appris les principes de base de la conversion d'une application monolithique en application modulaire et conteneurisée qui s'exécute sur un cluster Kubernetes. Les étapes suivantes résument le processus :

  1. Comprendre le monolithe

    • Exploration de la structure de l'application monolithique Cymbal Books.
    • Configurer un environnement Python local pour exécuter le monolith et tester ses points de terminaison.
    • Vous avez compris le codebase de l'application pour la préparer à la modularisation.

  2. Modulariser le monolithe

    • Vous avez appris à diviser le code monolithique en modules distincts. Chaque module gère une fonctionnalité distincte, comme l'affichage des détails ou des avis sur les livres.
    • Vous avez vu comment ces modules sont implémentés en tant qu'applications Flask indépendantes s'exécutant sur différents ports.
    • Test de l'application modularisée.

  3. Préparer le code modulaire pour la conteneurisation

    • Vous avez appris que vous deviez mettre à jour les URL dans home.py pour utiliser les noms de service au lieu de localhost.
    • Vous avez appris comment le fichier manifeste Kubernetes définit les services qui permettent aux modules de l'application, qui communiquent déjà entre eux, de se trouver les uns les autres dans le contexte d'un cluster Kubernetes.

  4. Conteneuriser l'application modulaire

    • Vous avez configuré un projet Google Cloud et cloné l'application depuis GitHub dans Cloud Shell.
    • Créé des images de conteneur pour chaque module à l'aide de Docker et testé les conteneurs en local.
    • Transférez les images de conteneur vers Artifact Registry pour préparer l'application au déploiement sur un cluster.
    • Mise à jour du fichier manifeste Kubernetes pour faire référence aux chemins d'accès aux images de conteneurs dans Artifact Registry.

  5. Déployez l'application sur un cluster GKE (le tutoriel que vous suivez actuellement) :

    • Vous avez créé un cluster GKE.
    • Déployé les images de conteneur depuis Artifact Registry vers le cluster GKE.
    • Testé la version finale de l'application, qui est désormais évolutive et s'exécute dans un environnement Kubernetes.

Étapes suivantes

Pour une formation pratique plus approfondie sur la création de clusters, consultez notre série Parcours de formation : Applications évolutives.