GSP699

Présentation

Pourquoi migrer une application monolithique vers une architecture de microservices ? Décomposer une application en microservices présente les avantages suivants (la plupart d'entre eux proviennent du fait que les microservices sont faiblement couplés) :

• Les microservices peuvent être testés et déployés indépendamment. Plus l'unité de déploiement est petite, plus le déploiement est facile.
• Ils peuvent être intégrés dans différents langages et frameworks. Vous pouvez choisir la meilleure technologie pour chaque microservice en fonction de son cas d'utilisation spécifique.
• Ils peuvent être gérés par différentes équipes. Les limites entre les microservices permettent de dédier une équipe à un ou à plusieurs d'entre eux.
• En passant aux microservices, vous assouplissez les dépendances entre les équipes. Chaque équipe ne doit se préoccuper que des API des microservices dont elles dépendent. Elle n'a pas besoin de réfléchir à la manière dont ces microservices sont implémentés, à leurs cycles de publication, etc.
• Vous pouvez concevoir plus aisément des solutions en prévision d'une défaillance. En établissant des limites claires entre les services, il est plus facile de déterminer la marche à suivre si l'un d'entre eux ne fonctionne plus.

Toutefois, les microservices présentent quelques inconvénients par rapport aux monolithes :

• Dans la mesure où une application reposant sur des microservices correspond à un réseau de différents services qui interagissent souvent de manière peu visible, la complexité globale du système tend à augmenter.
• Contrairement aux composants internes d'un monolithe, les microservices communiquent via un réseau. Dans certaines circonstances, cela peut être considéré comme un problème de sécurité. Istio résout ce problème en chiffrant automatiquement le trafic entre les microservices.
• Il peut être difficile d'atteindre le même niveau de performance qu'avec une approche monolithique en raison des latences entre les services.
• Le comportement de votre système n'est pas causé par un seul service, mais par nombre d'entre eux et par leurs interactions. Pour cette raison, il est plus difficile de comprendre le comportement de votre système en production (son observabilité). Là encore, Istio constitue une solution au problème.

Dans cet atelier, vous allez déployer une application monolithique existante sur un cluster Google Kubernetes Engine, puis vous la décomposerez en microservices. Kubernetes est une plate-forme permettant d'assurer la gestion, l'hébergement, le scaling et le déploiement de conteneurs, qui constituent un moyen portable d'empaqueter et d'exécuter du code. Les conteneurs sont bien adaptés au modèle de microservices, dans lequel chaque microservice peut s'exécuter dans son propre conteneur.

Diagramme de l'architecture de microservices

Vous allez commencer par décomposer le monolithe en trois microservices successifs : Orders (Commandes), Products (Produits) et Frontend (Interface). Ensuite, vous créerez une image Docker pour chaque microservice à l'aide de Cloud Build, puis vous déploierez et exposerez les microservices sur Google Kubernetes Engine (GKE) avec un service Kubernetes de type LoadBalancer. Vous suivrez cette procédure pour chacun des services tout en les refactorisant simultanément hors du monolithe. Pendant toute la durée de ce processus, le monolithe et les microservices s'exécuteront en même temps jusqu'à ce que vous soyez en mesure de supprimer le monolithe.

Objectifs de l'atelier

• Décomposer un monolithe en microservices
• Créer un cluster Google Kubernetes Engine
• Créer une image Docker
• Déployer des images Docker sur Kubernetes

Préparation

Avant de cliquer sur le bouton "Démarrer l'atelier"

Lisez ces instructions. Les ateliers sont minutés, et vous ne pouvez pas les mettre en pause. Le minuteur, qui démarre lorsque vous cliquez sur Démarrer l'atelier, indique combien de temps les ressources Google Cloud resteront accessibles.

Cet atelier pratique vous permet de suivre les activités dans un véritable environnement cloud, et non dans un environnement de simulation ou de démonstration. Des identifiants temporaires vous sont fournis pour vous permettre de vous connecter à Google Cloud le temps de l'atelier.

Pour réaliser cet atelier :

• Vous devez avoir accès à un navigateur Internet standard (nous vous recommandons d'utiliser Chrome).

Remarque : Ouvrez une fenêtre de navigateur en mode incognito (recommandé) ou de navigation privée pour effectuer cet atelier. Vous éviterez ainsi les conflits entre votre compte personnel et le compte temporaire de participant, qui pourraient entraîner des frais supplémentaires facturés sur votre compte personnel.

• Vous disposez d'un temps limité. N'oubliez pas qu'une fois l'atelier commencé, vous ne pouvez pas le mettre en pause.

Remarque : Utilisez uniquement le compte de participant pour cet atelier. Si vous utilisez un autre compte Google Cloud, des frais peuvent être facturés à ce compte.

Démarrer l'atelier et se connecter à la console Google Cloud

1. Cliquez sur le bouton Démarrer l'atelier. Si l'atelier est payant, une boîte de dialogue s'affiche pour vous permettre de sélectionner un mode de paiement. Sur la gauche, vous trouverez le panneau "Détails concernant l'atelier", qui contient les éléments suivants :

   • Le bouton "Ouvrir la console Google Cloud"
   • Le temps restant
   • Les identifiants temporaires que vous devez utiliser pour cet atelier
   • Des informations complémentaires vous permettant d'effectuer l'atelier

2. Cliquez sur Ouvrir la console Google Cloud (ou effectuez un clic droit et sélectionnez Ouvrir le lien dans la fenêtre de navigation privée si vous utilisez le navigateur Chrome).

   L'atelier lance les ressources, puis ouvre la page "Se connecter" dans un nouvel onglet.

   Conseil : Réorganisez les onglets dans des fenêtres distinctes, placées côte à côte.

   Remarque : Si la boîte de dialogue Sélectionner un compte s'affiche, cliquez sur Utiliser un autre compte.

3. Si nécessaire, copiez le nom d'utilisateur ci-dessous et collez-le dans la boîte de dialogue Se connecter.

   {{{user_0.username | "Username"}}}

   Vous trouverez également le nom d'utilisateur dans le panneau "Détails concernant l'atelier".

4. Cliquez sur Suivant.

5. Copiez le mot de passe ci-dessous et collez-le dans la boîte de dialogue Bienvenue.

   {{{user_0.password | "Password"}}}

   Vous trouverez également le mot de passe dans le panneau "Détails concernant l'atelier".

6. Cliquez sur Suivant.

   Important : Vous devez utiliser les identifiants fournis pour l'atelier. Ne saisissez pas ceux de votre compte Google Cloud. Remarque : Si vous utilisez votre propre compte Google Cloud pour cet atelier, des frais supplémentaires peuvent vous être facturés.

7. Accédez aux pages suivantes :

   • Acceptez les conditions d'utilisation.
   • N'ajoutez pas d'options de récupération ni d'authentification à deux facteurs (ce compte est temporaire).
   • Ne vous inscrivez pas à des essais sans frais.

Après quelques instants, la console Cloud s'ouvre dans cet onglet.

Remarque : Pour accéder aux produits et services Google Cloud, cliquez sur le menu de navigation ou saisissez le nom du service ou du produit dans le champ Recherche.

Activer Cloud Shell

Cloud Shell est une machine virtuelle qui contient de nombreux outils pour les développeurs. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud. Cloud Shell vous permet d'accéder via une ligne de commande à vos ressources Google Cloud.

1. Cliquez sur Activer Cloud Shell  en haut de la console Google Cloud.

2. Passez les fenêtres suivantes :

   • Accédez à la fenêtre d'informations de Cloud Shell.
   • Autorisez Cloud Shell à utiliser vos identifiants pour effectuer des appels d'API Google Cloud.

Une fois connecté, vous êtes en principe authentifié et le projet est défini sur votre ID_PROJET : . Le résultat contient une ligne qui déclare l'ID_PROJET pour cette session :

Your Cloud Platform project in this session is set to {{{project_0.project_id | "PROJECT_ID"}}}

gcloud est l'outil de ligne de commande pour Google Cloud. Il est préinstallé sur Cloud Shell et permet la complétion par tabulation.

3. (Facultatif) Vous pouvez lister les noms des comptes actifs à l'aide de cette commande :

gcloud auth list

4. Cliquez sur Autoriser.

Résultat :

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Facultatif) Vous pouvez lister les ID de projet à l'aide de cette commande :

gcloud config list project

Résultat :

[core] project = {{{project_0.project_id | "PROJECT_ID"}}} Remarque : Pour consulter la documentation complète sur gcloud, dans Google Cloud, accédez au guide de présentation de la gcloud CLI.

Définissez la configuration du projet et de la zone par défaut :

gcloud config set compute/zone {{{project_0.default_zone | (zone)}}}

Tâche 1 : Cloner le dépôt source

Vous allez utiliser une application monolithique existante d'un site Web d'e-commerce fictif, comportant une page d'accueil simple, une page de produits et une page d'historique des commandes. Il nous suffira de cloner la source de notre dépôt git, ce qui nous permettra de nous concentrer sur la décomposition de l'application en microservices et sur leur déploiement sur Google Kubernetes Engine (GKE).

• Exécutez les commandes suivantes pour cloner le dépôt git dans votre instance Cloud Shell et pour accéder au répertoire approprié. Vous allez également installer les dépendances NodeJS de manière à pouvoir tester votre monolithe avant de le déployer :

cd ~ git clone https://github.com/googlecodelabs/monolith-to-microservices.git cd ~/monolith-to-microservices ./setup.sh

L'exécution de ce script peut prendre quelques minutes.

Tâche 2 : Créer un cluster GKE

Maintenant que votre environnement de développement est opérationnel, vous avez besoin d'un cluster Kubernetes pour déployer votre monolithe, puis les microservices. Pour être en mesure de créer un cluster, vous devez commencer par vérifier que les API appropriées sont bien activées.

1. Exécutez la commande suivante pour activer l'API Containers de façon à pouvoir utiliser Google Kubernetes Engine :

gcloud services enable container.googleapis.com

2. Exécutez la commande ci-dessous pour créer un cluster GKE nommé fancy-cluster avec 3 nœuds :

gcloud container clusters create fancy-cluster --num-nodes 3 --machine-type=e2-standard-4 Avertissement : Si vous obtenez un message d'erreur signalant qu'aucune région ni zone n'a été spécifiée, reportez-vous à la section sur la configuration de l'environnement pour vérifier que la zone de calcul par défaut a bien été définie.

La création du cluster peut prendre plusieurs minutes.

3. Une fois cette opération terminée, exécutez la commande suivante pour afficher les trois instances de VM de nœud de calcul du cluster :

gcloud compute instances list

Résultat :

NAME ZONE MACHINE_TYPE PREEMPTIBLE INTERNAL_IP EXTERNAL_IP STATUS gke-fancy-cluster-default-pool-ad92506d-1ng3 {{{project_0.default_zone | (zone)}}} e2-standard-4 10.150.0.7 XX.XX.XX.XX RUNNING gke-fancy-cluster-default-pool-ad92506d-4fvq {{{project_0.default_zone | (zone)}}} e2-standard-4 10.150.0.5 XX.XX.XX.XX RUNNING gke-fancy-cluster-default-pool-ad92506d-4zs3 {{{project_0.default_zone | (zone)}}} e2-standard-4 10.150.0.6 XX.XX.XX.XX RUNNING

Vous pouvez également visualiser votre cluster Kubernetes et les informations associées dans la console Cloud. Pour ce faire, cliquez sur le menu de navigation, faites-le défiler vers le bas jusqu'à la section Kubernetes Engine, puis cliquez sur Clusters.

Le cluster nommé fancy-cluster doit s'afficher.

Félicitations ! Vous venez de créer votre premier cluster Kubernetes.

Cliquez sur Vérifier ma progression pour valider l'objectif. Créer un cluster GKE

Tâche 3 : Déployer le monolithe existant

Cet atelier porte sur la décomposition d'un monolithe en microservices. Vous devez donc disposer d'une application monolithique opérationnelle.

• Exécutez le script suivant pour déployer une application monolithique sur votre cluster GKE :

cd ~/monolith-to-microservices ./deploy-monolith.sh

Accéder au monolithe

1. Pour trouver l'adresse IP externe de l'application monolithique, exécutez la commande suivante :

kubectl get service monolith

Le résultat obtenu doit ressembler à ceci :

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE monolith 10.3.251.122 203.0.113.0 80:30877/TCP 3d

2. Si le résultat présente la valeur <pending> (<en attente>) pour l'adresse IP externe, patientez une minute, puis réexécutez la commande.

3. Une fois que vous avez déterminé l'adresse IP externe de votre monolithe, copiez-la. Saisissez cette URL (telle que http://203.0.113.0) dans votre navigateur pour vérifier si le monolithe est accessible.

Remarque : Retenez cette adresse IP, car vous la réutiliserez plus tard. Vous pourrez toujours la retrouver en exécutant la même commande.

Vous devriez voir la page d'accueil du site Web monolithique. Cette page d'accueil est une page statique qui sera diffusée par le microservice Frontend (Interface) par la suite. Votre monolithe s'exécute désormais entièrement sur Kubernetes.

Cliquez sur Vérifier ma progression pour valider l'objectif. Déployer un monolithe existant

Tâche 4 : Migrer les commandes vers un microservice

Maintenant que votre site Web monolithique s'exécute sur GKE, vous allez décomposer chaque service en microservice. En principe, il convient d'étudier les services afin de déterminer la manière dont ils peuvent être décomposés. Généralement, chaque microservice correspond à une partie spécifique de l'application (par exemple, le domaine d'activité).

