Exemple : créer un service AWS Fargate à l'aide du CDK AWS - AWS Kit de développement Cloud (AWS CDK) v2
Créer un projet CDKCréation d'un service FargateNettoyage

Ceci est le guide du développeur du AWS CDK v2. L'ancien CDK v1 est entré en maintenance le 1er juin 2022 et a pris fin le 1er juin 2023.

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Exemple : créer un service AWS Fargate à l'aide du CDK AWS

Dans cet exemple, nous vous montrons comment créer un service AWS Fargate exécuté sur un cluster Amazon Elastic Container Service (Amazon ECS) dirigé par un Application Load Balancer connecté à Internet à partir d'une image sur Amazon ECR.

Amazon ECS est un service de gestion de conteneurs hautement évolutif et rapide, qui permet d'exécuter, d'arrêter et de gérer facilement des conteneurs Docker sur un cluster. Vous pouvez héberger votre cluster sur une infrastructure sans serveur gérée par Amazon ECS en lançant vos services ou tâches à l'aide du type de lancement Fargate. Pour plus de contrôle, vous pouvez héberger vos tâches sur un cluster d'instances Amazon Elastic Compute Cloud (Amazon EC2) que vous gérez à l'aide du type de EC2 lancement Amazon.

Dans cet exemple, nous lançons certains services en utilisant le type de lancement Fargate. Si vous avez utilisé la console AWS de gestion pour créer un service Fargate, vous savez qu'il existe de nombreuses étapes à suivre pour accomplir cette tâche. AWS propose plusieurs didacticiels et rubriques de documentation qui vous guident dans la création d'un service Fargate, notamment :

Cet exemple crée un service Fargate similaire à l'aide du CDK. AWS

La structure Amazon ECS utilisée dans cet exemple vous aide à utiliser AWS les services en offrant les avantages suivants :

  • Configure automatiquement un équilibreur de charge.

  • Ouvre automatiquement un groupe de sécurité pour les équilibreurs de charge. Cela permet aux équilibreurs de charge de communiquer avec les instances sans avoir à créer explicitement un groupe de sécurité.

  • Ordonne automatiquement la dépendance entre le service et l'équilibreur de charge rattaché à un groupe cible, le AWS CDK appliquant l'ordre correct de création de l'écouteur avant de créer une instance.

  • Configure automatiquement les données utilisateur pour dimensionner automatiquement les groupes. Cela crée la configuration correcte à laquelle associer un cluster AMIs.

  • Valide les combinaisons de paramètres à un stade précoce. Cela permet de détecter les AWS CloudFormation problèmes plus tôt, ce qui permet de gagner du temps de déploiement. Par exemple, en fonction de la tâche, il est facile de mal configurer les paramètres de mémoire. Auparavant, nous ne rencontrions aucune erreur tant que nous n'avions pas déployé notre application. Mais maintenant, le AWS CDK peut détecter une mauvaise configuration et émettre une erreur lorsque nous synthétisons notre application.

  • Ajoute automatiquement des autorisations pour Amazon Elastic Container Registry (Amazon ECR) si nous utilisons une image provenant d'Amazon ECR.

  • Échelle automatiquement. Le AWS CDK fournit une méthode qui nous permet de dimensionner automatiquement les instances lorsque nous utilisons un EC2 cluster Amazon. Cela se produit automatiquement lorsque nous utilisons une instance dans un cluster Fargate.

    En outre, le AWS CDK empêche la suppression d'une instance lorsque le dimensionnement automatique tente d'arrêter une instance, alors qu'une tâche est en cours d'exécution ou est planifiée sur cette instance.

    Auparavant, nous devions créer une fonction Lambda pour disposer de cette fonctionnalité.

  • Assure le support des actifs, afin que nous puissions déployer une source depuis notre machine vers Amazon ECS en une seule étape. Auparavant, pour utiliser une source d'application, nous devions effectuer plusieurs étapes manuelles, telles que le téléchargement sur Amazon ECR et la création d'une image Docker.

