Dans ce module, vous allez utiliser Amazon Elastic Container Service (Amazon ECS) pour instancier un cluster géré d'instances de calcul EC2 et déployer votre image sous la forme d'un conteneur s'exécutant sur le cluster. Commencer la construction

présentation de l’architecture

a. Client
Le client envoie une requête à l’équilibreur de charge sur le port 80.

b. Équilibreur de charge
L’équilibreur de charge répartit les requêtes sur tous les ports disponibles.

c. Groupes cibles
Les instances sont enregistrées dans le groupe cible de l’application.

d. Ports de conteneurs
Chaque conteneur exécute un seul processus d’application qui lie le parent du cluster node.js au port 80 au sein de son espace de noms.

e. Monolithe conteneurisé node.js
Le parent du cluster node.js est chargé de répartir le trafic entre les nœuds au sein de l’application monolithique. Cette architecture est conteneurisée, mais elle demeure monolithique, car chaque conteneur possède les mêmes caractéristiques que les autres conteneurs.

Amazon Elastic Container Service (Amazon ECS) est un service de gestion de conteneurs hautement scalable et à hautes performances qui prend en charge les conteneurs Docker et vous permet d'exécuter facilement des applications sur un cluster géré d'instances Amazon EC2. Grâce à de simples appels d'API, vous pouvez lancer et arrêter les applications activées par des conteneurs Docker, connaître l'état complet de votre cluster et accéder à de nombreuses fonctions courantes telles que les groupes de sécurité, Elastic Load Balancing, les volumes EBS et les rôles IAM.

Vous pouvez utiliser Amazon ECS pour programmer le placement des conteneurs sur votre cluster en fonction de vos besoins en ressources et vos exigences en termes de disponibilité. Vous pouvez également intégrer votre propre programmeur ou des programmeurs tiers pour répondre aux besoins spécifiques de votre entreprise ou de votre application.

Amazon Elastic Container Service est disponible sans frais supplémentaires. Vous payez les ressources AWS (par ex : instances EC2 ou volumes EBS) que vous créez pour stocker et exécuter votre application.


Suivez les instructions détaillées ci-dessous pour déployer l’application node.js à l’aide d’Amazon ECS. Cliquez sur chaque numéro d’étape pour développer la section correspondante.

