Déploiement d'une appli web conteneurisée sur Amazon ECS

GUIDE DE DÉMARRAGE

Module 2 : Création de l'infrastructure et déploiement de l'application

Dans ce module, vous allez créer un cluster ECS et déployer votre appli avec CDK

Introduction

Dans ce module, vous allez créer une application AWS CDK qui créera toute l'infrastructure nécessaire pour configurer un cluster ECS et y déployer un exemple de conteneur.

Ce que vous apprendrez

  • Création d'une application CDK simple
  • Création d'un cluster ECS, avec Fargate pour la capacité
  • Création d'une définition de tâche et d'un service pour déployer notre application

 Durée

15 minutes

 Prérequis du module

  • Compte AWS avec accès administrateur**
  • Dernière version de Chrome ou de Firefox (recommandé)

[**]Les comptes créés au cours des dernières 24 heures n'ont sans doute pas encore accès aux services requis pour ce didacticiel.

Implémentation

Création de l'appli CDK

Tout d'abord, assurez-vous que CDK est installé. À défaut, suivez le guide Démarrage avec AWS CDK :

cdk --version

Nous créons à présent le squelette de l'application CDK en utilisant TypeScript comme langage de choix. Exécutez les commandes suivantes dans votre terminal :

mkdir cdk-ecs-infra
cd cdk-ecs-infra
cdk init app --language typescript

Cette opération produira le résultat suivant :

Applying project template app for typescript
# Welcome to your CDK TypeScript project!

This is a blank project for TypeScript development with CDK.

The `cdk.json` file tells the CDK Toolkit how to execute your app.

## Useful commands

 * `npm run build`   compile typescript to js
 * `npm run watch`   watch for changes and compile
 * `npm run test`    perform the jest unit tests
 * `cdk deploy`      deploy this stack to your default AWS account/region
 * `cdk diff`        compare deployed stack with current state
 * `cdk synth`       emits the synthesized CloudFormation template

Executing npm install...
✅ All done!

Création du code pour la pile de ressources

Accédez au fichier /lib/cdk-ecs-infra-stack.ts, dans lequel vous écrirez le code de la pile de ressources que vous allez créer.

Une pile de ressources est un ensemble de ressources d'infrastructure cloud (dans votre cas particulier, il s'agit de toutes les ressources AWS), qui sont allouées dans un compte spécifique. Il est possible de configurer dans la pile le compte/la région où ces ressources sont allouées (comme indiqué dans le guide Démarrage avec AWS CDK).

Dans cette pile de ressources, vous créerez les ressources suivantes :

  • Rôle IAM : ce rôle est attribué au conteneur pour l'autoriser à appeler d'autres services AWS.
  • Définition d'une tâche ECS : les paramètres spécifiques à utiliser lors du lancement du conteneur.
  • Modèle ECS pour le service d'équilibrage de charge Fargate : il fait abstraction de la complexité de tous les composants nécessaires pour créer le cluster, l'équilibreur de charge et le service. Il configure tous ces éléments pour qu'ils fonctionnent ensemble.

Création du cluster ECS

Pour démarrer la création du cluster ECS, vous devez d'abord importer les modules appropriés :

npm i @aws-cdk/aws-s3-assets

Puis, vous ajoutez la dépendance en haut de votre fichier lib/cdk-eb-infra-stack.ts.

npm i @aws-cdk/aws-ec2 @aws-cdk/aws-ecs @aws-cdk/aws-ecs-patterns @aws-cdk/aws-iam 

Vous modifiez ensuite le fichier lib/cdk-eb-infra-stack.ts pour ajouter la dépendance en haut du fichier :

import ecs = require('@aws-cdk/aws-ecs'); // Allows working with ECS resources
import ec2 = require('@aws-cdk/aws-ec2'); // Allows working with EC2 and VPC resources
import iam = require('@aws-cdk/aws-iam'); // Allows working with IAM resources
import ecsPatterns = require('@aws-cdk/aws-ecs-patterns') // Helper to create ECS services with loadbalancers, and configure them