Important

Les ApplicationLoadBalancedFargateService structures que nous utiliserons incluent de nombreux AWS composants, dont certains ont des coûts non négligeables s'ils restent provisionnés dans notre AWS compte, même si nous ne les utilisons pas. Assurez-vous de nettoyer (cdk destroy) si vous suivez cet exemple.

Créer un projet CDK

Nous commençons par créer un projet CDK. Il s'agit d'un répertoire qui stocke notre code AWS CDK, y compris notre application CDK.

TypeScript
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language typescript
JavaScript
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language javascript
Python
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language python
source .venv/bin/activate # On Windows, run '.\venv\Scripts\activate' instead
pip install -r requirements.txt
Java
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language java

Nous pouvons maintenant importer le projet Maven dans notre IDE.

C#
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language csharp

Nous pouvons maintenant ouvrir src/MyEcsConstruct.sln dans Visual Studio.

Ensuite, nous exécutons l'application et confirmons qu'elle crée une pile vide.

cdk synth

Création d'un service Fargate

Nous pouvons exécuter nos tâches de conteneur de deux manières différentes avec Amazon ECS :

  • Utilisez le type de Fargate lancement, dans lequel Amazon ECS gère les machines physiques sur lesquelles nos conteneurs s'exécutent pour nous.

  • Utilisez le type de EC2 lancement, où nous effectuons la gestion, par exemple en spécifiant le dimensionnement automatique.

Dans cet exemple, nous allons créer un service Fargate exécuté sur un cluster Amazon ECS, dirigé par un Application Load Balancer connecté à Internet.

Nous ajoutons les importations du module AWS Construct Library suivantes à notre fichier de pile :

TypeScript

Dossier : lib/my_ecs_construct-stack.ts 

import * as ec2 from "aws-cdk-lib/aws-ec2";
import * as ecs from "aws-cdk-lib/aws-ecs";
import * as ecs_patterns from "aws-cdk-lib/aws-ecs-patterns";
JavaScript

Dossier : lib/my_ecs_construct-stack.js 

const ec2 = require("aws-cdk-lib/aws-ec2");
const ecs = require("aws-cdk-lib/aws-ecs");
const ecs_patterns = require("aws-cdk-lib/aws-ecs-patterns");
Python

Dossier : my_ecs_construct/my_ecs_construct_stack.py 

from aws_cdk import (aws_ec2 as ec2, aws_ecs as ecs,
                     aws_ecs_patterns as ecs_patterns)
Java

Dossier : src/main/java/com/myorg/MyEcsConstructStack.java 

import software.amazon.awscdk.services.ec2.*;
import software.amazon.awscdk.services.ecs.*;
import software.amazon.awscdk.services.ecs.patterns.*;
C#

Dossier : src/MyEcsConstruct/MyEcsConstructStack.cs 

using Amazon.CDK.AWS.EC2;
using Amazon.CDK.AWS.ECS;
using Amazon.CDK.AWS.ECS.Patterns;

Dans notre stack, nous ajoutons le code suivant :

TypeScript
    const vpc = new ec2.Vpc(this, "MyVpc", {
      maxAzs: 3 // Default is all AZs in region
    });

    const cluster = new ecs.Cluster(this, "MyCluster", {
      vpc: vpc
    });

    // Create a load-balanced Fargate service and make it public
    new ecs_patterns.ApplicationLoadBalancedFargateService(this, "MyFargateService", {
      cluster: cluster, // Required
      cpu: 512, // Default is 256
      desiredCount: 6, // Default is 1
      taskImageOptions: { image: ecs.ContainerImage.fromRegistry("amazon/amazon-ecs-sample") },
      memoryLimitMiB: 2048, // Default is 512
      publicLoadBalancer: true // Default is true
    });