break-the-monolith
  • Étape 1. Lancement d’un cluster ECS à l’aide d’AWS CloudFormation

    Créez tout d’abord un cluster Amazon ECS, déployé à l’arrière d’un Application Load Balancer.

    1. Accédez à la console CloudFormation AWS.
    2. Sélectionnez « Créer une pile ».
    3. Sélectionnez « Télécharger un modèle sur Amazon S3 » et choisissez le fichier ecs.yml du projet GitHub sur amazon-ecs-nodejs-microservice/2-containerized/infrastructure/ecs.yml. Sélectionnez Suivant.
    4. Saisissez BreakTheMonolith-Demo comme nom de pile. Conservez les valeurs des autres paramètres :
      1. Capacité souhaitée = 2
      2. InstanceType = t2.micro
      3. MaxSize = 2
    5. Sélectionnez Suivant.
    6. Il n’est pas nécessaire de modifier les options sur cette page. Sélectionnez Suivant.
    7. Cochez la case située en bas de la page suivante et sélectionnez Créer. Votre pile s’affiche avec le statut CREATE_IN_PROGRESS (CRÉATION_EN_COURS) en orange. Vous pouvez cliquer sur le bouton d’actualisation situé en haut à droite de l’écran pour vérifier la progression. Ce processus prend généralement moins de 5 minutes.
    création d’une pile

    ⚐ REMARQUE : vous pouvez également utiliser AWS CLI pour déployer des piles AWS CloudFormation. Il vous suffit d’ajouter votre région à ce code, puis de l’exécuter sur le terminal à partir du dossier amazon-ecs-nodejs-microservices/3-microservices de votre ordinateur.

    $ aws cloudformation deploy \
       --template-file infrastructure/ecs.yml \
       --region <region> \
       --stack-name Nodejs-Microservices \
       --capabilities CAPABILITY_NAMED_IAM
  • Étape 2. Vérification de l’exécution du cluster.

    vérification du cluster
    • En cliquant dans le cluster, sélectionnez l’onglet « Tâches » ; aucune tâche n’est en cours d’exécution.
    tâches
    • Sélectionnez l’onglet « Instances ECS » : vous y verrez les deux instances EC2 créées par le modèle AWS CloudFormation.
    instances ECS
  • Étape 3. Écriture d’une définition de tâche

    La définition de tâche indique à Amazon ECS comment déployer les conteneurs de votre application sur le cluster.

    • Naviguez vers le menu « Définitions de tâches » sur le côté gauche de la console Amazon ECS.
    • Sélectionnez « Créer une définition de tâche ».
    • Nom de définition de tâche = api.
    • Sélectionnez « Ajouter un conteneur ».
    • Spécifiez les paramètres suivants :
      • Si un paramètre n’est pas défini, laissez-le vide ou avec les paramètres par défaut : Nom du conteneur = api image = [ID_compte].dkr.ecr.[région].amazonaws.com/api:v1 (il s’agit de l’URL de l’image de référentiel ECR que vous avez créée à l’étape précédente).
      • Vérifiez que la balise :v1 correspond à la valeur que vous avez utilisée dans le module 1 pour baliser et envoyer l’image. Mémoire = Limite stricte : 256 Mappages de ports = Port hôte :0, Port du conteneur :3 000 Unités CPU = 256
    • Sélectionnez « Ajouter ».
    • Sélectionnez « Créer ».
    • Votre définition de tâche s’affichera dans la console.
    définition de tâche
  • Étape 4. Configuration de l’Application Load Balancer : groupe cible

    L’Application Load Balancer (ALB) permet à votre service d’accepter le trafic entrant. L’ALB achemine automatiquement le trafic vers les instances en cours d’exécution sur votre cluster, en les utilisant comme un groupe cible.

    Vérifiez le nom de votre VPC : si ce n’est pas la première fois que vous utilisez ce compte AWS, il est possible que vous ayez plusieurs VPC. Il est important de configurer votre groupe cible avec le bon VPC.

    • Accédez à la section Équilibreur de charge de la console EC2.
    • Vous devriez voir qu’il existe déjà un équilibreur de charge nommé « demo ».
    • Cochez la case pour afficher les détails de l’équilibreur de charge.
    • Notez la valeur de l’attribut VPC sur la page de détails.
    attribut vpc

    Configurez le groupe cible de l’ALB

    • Accédez à la section Groupe cible de la console EC2.
    • Sélectionnez Créer un groupe cible.
    • Configurez le groupe cible (ne modifiez pas les valeurs par défaut qui ne sont pas spécifiées ici) :
      • Nom = api
      • Protocole = HTTP
      • Port = 80
      • VPC = sélectionnez le VPC qui correspond à votre équilibreur de charge de l’étape précédente. Il ne s’agit fort probablement PAS de votre VPC par défaut.
      • Paramètres avancés de vérification de l’état : Seuil de bonne santé = 2, Seuil de défectuosité = 2, Expiration = 5, Intervalle = 6.
    • Sélectionnez « Créer ».
    création des groupes cibles
  • Étape 5. Configuration de l’Application Load Balancer : écouteur

    L’écouteur vérifie s’il existe des demandes de connexion entrantes pour votre ALB.

    Ajoutez un écouteur à l’ALB

    • Accédez à la section Équilibreur de charge de la console EC2.
    • Vous devriez voir qu’il existe déjà un équilibreur de charge nommé « demo ».
    • Cochez la case pour afficher les détails de l’équilibreur de charge.
    • Sélectionnez l’onglet Écouteurs.
    • Sélectionnez « Créer un écouteur » :
      • Protocole = HTTP
      • Port = 80
      • Groupe cible par défaut = api
    • Cliquez sur Créer.
    écouteur pour ALB
  • Étape 6. Déploiement du monolithe en tant que service

    Déployez maintenant le monolithe en tant que service sur le cluster.

    • Naviguez vers le menu « Clusters » sur le côté gauche de la console Amazon ECS.
    • Sélectionnez votre cluster : BreakTheMonolith-Demo-ECSCluster.
    • Sous l’onglet « Services », sélectionnez « Créer ».
    • Configurez le service (ne modifiez pas les valeurs par défaut) : Nom du service = api, Nombre de tâches = 1
    • Sélectionnez « Configurer ELB » :
      • Type d’ELB = Application Load Balancer.
      • Pour le rôle IAM, sélectionnez BreakTheMonolith-Demo-ECSServiceRole.
      • Sélectionnez le nom de votre équilibreur de charge ELB = démo.
      • Sélectionnez « Ajouter à ELB ».
    • Ajoutez votre service au groupe cible :
      • Port d’écoute = 80:HTTP
      • Nom du groupe cible = sélectionnez votre groupe : api.
    • Sélectionnez « Enregistrer ».
    déploiement de votre service
    • Sélectionnez « Créer un service ».
    • Sélectionnez « Afficher le service ».
    configuration facultative

    Beau travail ! Vous disposez à présent d’un service en cours d’exécution. Il faudra peut-être une minute pour que le conteneur soit enregistré comme sain et commence à recevoir du trafic.

  • Étape 7. Test de votre monolithe

    Validez votre déploiement en vérifiant si le service est disponible via Internet et en réalisant un test ping.

    Trouvez votre URL de service :

    • Accédez à la section Équilibreurs de charge de la console EC2.
    • Sélectionnez votre équilibreur de charge « démo ».
    • Copiez et collez la valeur du nom DNS dans votre navigateur.
    • Vous devriez voir le message « Prêt à recevoir des requêtes ».


    Consultez chaque partie du service :
    l’application node.js achemine le trafic vers chaque nœud basé sur l’URL. Pour consulter un nœud, il vous suffit d’ajouter son nom api/[Nom de nœud] à la fin de votre nom DNS, comme suit :

    • http://[nom DNS]/api/utilisateurs
    • http://[nom DNS]/api/threads
    • http://[nom DNS]/api/publications

    Vous pouvez également ajouter un numéro d’enregistrement à la fin de l’URL pour accéder à un enregistrement particulier. Par exemple : http://[nom DNS]/api/posts/1 ou http://[nom DNS]/api/users/2

    démonstration de l’utilisateur