Projets sur AWS :

Fragmenter une application monolithique en microservices

en utilisant Amazon Elastic Container Service, Docker et Amazon EC2

blocs conteneurs
introduction

Introduction

module un

Conteneuriser le monolithe

module deux

Déployer le monolithe

module trois

Fragmenter le monolithe

étape quatre

Déployer des microservices

module cinq

Nettoyage

Module 4 – Déploiement de microservices

Dans ce module, vous découvrirez comment déployer votre application node.js sous forme de services interconnectés derrière un équilibreur de charge d'application. Vous serez ensuite en mesure d'employer cet équilibreur de charge pour rediriger aisément le trafic du monolithe vers les microservices. Procéder au déploiement

Présentation de l'architecture

Voici le processus à suivre pour déployer les microservices et réorienter en toute sécurité le trafic de l'application concentré au niveau du monolithe.

présentation de l'architecture
  1. Réorientation du trafic
    Il s'agit de la configuration initiale, à savoir l'application node.js monolithique qui s'exécute sur un conteneur dans Amazon ECS.
  2. Démarrage des microservices
    À l'aide des trois images de conteneur que vous avez créées et transférées dans Amazon ECR au cours du module précédent, vous pouvez démarrer jusqu'à trois microservices dans votre cluster Amazon ECS existant.
  3. Configuration des groupes cibles
    Comme dans le module 2, vous ajoutez un groupe cible pour chaque service et mettez à jour les règles applicables à l'équilibreur de charge d'application pour connecter les nouveaux microservices.
  4. Désactivation du monolithe
    En modifiant l'une des règles de l'équilibreur de charge d'application, vous réorientez le trafic en direction des microservices en cours d'exécution. Une fois que cette redirection est effective, vous pouvez désactiver le monolithe.

Temps nécessaire : 30 minutes

Services utilisés :

Instructions de mise en œuvre