Dans ces modules, vous avez accès à tous les éléments dont vous avez besoin pour déployer l'application web. La première étape consiste à trouver le VPC par défaut existant dans votre compte en ajoutant le code suivant :

// Look up the default VPC
const vpc = ec2.Vpc.fromLookup(this, "VPC", {
   isDefault: true
});

Ensuite, vous devez définir le conteneur à utiliser et la manière dont il doit être configuré. Cela se fait en créant une définition de tâche pour fournir le port du conteneur, la quantité nécessaire de CPU et de mémoire, ainsi que l'image de conteneur à utiliser. Pour ce guide, nous créons l'image de conteneur fournie avec l'exemple d'application dans le dossier SampleApp et nous laissons CDK gérer la création, le téléchargement et le déploiement du conteneur pour nous. Nous créons également un rôle IAM vide à attacher à la définition de tâche pour les guides futurs. 

Pour créer la définition de tâche et le rôle IAM, ajoutez le code suivant :

const taskIamRole = new iam.Role(this, "AppRole", {
    roleName: "AppRole",
    assumedBy: new iam.ServicePrincipal('ecs-tasks.amazonaws.com'),
});

const taskDefinition = new ecs.FargateTaskDefinition(this, 'Task', {
    taskRole: taskIamRole,
});

taskDefinition.addContainer('MyContainer', {
    image: ecs.ContainerImage.fromAsset('../SampleApp'),
    portMappings: [{ containerPort: 80 }],
    memoryReservationMiB: 256,
     cpu : 256,
});

Dans le code ci-dessus, vous pouvez voir que vous avez spécifié un type de définition de tâche à déployer dans Fargate en utilisant FargateTaskDefintion, et en utilisant ContainerImage.fromAsset. CDK crée l'image de conteneur à l'aide du fichier Dockerfile dans le répertoire SampleApp.

Ensuite, vous devez configurer le cluster ECS, définir un service, créer un équilibreur de charge, le configurer pour la connexion au service et configurer les règles des groupes de sécurité requises. Un service dans ECS est utilisé pour lancer une définition de tâche en spécifiant le nombre de copies que vous souhaitez, les stratégies de déploiement et d'autres configurations. Pour cet exemple, nous ne lançons qu'une seule copie du conteneur. Un groupe de sécurité agit comme un pare-feu virtuel pour votre instance afin de contrôler le trafic entrant et sortant. Vous n'avez pas besoin de le configurer, car le modèle ECS que vous utilisez le fait pour vous. 

Ajoutez le code suivant à votre projet au-dessous de la définition de tâche :

new ecsPatterns.ApplicationLoadBalancedFargateService(this, "MyApp", {
    vpc: vpc,
    taskDefinition: taskDefinition,
    desiredCount: 1,
    serviceName: 'MyWebApp',
    assignPublicIp: true,
    publicLoadBalancer: true,
})

Vous passez par l'objet VPC que vous avez recherché précédemment pour spécifier l'emplacement où créer toutes les ressources, ainsi que la définition de tâche qui définit l'image de conteneur à déployer. desiredCount indique le nombre de copies que vous souhaitez, serviceName indique le nom que vous souhaitez donner au service et publicLoadBalancer est défini sur true (vrai) pour que vous puissiez y accéder via Internet. Il est important de définir la ligne assignPublicIp sur true (vrai) dans cet exemple, car nous utilisons le VPC par défaut qui n'a pas de sous-réseau privé. Conformément aux bonnes pratiques, il est recommandé de lancer les services dans des sous-réseaux privés, mais ce point n'est pas abordé dans ce guide.

Vous êtes maintenant prêt à déployer l'application web, mais vous devez d'abord configurer CDK sur le compte sur lequel vous allez effectuer le déploiement. 

Modifiez le fichier bin/cdk-ecs-infra.ts et supprimez le commentaire de la ligne 14:

env: { account: process.env.CDK_DEFAULT_ACCOUNT, region: process.env.CDK_DEFAULT_REGION },

Cette opération utilisera l'ID de compte et la région configurés dans AWS CLI. Avant toute utilisation, le kit CDK doit être amorcé. Cette action a pour but de créer l'infrastructure dont a besoin le kit CDK pour gérer l'infrastructure de votre compte. Pour amorcer le kit CDK, exécutez cdk bootstrap. Le résultat devrait être similaire à celui-ci :

cdk bootstrap

#output
⏳  Bootstrapping environment aws://0123456789012/<region>...
✅  Environment aws://0123456789012/<region> bootstrapped

Cela crée l'infrastructure nécessaire pour que CDK gère l'infrastructure dans votre compte. Nous recommandons de consulter le guide Démarrage avec AWS CDK si vous ne connaissez pas la configuration d'une application CDK.

Lorsque l'action d’amorçage est terminée, vous exécutez cdk deploy pour déployer le conteneur, le cluster et toute autre infrastructure nécessaire. Le résultat devrait être similaire à celui-ci :

gsg-build-ecs-2

CDK vous interroge avant de créer l'infrastructure, car la création de l'infrastructure modifie la configuration de sécurité, dans votre cas, en créant des rôles IAM et des groupes de sécurité. Appuyez sur y puis sur Entrée pour déployer. CDK configure maintenant toute l'infrastructure que vous avez définie, ce qui prend quelques minutes. 

Au cours de l'exécution, vous voyez des mises à jour semblables à celle-ci :

gsg-build-ecs-3

Une fois l'exécution terminée, vous voyez le résultat avec le lien vers l'URL publique pour accéder à votre service, semblable à ceci :

gsg-build-ecs-4

Exemple de code complet

import * as cdk from '@aws-cdk/core';
import ecs = require('@aws-cdk/aws-ecs');
import ec2 = require('@aws-cdk/aws-ec2');
import iam = require('@aws-cdk/aws-iam');
import ecsPatterns = require('@aws-cdk/aws-ecs-patterns')

export class CdkEcsInfraStack extends cdk.Stack {
  constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

      // Look up the default VPC
      const vpc = ec2.Vpc.fromLookup(this, "VPC", {
        isDefault: true
      });

      const taskIamRole = new iam.Role(this, "AppRole", {
        roleName: "AppRole",
        assumedBy: new iam.ServicePrincipal('ecs-tasks.amazonaws.com'),
      });

      const taskDefinition = new ecs.FargateTaskDefinition(this, 'Task', {
        taskRole: taskIamRole,
      });

      taskDefinition.addContainer('MyContainer', {
        image: ecs.ContainerImage.fromAsset('../SampleApp'),
        portMappings: [{ containerPort: 80 }],
        memoryReservationMiB: 256,
        cpu : 256,
      });

      new ecsPatterns.ApplicationLoadBalancedFargateService(this, "MyApp", {
        vpc: vpc,
        taskDefinition: taskDefinition,
        desiredCount: 1,
        serviceName: 'MyWebApp',
        assignPublicIp: true,
        publicLoadBalancer: true,
      })

  }
}

Conclusion

Dans ce module, vous avez appris à créer un cluster ECS avec un équilibreur de charge pour acheminer le trafic vers votre conteneur exécuté sur Fargate à l'aide d'un modèle ECS fourni par CDK. Dans le module suivant, vous procéderez au nettoyage de toutes les ressources créées dans ce guide.

À suivre : Nettoyage des ressources

Dites-nous si nous avons répondu à vos attentes.

Nous vous remercions pour votre commentaire
Nous sommes ravis que cette page vous ait été utile. Souhaitez-vous partager des détails supplémentaires pour nous aider à continuer à nous améliorer ?
Fermer
Nous vous remercions pour votre commentaire
Nous sommes désolés que cette page ne vous ait pas été utile. Souhaitez-vous partager des détails supplémentaires pour nous aider à continuer à nous améliorer ?
Fermer