JavaScript
    const vpc = new ec2.Vpc(this, "MyVpc", {
      maxAzs: 3 // Default is all AZs in region
    });

    const cluster = new ecs.Cluster(this, "MyCluster", {
      vpc: vpc
    });

    // Create a load-balanced Fargate service and make it public
    new ecs_patterns.ApplicationLoadBalancedFargateService(this, "MyFargateService", {
      cluster: cluster, // Required
      cpu: 512, // Default is 256
      desiredCount: 6, // Default is 1
      taskImageOptions: { image: ecs.ContainerImage.fromRegistry("amazon/amazon-ecs-sample") },
      memoryLimitMiB: 2048, // Default is 512
      publicLoadBalancer: true // Default is true
    });
Python
        vpc = ec2.Vpc(self, "MyVpc", max_azs=3)     # default is all AZs in region

        cluster = ecs.Cluster(self, "MyCluster", vpc=vpc)

        ecs_patterns.ApplicationLoadBalancedFargateService(self, "MyFargateService",
            cluster=cluster,            # Required
            cpu=512,                    # Default is 256
            desired_count=6,            # Default is 1
            task_image_options=ecs_patterns.ApplicationLoadBalancedTaskImageOptions(
                image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")),
            memory_limit_mib=2048,      # Default is 512
            public_load_balancer=True)  # Default is True
Java
        Vpc vpc = Vpc.Builder.create(this, "MyVpc")
                            .maxAzs(3)  // Default is all AZs in region
                            .build();

        Cluster cluster = Cluster.Builder.create(this, "MyCluster")
                            .vpc(vpc).build();

        // Create a load-balanced Fargate service and make it public
        ApplicationLoadBalancedFargateService.Builder.create(this, "MyFargateService")
                    .cluster(cluster)           // Required
                    .cpu(512)                   // Default is 256
                     .desiredCount(6)            // Default is 1
                     .taskImageOptions(
                             ApplicationLoadBalancedTaskImageOptions.builder()
                                     .image(ContainerImage.fromRegistry("amazon/amazon-ecs-sample"))
                                     .build())
                     .memoryLimitMiB(2048)       // Default is 512
                     .publicLoadBalancer(true)   // Default is true
                     .build();
C#
            var vpc = new Vpc(this, "MyVpc", new VpcProps
            {
                MaxAzs = 3 // Default is all AZs in region
            });

            var cluster = new Cluster(this, "MyCluster", new ClusterProps
            {
                Vpc = vpc
            });

            // Create a load-balanced Fargate service and make it public
            new ApplicationLoadBalancedFargateService(this, "MyFargateService",
                new ApplicationLoadBalancedFargateServiceProps
                {
                    Cluster = cluster,          // Required
                    DesiredCount = 6,           // Default is 1
                    TaskImageOptions = new ApplicationLoadBalancedTaskImageOptions
                    {
                        Image = ContainerImage.FromRegistry("amazon/amazon-ecs-sample")
                    },
                    MemoryLimitMiB = 2048,      // Default is 256
                    PublicLoadBalancer = true   // Default is true
                }
            );

Ensuite, nous validons notre code en exécutant ce qui suit pour synthétiser notre pile :

cdk synth

La pile est composée de centaines de lignes, nous ne la montrerons donc pas ici. La pile doit contenir une instance par défaut, un sous-réseau privé et un sous-réseau public pour les trois zones de disponibilité, ainsi qu'un groupe de sécurité.

Pour déployer la pile, nous exécutons les opérations suivantes :

cdk deploy

AWS CloudFormation affiche des informations sur les dizaines d'étapes qu'il effectue lors du déploiement de notre application.

Une fois le déploiement terminé, nous avons créé avec succès un service Amazon ECS basé sur Fargate pour exécuter une image Docker.

Nettoyage

En tant que bonne pratique de maintenance générale, et afin de minimiser les coûts inutiles, nous supprimons notre pile une fois terminée :

cdk destroy