Dans cet atelier, vous allez créer un exemple et décomposer chaque service en fonction du domaine d'activité : Orders (Commandes), Products (Produits) et Frontend (Interface). Le code a déjà été migré pour vous, ce qui vous permet de vous concentrer sur la création et le déploiement des services sur Google Kubernetes Engine (GKE).

Créer le microservice "Orders"

Le premier service à décomposer est le service Orders (Commandes). Vous allez utiliser le codebase fourni et créer un conteneur Docker distinct pour ce service.

Créer un conteneur Docker à l'aide de Cloud Build

Le codebase est déjà disponible, vous allez donc commencer par créer un conteneur Docker de votre service Orders (Commandes) avec Cloud Build.

En temps normal, vous devez adopter une approche en deux étapes consistant à créer un conteneur Docker, puis à le transférer vers un registre afin de stocker l'image pour que GKE puisse l'extraire. Mais avec Cloud Build, vous pouvez créer le conteneur Docker et placer l'image dans Artifact Registry en une seule opération !

Google Cloud Build compressera les fichiers du répertoire et les déplacera vers un bucket Cloud Storage. Ensuite, le processus de compilation récupérera tous les fichiers du bucket et utilisera le Dockerfile pour exécuter le processus de compilation Docker. Étant donné que le flag --tag est spécifié avec l'hôte en tant que gcr.io pour l'image Docker, l'image Docker résultante sera transférée vers Artifact Registry.