Respectez les instructions détaillées ci-dessous pour déployer les microservices. Cliquez sur chaque numéro d'étape pour développer la section appropriée.

  • Étape 1. Écriture des définitions de tâches pour vos services

    Vous allez déployer trois nouveaux services dans le cluster que vous avez lancé au sein du module 2. Comme dans le module 2, vous devez écrire des définitions de tâches pour chaque service.

    ⚐ Remarque : vous pouvez ajouter plusieurs conteneurs à une seule définition de tâche. Ainsi, vous pouvez exécuter les trois microservices en tant que conteneurs différents depuis un seul service. Cependant, cette approche reste monolithique, dans la mesure où chaque conteneur doit être dimensionné linéairement avec le service. L'objectif est de disposer de trois services indépendants. Chaque service doit être associé à sa propre définition de tâche exécutant un conteneur dont l'image correspond à celui-ci.

    Vous pouvez créer ces définitions de tâches depuis la console Amazon ECS, ou les écrire au format JSON pour accélérer le processus. Pour écrire les définitions de tâches dans un fichier JSON, procédez comme suit :

    1. Dans la console Amazon Container Services, sous Amazon ECS, sélectionnez Définitions de tâches.
    2. Sur la page Définitions de tâches, sélectionnez l'option Créer une nouvelle définition de tâche.
    3. Sur la page Sélectionner le niveau de compatibilité du type de lancement, sélectionnez l'option EC2, puis Étape suivante.
    4. Sur la page Configurer les définitions de tâches et de conteneurs, accédez à la section Volumes, puis sélectionnez le bouton Configurer via JSON.
    5. Copiez et collez l'élément de code suivant dans le champ JSON, à la place du code existant.
      Veillez à remplacer les termes [nom-service], [ID-compte], [région] et [balise].

    ⚐ Remarque : les paramètres suivants sont utilisés lors de la définition de la tâche :

    • Nom = [nom-service : posts, threads et users] 
    • Image = [URL de l'image du référentiel Amazon ECR la plus récente]
    • Processeur = 256 
    • Mémoire = 256 
    • Port du conteneur = 3 000 
    • Enregistrement hôte = 0
    {
    "containerDefinitions": [
        {
            "name": "[service-name]",
            "image": "[account-id].dkr.ecr.[region].amazonaws.com/[service-name]:[tag]",
            "memoryReservation": "256",
            "cpu": "256",
            "essential": true,
            "portMappings": [
                {
                    "hostPort": "0",
                    "containerPort": "3000",
                    "protocol": "tcp"
                }
            ]
        }
    ],
    "volumes": [],
    "networkMode": "bridge",
    "placementConstraints": [],
    "family": "[service-name]"
}

    ♻ Répétez les étapes pour créer une définition de tâche pour chaque service :

    • posts
    • threads
    • users

  • Étape 2. Configuration de l'équilibreur de charge d'application : groupes cibles

    Comme dans le module 2, configurez un groupe cible pour chaque service (posts, threads et users). Un groupe cible permet au trafic de s'effectuer correctement en direction d'un service particulier. Vous pouvez configurer les groupes cibles à l'aide de l'interface en ligne de commande AWS. Avant de poursuivre, veillez toutefois à disposer du nom du VPC employé dans le cadre de ce didacticiel :

    • Accédez à la section Équilibreurs de charge de la console EC2.
    • Cochez la case située à côté de demo, puis sélectionnez l'onglet Description et recherchez l'attribut du VPC (au format vpc-xxxxxxxxxxxxxxxxx).
      ⚐ Remarque : vous devez disposer de l'attribut du VPC lors de la configuration des groupes cibles.

    Configuration des groupes cibles

    Dans votre terminal, saisissez la commande suivante afin de créer un groupe cible pour chaque service (posts, threads et users). Vous devrez également créer le groupe cible drop-traffic pour empêcher l'acheminement du trafic en direction du monolithe une fois que vos microservices s'exécuteront. Veillez à remplacer les termes suivants : [région], [nom-service] et [attribut-vpc].

    Noms des services : posts, threads, users et drop-traffic

    aws elbv2 create-target-group --region [region] --name [service-name] --protocol HTTP --port 80 --vpc-id [vpc-attribute] --healthy-threshold-count 2 --unhealthy-threshold-count 2 --health-check-timeout-seconds 5 --health-check-interval-seconds 6
    groupes cibles

  • Étape 3. Configuration des règles de l'écouteur

    L'écouteur permet de détecter les requêtes de connexion entrantes s'effectuant en direction de votre équilibreur de charge d'application afin que le trafic soit correctement acheminé.

    Pour l'instant, vos quatre services (le monolithe et les trois microservices) s'exécutent derrière le même équilibreur de charge. Pour rediriger le trafic de votre monolithe à vos microservices, acheminez le trafic en direction de vos microservices et mettez fin à celui s'effectuant vers votre monolithe.

    Accès aux règles de l'écouteur

    Mise à jour des règles de l'écouteur

    Un seul écouteur doit être répertorié dans cet onglet. Suivez les étapes suivantes pour modifier les règles de l'écouteur :

    • Dans la colonne Règles, cliquez sur Consulter/modifier les règles.
    • Sur la page Règles, cliquez sur le bouton +.
      L'option Insérer une règle s'affiche sur la page. 
    • Utilisez le modèle suivant pour insérer les règles nécessaires, l'une permettant de maintenir le trafic vers le monolithe, et l'autre pour chaque microservice :
      • IF Path = /api/[nom-service]* THEN Forward to [nom-service]
        Exemple : IF Path = /api/posts* THEN Forward to posts
      • Insérez les règles selon l'ordre suivant :
        • api : /api* forwards to api
        • users : /api/users* forwards to users
        • threads : /api/threads* forwards to threads
        • posts : /api/posts* forwards to posts
    • Sélectionnez Enregistrer.
    • Cliquez sur la flèche de retour située dans le coin supérieur gauche de la page pour revenir sur la console de l'équilibreur de charge.
    Configuration des règles de l'écouteur de l'équilibreur de charge d'application

  • Étape 4. Déploiement de vos microservices

    Déployez les trois microservices (posts, threads et users) dans votre cluster. Répétez les étapes suivantes pour chacun de vos trois microservices :

    • Accédez à la console Amazon ECS, puis sélectionnez Clusters dans la barre de menu de gauche.
    • Sélectionnez le cluster BreakTheMonolith-Demo, l'onglet Services, puis l'option Créer.
    • Sur la page Configurer le service, modifiez les paramètres suivants (et pas ceux qui ne sont pas répertoriés ci-dessous) :
      • Pour le paramètre Type de lancement, sélectionnez EC2.
      • Pour le paramètre Définition de tâche, cliquez sur le bouton Saisir une valeur pour définir automatiquement la valeur la plus élevée.
        Par exemple, « api:1 ». 
      • Pour le paramètre Nom du service, sélectionnez un nom de service (posts, threads ou users).
      • Pour le paramètre Nombre de tâches, saisissez 1.
    • Sélectionnez Étape suivante.
    • Sur la page Configurer le réseau, dans la section Équilibrage de charge, procédez comme suit :
      • Pour le paramètre Type d'équilibreur de charge, sélectionnez Équilibreur de charge d'application.
      • Pour le paramètre Rôle IAM du service, sélectionnez BreakTheMonolith-Demo-ECSServiceRole.
      • Vérifiez que demo est sélectionné pour le nom de l'équilibreur de charge.
      • Dans la section Conteneur pour l'équilibrage de charge, sélectionnez l'option Ajouter à l'équilibreur de charge et effectuez les modifications suivantes :
        • Pour le paramètre Port de l'écouteur de production, définissez la valeur 80:HTTP.
        • Pour le paramètre Nom du groupe cible, sélectionnez le groupe approprié : (posts, threads ou users).
    • Sélectionnez Étape suivante.
    • Sur la page Définir l'Auto Scaling, sélectionnez Étape suivante.
    • Sur la page Vérification, sélectionnez Créer le service.
    • Sélectionnez Consulter le service.

    Le démarrage de tous vos services devrait s'effectuer en quelques secondes. Avant de poursuivre, vérifiez que tous les services et toutes les tâches s'exécutent et sont actifs.

    Amazon ECS – Déploiement des microservices

  • Étape 5. Redirection du trafic vers vos microservices

    Vos microservices sont désormais en cours d'exécution. Toutefois, l'intégralité du trafic s'effectue toujours en direction de votre monolithe. Pour rediriger le trafic vers les microservices, suivez les étapes suivantes afin de modifier les règles de l'écouteur :

    • Accédez à la section Équilibreurs de charge de la console EC2.
    • Cochez la case située à côté de demo pour consulter les détails de l'équilibreur de charge.
    • Sélectionnez l'onglet Écouteurs.
      Un seul écouteur doit être répertorié.
    • Dans la colonne Règles, cliquez sur Consulter/modifier les règles.
    • Sur la page Règles, cliquez sur le bouton - du menu supérieur.
    • Supprimez la première règle (/api* forwards to api) en cochant la case située à côté de la règle en question.
    • Sélectionnez Supprimer.
    • Modifiez la règle par défaut afin de rediriger le trafic :
      • Cliquez sur l'icône de crayon dans le menu supérieur.
      • Cliquez sur l'icône de crayon située à côté de la règle par défaut (HTTP 80 : action par défaut).
      • Cliquez sur l'icône de crayon située dans la colonne PUIS pour modifier la règle Rediriger vers.
      • Dans le champ Groupe cible, sélectionnez drop-traffic.
      • Cliquez sur le bouton Mettre à jour.

    La capture d'écran suivante illustre des règles mises à jour.

    Amazon EC2 – Redirection du trafic vers les microservices

    Désactivez le monolithe : étant donné que l'intégralité du trafic s'effectue désormais en direction de vos microservices, vous pouvez désactiver le monolithe.

    • Accédez à nouveau au cluster BreakTheMonolith-Demo-ECSCluster Amazon ECS.
    • Dans l'onglet Services, cochez la case située à côté de api et sélectionnez Mettre à jour.
    • Sur la page Configurer le service, recherchez le paramètre Nombre de tâches et saisissez 0.
    • Sélectionnez Passer à la vérification.
    • Sélectionnez Mettre à jour le service.

    Amazon ECS désactive ensuite les connexions non exploitées des conteneurs que le service a déployés sur le cluster, puis arrête ces conteneurs. Si vous actualisez la liste des déploiements ou des tâches après environ 30 secondes, le nombre de tâches est alors de 0. Le service étant toujours actif, vous pouvez simplement le mettre à jour pour déployer des tâches supplémentaires si nécessaire.

    Vous pouvez également supprimer le service api. Dans l'onglet Services, cochez la case située à côté de api, sélectionnez Supprimer, puis confirmez la suppression.

    Votre application node.js est désormais déployée vers vos microservices, et ce, sans aucune interruption.

  • Étape 6. Validation de votre déploiement

    Recherchez l'URL de votre service : il s'agit de l'URL que vous avez utilisée dans le module 2 de ce didacticiel.

    • Accédez à la section Équilibreurs de charge de la console EC2.
    • Cochez la case située à côté de demo pour consulter les détails de l'équilibreur de charge.
    • Dans l'onglet Description, identifiez le nom DNS et cliquez sur l'icône de copie à la fin de l'URL. 
    • Copiez le nom DNS dans un nouvel onglet ou une nouvelle fenêtre de navigateur.

    Le message « Réception de requêtes possible » doit apparaître.

    Consultez les valeurs se rapportant à chaque microservice : votre équilibreur de charge d'application achemine le trafic en fonction de l'URL de la requête. Pour consulter chaque service, ajoutez simplement son nom à la fin de votre nom DNS :

    • http://[nom DNS]/api/users
    • http://[nom DNS]/api/threads
    • http://[nom DNS]/api/posts
    consultation des valeurs se rapportant à chaque microservice

    ⚐ Remarque : ces URL fonctionnent exactement de la même manière que lorsque le monolithe est déployé. Ce point s'avère très important, dans la mesure où toute API ou tout client se connectant à cette application ne sera alors pas affecté par les modifications effectuées. La redirection du trafic vers les microservices n'implique aucune autre modification à votre infrastructure.

    Vous pouvez également utiliser des outils tels que Postman afin de tester vos API.

Étape suivante : nettoyage