Exemple : créez un AWS Fargate service à l'aide du AWS CDK - AWS Cloud Development Kit (AWS CDK) v2
Création d'un CDK projetCréation d'un service FargateNettoyage

Ceci est le guide du AWS CDK développeur de la version 2. L'ancienne CDK version 1 est entrée 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éez un AWS Fargate service à l'aide du AWS CDK

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

Amazon ECS est un service de gestion de conteneurs rapide et hautement évolutif qui facilite l'exécution, l'arrêt et la gestion Docker des conteneurs sur un cluster. Vous pouvez héberger votre cluster sur une infrastructure sans serveur gérée ECS par Amazon 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 (AmazonEC2) 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é le AWS Management Console 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. AWS CDK

La ECS structure Amazon 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 attaché à un groupe cible, où il AWS CDK applique l'ordre correct de création de l'écouteur avant la création d'une instance.

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

  • 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, ils AWS CDK peuvent détecter une mauvaise configuration et émettre une erreur lorsque nous synthétisons notre application.

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

  • Échelle automatiquement. Il 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, cela 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 Docker image.

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éation d'un CDK projet

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

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 notreIDE.

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, où 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 ECS Amazon, 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 ECS Amazon basé sur Fargate pour Docker exécuter une image.

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