1. Exécutez les commandes suivantes pour créer votre conteneur Docker et pour le transférer vers Artifact Registry :

cd ~/monolith-to-microservices/microservices/src/orders gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/orders:1.0.0 .

Ce processus prend une minute, mais vous devriez obtenir ensuite un résultat semblable à celui-ci dans le terminal :

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ID CREATE_TIME DURATION SOURCE IMAGES STATUS 1ae295d9-63cb-482c-959b-bc52e9644d53 2019-08-29T01:56:35+00:00 33S gs://_cloudbuild/source/1567043793.94-abfd382011724422bf49af1558b894aa.tgz gcr.io//orders:1.0.0 SUCCESS

2. Pour consulter votre historique de compilation ou suivre le processus en temps réel, dans la console, recherchez Cloud Build, puis cliquez sur le résultat Cloud Build.

3. Sur la page Historique, vous pouvez voir une liste de toutes vos compilations. Seule celle que vous venez de créer devrait apparaître. Si vous cliquez sur l'ID de la compilation, vous pouvez consulter tous les détails de cette compilation, y compris la sortie du journal.

4. Vous pouvez consulter l'image de conteneur créée à partir de la page "Informations sur le build". Pour cela, cliquez sur l'onglet Détails de l'exécution situé dans la section de droite, puis affichez l'image.

