Dans ce module, vous allez apprendre à diviser votre application node.js en plusieurs services interconnectés, puis à transférer l'image de chaque service dans un référentiel Amazon Elastic Container Registry (Amazon ECR). Commencer la création

L'architecture finale de l'application exploite Amazon Elastic Container Service (Amazon ECS) et l'équilibreur de charge d'application (ALB). 

présentation de l'architecture

a. Client
Le client effectue des requêtes de trafic au niveau du port 80.

b. Équilibreur de charge
L'ALB achemine le trafic externe vers le service approprié. Il examine également la requête du client et s'appuie sur les règles de routage pour rediriger la requête vers une instance et un port associés au groupe cible correspondant à la règle concernée.

c. Groupes cibles
Chaque service est lié à un groupe cible qui effectue un suivi des instances et des ports de chaque conteneur s'exécutant pour ce même service.

d. Microservices
Amazon ECS déploie chaque service dans un conteneur à via un cluster EC2. Chaque conteneur prend en charge une seule fonction.

Isolement des défaillances
Il arrive à tous, même aux entreprises particulièrement expérimentées en ingénierie d'être confronté à de défaillances critiques. En plus de vous conformer à toutes les meilleures pratiques applicables pour procéder au mieux dans de telles situations, vous pouvez également configurer des microservices afin de limiter l'impact de ces dernières. Avec une bonne architecture de microservices, seule une partie de votre service est en panne si un micro-élément de votre service ne fonctionne plus. En revanche, le reste de votre service continue de fonctionner correctement.

Isolement de chaque service
Dans une application monolithique, si l'une des fonctions est victime d'une faille de sécurité (permettant, par exemple, qu'un code soit exécuté à distance), il est probable que le cybercriminel qui en est à l'origine soit aussi en mesure d'accéder à chaque autre service de votre système. Ceci peut se révéler particulièrement dangereux et provoquer, notamment, l'exploitation non autorisée d'une base de données renfermant des mots de passe. La répartition de fonctions au sein de microservices à l'aide d'Amazon ECS constitue un moyen d'accéder en toute sécurité aux ressources AWS, chaque service profitant de son propre rôle AWS Identity and Access Management (IAM). Lorsque les bonnes pratiques des microservices sont suivies, tout intrus malveillant qui accède au service ne peut accéder qu'aux ressources de ce service, et ne peut pas accéder horizontalement aux ressources d'autres services sans s'introduire dans ces services également.

Mise à l'échelle indépendante
Lorsque des fonctions sont réparties au sein de microservices, la part de l'infrastructure et le nombre d'instances utilisées par chaque classe de microservices peuvent être mis à l'échelle de façon indépendante. Il est donc plus simple d'estimer le coût d'une fonctionnalité spécifique, ainsi que d'identifier les fonctionnalités dont l'optimisation est nécessaire. Si les ressources de l'une d'elles présentent un problème, les autres ne sont pas affectées et les performances demeurent assurées.

Développement rapide
Les microservices garantissent une réduction des risques lors du développement, ce qui offre à une équipe la possibilité de créer plus rapidement des applications. Dans un monolithe, l'ajout d'une nouvelle fonctions peut potentiellement avoir une incidence sur toutes les autres. Les développeurs doivent bien prendre en compte l'impact de n'importe quel code ajouté, et s'assurer que tout s'effectue correctement. Par ailleurs, l'application d'un nouveau code à une fonctionnalité concerne uniquement le microservice associé. Les développeurs peuvent être sûrs que tout code écrit n'influe pas sur celui des autres microservices, sauf si une connexion est explicitement établie entre deux microservices.

Temps nécessaire : 20 minutes

Services utilisés :


Suivez les instructions pas à pas ci-dessous pour diviser votre monolithe. Cliquez sur le numéro de chaque étape pour développer la section correspondante.

break-the-monolith
  • Étape 1. Mise en service des référentiels ECR

    Dans les deux modules précédents, vous avez déployé votre application sous forme de monolithe à l'aide d'un seul service et d'un seul référentiel comportant les images des conteneurs. Pour déployer l'application sous forme de trois microservices, vous devez mettre en service trois référentiels (un pour chaque service) dans Amazon ECR.

    Les trois services sont les suivants :

    1. users
    2. threads
    3. posts

    Créez les trois référentiels en répétant les étapes suivantes avec chaque service :

    • Accédez à la console Amazon ECR.
    • Sélectionnez Créer un référentiel.
    • Sur la page Créer un référentiel, dans le champ Nom du référentiel, créez un référentiel pour le service (posts, threads ou users).
      ⚐ Remarque : conservez les paramètres par défaut associés aux options Immuabilité des balises.

    Quatre référentiels doivent être configurés dans Amazon ECR. Prenez note des informations relatives à chaque référentiel que vous avez créé. Elles vous seront utiles ultérieurement. Les informations nécessaires se trouvent au format suivant :
    [id-compte].dkr.ecr.[region].amazonaws.com/[service-name]

    référentiels
  • Étape 2. Authentifier Docker avec AWS (facultatif)

    Vous devez accéder à Docker pour créer et transférer les images de chaque service. Si vous suivez ce tutoriel à différents moments, il est possible que vous ayez été déconnecté de Docker. Si tel est le cas, procédez comme suit pour vous reconnecter à Docker.

    • Exécutez la commande  $(aws ecr get-login --no-include-email --region [your-region]).
      Modifiez le terme [your-region]exemple : $(aws ecr get-login --no-include-email --region us-west-2).

    Si l'authentification s'effectue avec succès, le message Connexion réussie s'affiche.

  • Étape 3. Création et transmission d'images pour chaque service

    Dans le dossier amazon-ecs-nodejs-microservices/3-microservices/services, des sous-dossiers comportent des fichiers pour chaque service. Vous remarquerez que chaque microservice constitue une forme de reproduction de l'ancien service monolithique,

    et qu'il est désormais spécialisé, en comparant les deux fichiers db.json correspondants (celui du service en question et celui du service monolithique). Précédemment, les services posts, threads et users se trouvaient tous dans un seul fichier de base de données. Désormais, chacun est stocké dans le fichier de base de données associé au service concerné.

    Ouvrez votre terminal, puis définissez le chemin sur ~/amazon-ecs-nodejs-microservices/3-microservices/services.

    Création des images et ajout de balises à celles-ci

    • Dans le terminal, exécutez la commande docker build -t [service-name] ./[service-name].
      Remplacez le terme [service-name] (exemple : docker build -t posts ./posts).

    • Une fois la création effectuée, ajoutez une balise à l'image afin de pouvoir la transférer dans le référentiel à l'aide de la commande suivante :
      docker tag [service-name]:latest [account-ID].dkr.ecr.[region].amazonaws.com/[service-name]:v1
      Remplacez les termes [service-name], [account-ID] et [region] (exemple : docker tag posts:latest [id-compte].dkr.ecr.us-west-2.amazonaws.com/posts:v1).

    • Transférez votre image dans Amazon ECR à l'aide de la commande « docker push [id-compte].dkr.ecr.[région].amazonaws.com/[nom-service]:v1 ».
      Remplacez les termes [service-name], [account-ID] et [region].

    Si vous vous rendez dans votre référentiel Amazon ECR, vous devriez y trouver les images, accompagnées de la balise « v1 ». 

    ♻ Répétez ces étapes avec chaque image de microservice.  

    ⚐ REMARQUE : assurez-vous de bien créer les trois images, et d'ajouter une balise à chacune.