Déployer le conteneur sur GKE

Maintenant que vous avez conteneurisé le site Web et transféré le conteneur vers Google Artifact Registry, le moment est venu de déployer ce conteneur sur Kubernetes.

Kubernetes représente les applications sous forme de pods, qui sont eux-mêmes des unités représentant un conteneur (ou un groupe de conteneurs fortement couplés). Le pod est la plus petite unité déployable dans Kubernetes. Dans ce tutoriel, chaque pod contient uniquement votre conteneur de microservices.

Pour déployer et gérer des applications sur un cluster GKE, vous devez communiquer avec le système de gestion de clusters Kubernetes. Pour ce faire, vous utilisez généralement l'outil de ligne de commande kubectl depuis Cloud Shell.

Commencez par créer une ressource de déploiement. Le déploiement gère plusieurs copies de votre application, appelées instances répliquées, et planifie leur exécution sur les nœuds individuels du cluster. Dans ce cas précis, le déploiement n'exécute qu'un seul pod de l'application. Les déploiements garantissent ce résultat en créant un ReplicaSet (ensemble d'instances répliquées). Le rôle du ReplicaSet est de garantir l'exécution systématique du nombre d'instances répliquées spécifié.

La commande kubectl create deployment ci-dessous demande à Kubernetes de créer sur votre cluster un déploiement nommé Orders (Commandes) avec 1 instance répliquée.

• Exécutez la commande suivante pour déployer votre application :

kubectl create deployment orders --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/orders:1.0.0 Remarque : Nous vous recommandons d'utiliser un fichier YAML pour déclarer vos changements au cluster Kubernetes (par exemple, la création ou la modification d'un déploiement ou d'un service) et de stocker ces changements à l'aide d'un système de gestion de code source tel que GitHub. Pour en savoir plus, consultez la documentation sur les déploiements Kubernetes.

Vérifier le déploiement

• Pour vérifier que le déploiement a bien été créé, exécutez la commande suivante :

kubectl get all

Il peut s'écouler quelques instants avant que le pod passe à l'état "Running" (En cours d'exécution).

Résultat :

NAME READY STATUS RESTARTS AGE pod/monolith-779c8d95f5-dxnzl 1/1 Running 0 15h pod/orders-5bc6969d76-kdxkk 1/1 Running 0 21s NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE service/kubernetes ClusterIP 10.39.240.1 443/TCP 19d service/monolith LoadBalancer 10.39.241.130 34.74.209.57 80:30412/TCP 15h NAME READY UP-TO-DATE AVAILABLE AGE deployment.apps/monolith 1/1 1 1 15h deployment.apps/orders 1/1 1 1 21s NAME DESIRED CURRENT READY AGE replicaset.apps/monolith-779c8d95f5 1 1 1 15h replicaset.apps/orders-5bc6969d76 1 1 1 21s

Ici, vous pouvez voir le déploiement qui est actuellement exécuté, le replicaset avec le nombre de pods souhaité (1), et le pod qui est en cours d'exécution. Apparemment, tous les éléments ont bien été créés.

Vous pouvez également visualiser vos déploiements Kubernetes dans la console Cloud. Pour ce faire, accédez au menu de navigation, puis cliquez sur Kubernetes Engine > Charges de travail.

Exposer le conteneur GKE

Vous avez déployé votre application sur GKE, mais vous ne pouvez pas y accéder en dehors du cluster. Par défaut, les conteneurs que vous exécutez sur GKE ne sont pas accessibles depuis Internet, car ils sont dépourvus d'adresses IP externes. Vous devez donc exposer explicitement votre application au trafic Internet via une ressource de service. Un service offre une compatibilité réseau et IP avec les pods de votre application. GKE crée une adresse IP externe et un équilibreur de charge.

Pour les besoins de cet atelier, l'exposition du service a été simplifiée. Généralement, vous devez sécuriser vos points de terminaison publics à l'aide d'une passerelle API.

Lorsque vous avez déployé le service Orders (Commandes), vous l'avez exposé sur le port 8081 en interne via un déploiement Kubernetes. Pour exposer ce service en externe, vous devez créer un service Kubernetes de type LoadBalancer pour acheminer le trafic externe du port 80 vers le port interne 8081.

• Exécutez la commande suivante pour exposer votre site Web à Internet :

kubectl expose deployment orders --type=LoadBalancer --port 80 --target-port 8081

Accéder au service

GKE attribue l'adresse IP externe à la ressource de service, et non à la ressource de déploiement.

• Pour connaître l'adresse IP externe provisionnée par GKE pour votre application, inspectez le service à l'aide de la commande kubectl get service :

kubectl get service orders

Résultat :

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE orders 10.3.251.122 203.0.113.0 80:30877/TCP 3s

Une fois que vous avez déterminé l'adresse IP externe de votre application, copiez-la. Enregistrez cette adresse pour l'étape suivante lorsque vous modifierez votre monolithe afin de le faire pointer vers le nouveau service Orders (Commandes).

Reconfigurer le monolithe

Vous avez supprimé le service Orders (Commandes) du monolithe. Vous allez donc devoir modifier le monolithe pour le faire pointer vers le nouveau microservice Orders externe.

Lorsque vous décomposez un monolithe, vous transférez des fragments de code d'un codebase unique vers plusieurs microservices et vous les déployez séparément. Puisque les microservices s'exécutent sur un autre serveur, vous ne pouvez plus référencer l'URL des services sous la forme d'un chemin absolu. Vous devez router le trafic vers l'adresse du serveur du microservice Orders (Commandes). Pour ce faire, vous devrez arrêter le service monolithe afin de mettre à jour l'URL de chaque service qui a été décomposé. Prenez cet aspect en compte lorsque vous prévoierez de faire passer vos microservices et le monolithe en production au cours du processus de migration vers une architecture de microservices.

Vous devez modifier le fichier de configuration du monolithe pour le faire pointer vers l'adresse IP du nouveau microservice Orders (Commandes).

1. À l'aide de l'éditeur nano, remplacez l'URL locale par l'adresse IP du microservice Orders (Commandes) :

cd ~/monolith-to-microservices/react-app nano .env.monolith

Lorsque l'éditeur s'ouvre, votre fichier devrait se présenter comme suit :

REACT_APP_ORDERS_URL=/service/orders REACT_APP_PRODUCTS_URL=/service/products

2. Modifiez le format de la chaîne REACT_APP_ORDERS_URL en remplaçant sa valeur par l'adresse IP de votre microservice Orders (Commandes) comme suit :

REACT_APP_ORDERS_URL=http://<ORDERS_IP_ADDRESS>/api/orders REACT_APP_PRODUCTS_URL=/service/products

3. Appuyez sur CTRL+O, sur ENTRÉE, puis sur CTRL+X pour enregistrer le fichier dans l'éditeur nano.

4. Testez le nouveau microservice en accédant à l'URL que vous venez de définir dans le fichier. La page Web doit renvoyer une réponse JSON de votre microservice Orders (Commandes).

5. Ensuite, recréez l'interface du monolithe, puis répétez le processus de compilation pour créer le conteneur du monolithe et le redéployer sur le cluster GKE :

npm run build:monolith

6. Créez un conteneur Docker à l'aide de Cloud Build :

cd ~/monolith-to-microservices/monolith gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0 .

7. Déployez le conteneur sur GKE :

kubectl set image deployment/monolith monolith=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0

8. Vérifiez que l'application appelle désormais le microservice Orders (Commandes) en accédant à l'application monolithique dans votre navigateur et en affichant la page Orders (Commandes). Tous les ID de commande doivent se terminer par le suffixe "-MICROSERVICE", comme indiqué ci-dessous :

9. Cliquez sur Vérifier ma progression pour valider l'objectif. Migrer les commandes vers un microservice

Tâche 5 : Migrer les produits vers un microservice

Créer un microservice de produits (Products)

Vous allez continuer à décomposer les services en migrant maintenant le service Products (Produits). Suivez la même procédure que précédemment. Exécutez les commandes suivantes pour créer un conteneur Docker, le déployer et l'exposer via un service Kubernetes.

1. Créez un conteneur Docker à l'aide de Cloud Build :

cd ~/monolith-to-microservices/microservices/src/products gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/products:1.0.0 .

2. Déployez le conteneur sur GKE :

kubectl create deployment products --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/products:1.0.0

3. Exposez le conteneur GKE :

kubectl expose deployment products --type=LoadBalancer --port 80 --target-port 8082

4. Recherchez l'adresse IP publique du service Products (Produits) en procédant comme vous l'avez fait pour le service Orders (Commandes) :

kubectl get service products

Résultat :

NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGE products 10.3.251.122 203.0.113.0 80:30877/TCP 3d

Vous utiliserez cette adresse IP à l'étape suivante lorsque vous reconfigurerez le monolithe pour le faire pointer vers le nouveau microservice Products (Produits).

Reconfigurer le monolithe

1. À l'aide de l'éditeur nano, remplacez l'URL locale par l'adresse IP du nouveau microservice Products comme suit :

cd ~/monolith-to-microservices/react-app nano .env.monolith

Lorsque l'éditeur s'ouvre, votre fichier devrait se présenter comme suit :

REACT_APP_ORDERS_URL=http://<ORDERS_IP_ADDRESS>/api/orders REACT_APP_PRODUCTS_URL=/service/products

2. Modifiez le format de la chaîne REACT_APP_PRODUCTS_URL en remplaçant sa valeur par l'adresse IP de votre microservice Products (Produits) comme suit :

REACT_APP_ORDERS_URL=http://<ORDERS_IP_ADDRESS>/api/orders REACT_APP_PRODUCTS_URL=http://<PRODUCTS_IP_ADDRESS>/api/products

3. Appuyez sur CTRL+O, sur ENTRÉE, puis sur CTRL+X pour enregistrer le fichier.

4. Testez le nouveau microservice en accédant à l'URL que vous venez de définir dans le fichier. La page Web doit renvoyer une réponse JSON du microservice Products (Produits).

5. Ensuite, recréez l'interface du monolithe puis répétez le processus de compilation pour créer le conteneur du monolithe et le redéployer sur le cluster GKE. Pour ce faire, exécutez les commandes suivantes :

6. Recréez les fichiers de configuration du monolithe :

npm run build:monolith

7. Créez un conteneur Docker à l'aide de Cloud Build :

cd ~/monolith-to-microservices/monolith gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:3.0.0 .

8. Déployez le conteneur sur GKE :

kubectl set image deployment/monolith monolith=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:3.0.0

9. Vérifiez que l'application appelle désormais le nouveau microservice Products (Produits) en accédant à l'application monolithique dans votre navigateur et en affichant la page Products (Produits). Tous les noms de produit doivent commencer par le préfixe "MS-", comme indiqué ci-dessous :

10. Cliquez sur Vérifier ma progression pour valider l'objectif. Migrer les produits vers un microservice

Tâche 6 : Migrer l'interface vers un microservice

La dernière étape du processus de migration consiste à déplacer le code de l'interface (frontend) vers un microservice et à supprimer le monolithe. Lorsque vous aurez terminé cette étape, vous aurez migré l'intégralité du monolithe vers une architecture de microservices.

Créer un microservice Frontend (Interface)

Suivez la même procédure que dans les deux sections précédentes pour créer un microservice Frontend (Interface).

Précédemment, lorsque vous avez recréé le monolithe, vous avez mis à jour la configuration pour qu'elle pointe vers le monolithe. Maintenant, vous allez devoir utiliser la même configuration pour le microservice Frontend (Interface).

1. Exécutez les commandes suivantes pour copier les fichiers de configuration de l'URL des microservices dans le codebase du microservice Frontend (Interface) :

cd ~/monolith-to-microservices/react-app cp .env.monolith .env npm run build

2. Une fois cette opération effectuée, suivez la même procédure que dans les sections précédentes. Exécutez les commandes suivantes pour créer un conteneur Docker, le déployer et l'exposer via un service Kubernetes.

3. Créez un conteneur Docker à l'aide de Google Cloud Build :

cd ~/monolith-to-microservices/microservices/src/frontend gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/frontend:1.0.0 .

4. Déployez le conteneur sur GKE :

kubectl create deployment frontend --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/frontend:1.0.0

5. Exposez le conteneur GKE :

kubectl expose deployment frontend --type=LoadBalancer --port 80 --target-port 8080

6. Cliquez sur Vérifier ma progression pour valider l'objectif. Migrer l'interface vers un microservice

Supprimer le monolithe

Maintenant que tous les services s'exécutent sous forme de microservices, vous pouvez supprimer l'application monolithique. Dans une véritable migration, cette opération impliquerait d'autres modifications, notamment au niveau des paramètres DNS, pour faire en sorte que les noms de domaine existants pointent vers le nouveau microservice Frontend (Interface) de l'application.

• Exécutez les commandes suivantes pour supprimer le monolithe :

kubectl delete deployment monolith kubectl delete service monolith

Tester votre travail

Pour vous assurer que tout fonctionne correctement, vérifiez que l'ancienne adresse IP de votre service monolithe est désormais inopérante et que la nouvelle adresse IP de votre service Frontend (Interface) héberge bien la nouvelle application.

• Pour afficher la liste de l'ensemble des services et des adresses IP, exécutez la commande suivante :

kubectl get services

Vous devriez obtenir un résultat semblable à celui-ci :

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE frontend LoadBalancer 10.39.246.135 35.227.21.154 80:32663/TCP 12m kubernetes ClusterIP 10.39.240.1 443/TCP 18d orders LoadBalancer 10.39.243.42 35.243.173.255 80:32714/TCP 31m products LoadBalancer 10.39.250.16 35.243.180.23 80:32335/TCP 21m

Une fois que vous avez déterminé l'adresse IP externe de votre microservice Frontend (Interface), copiez-la. Saisissez cette URL (telle que http://203.0.113.0) dans votre navigateur pour vérifier si l'interface est accessible. Votre site Web doit être identique à celui dont vous disposiez avant de décomposer le monolithe en microservices.

Félicitations !

Vous avez décomposé votre application monolithique en microservices que vous avez déployés sur Google Kubernetes Engine.

Étapes suivantes et ressources supplémentaires

• Documentation Docker
• Documentation Kubernetes
• Documentation Google Kubernetes Engine (GKE)
• Documentation Google Cloud Build
• Migrer une application monolithique vers des microservices
• Bonnes pratiques concernant les microservices
• Vidéo d'une étude de cas portant sur l'hébergement d'une application Web statique sur Google Cloud

Formations et certifications Google Cloud

Les formations et certifications Google Cloud vous aident à tirer pleinement parti des technologies Google Cloud. Nos cours portent sur les compétences techniques et les bonnes pratiques à suivre pour être rapidement opérationnel et poursuivre votre apprentissage. Nous proposons des formations pour tous les niveaux, à la demande, en salle et à distance, pour nous adapter aux emplois du temps de chacun. Les certifications vous permettent de valider et de démontrer vos compétences et votre expérience en matière de technologies Google Cloud.

Dernière mise à jour du manuel : 26 avril 2024

Dernier test de l'atelier : 20 septembre 2023

Copyright 2026 Google LLC. Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms d'entreprises et de produits peuvent être des marques des entreprises auxquelles ils sont associés.