View a markdown version of this page

Création de ressources Amazon ECS à l'aide du AWS CDK - Amazon Elastic Container Service

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.

Création de ressources Amazon ECS à l'aide du AWS CDK

Le Cloud Development Kit AWS (AWS CDK) est un Infrastructure-as-Code cadre (IAC) que vous pouvez utiliser pour définir AWS infrastructure cloud en utilisant le langage de programmation de votre choix. Pour définir votre propre infrastructure de cloud, écrivez d'abord une application (dans l'un des langages pris en charge par le CDK) contenant une ou plusieurs piles. Ensuite, vous le synthétisez en un CloudFormation modélisez et déployez vos ressources sur votre Compte AWS. Suivez les étapes décrites dans cette rubrique pour déployer un serveur Web conteneurisé avec Amazon Elastic Container Service (Amazon ECS) et AWS CDK sur Fargate.

Le AWS La bibliothèque Construct, incluse dans le CDK, fournit des modules que vous pouvez utiliser pour modéliser les ressources qui Services AWS fournir. Pour les services populaires, la bibliothèque fournit des constructions organisées avec des valeurs par défaut intelligentes et les bonnes pratiques. L'un de ces modules, en particulier aws-ecs-patterns, fournit des abstractions de haut niveau que vous pouvez utiliser pour définir votre service conteneurisé et toutes les ressources de support nécessaires en quelques lignes de code.

Cette rubrique utilise la construction ApplicationLoadBalancedFargateService. Cette construction déploie un Amazon ECS service sur Fargate derrière un Application Load Balancer. Le module aws-ecs-patterns inclut également des constructions qui utilisent un Network Load Balancer et s'exécutent sur Amazon EC2.

Avant de commencer cette tâche, configurez votre AWS CDK environnement de développement et installez le AWS CDK en exécutant la commande suivante. Pour obtenir des instructions sur la configuration de votre AWS CDK environnement de développement, voir Commencer à utiliser le AWS CDK - Prérequis.

npm install -g aws-cdk
Note

Ces instructions supposent que vous utilisez AWS CDK v2.

Étape 1 : configurez votre AWS CDK project

Créez un répertoire pour votre nouveau AWS CDK application et initialisez le projet.

TypeScript
mkdir hello-ecs cd hello-ecs cdk init --language typescript
JavaScript
mkdir hello-ecs cd hello-ecs cdk init --language javascript
Python
mkdir hello-ecs cd hello-ecs cdk init --language python

Une fois le projet démarré, activez l'environnement virtuel du projet et installez AWS CDK les dépendances de base de l'entreprise.

source .venv/bin/activate python -m pip install -r requirements.txt
Java
mkdir hello-ecs cd hello-ecs cdk init --language java

Importez ce projet Maven dans votre IDE Java. Par exemple, dans Eclipse, utilisez Fichier >Importer >Maven >Projets Maven existants.

C#
mkdir hello-ecs cd hello-ecs cdk init --language csharp
Go
mkdir hello-ecs cd hello-ecs cdk init --language go
Note

Le AWS CDK Un modèle d'application utilise le nom du répertoire du projet pour générer des noms pour les fichiers source et les classes. Dans cet exemple, le répertoire est nommé hello-ecs. Si vous utilisez un nom répertoire différent, votre application ne correspondra pas à ces instructions.

AWS CDK La v2 inclut des constructions stables pour tous Services AWS dans un seul package appelé aws-cdk-lib. Ce package est installé en tant que dépendance lorsque vous initialisez le projet. Lorsque vous travaillez avec certains langages de programmation, le package est installé lorsque vous créez le projet pour la première fois. Cette rubrique explique comment utiliser une construction Amazon ECS Patterns, qui fournit des abstractions de haut niveau pour travailler avec Amazon ECS. Ce module s'appuie sur les constructions Amazon ECS et d'autres constructions pour allouer les ressources nécessaires à votre application Amazon ECS.

Les noms que vous utilisez pour importer ces bibliothèques dans votre application CDK peuvent différer légèrement selon le langage de programmation que vous utilisez. À titre de référence, les noms suivants sont utilisés dans chaque langage de programmation CDK pris en charge.

TypeScript
aws-cdk-lib/aws-ecs aws-cdk-lib/aws-ecs-patterns
JavaScript
aws-cdk-lib/aws-ecs aws-cdk-lib/aws-ecs-patterns
Python
aws_cdk.aws_ecs aws_cdk.aws_ecs_patterns
Java
software.amazon.awscdk.services.ecs software.amazon.awscdk.services.ecs.patterns
C#
Amazon.CDK.AWS.ECS Amazon.CDK.AWS.ECS.Patterns
Go
github.com/aws/aws-cdk-go/awscdk/v2/awsecs github.com/aws/aws-cdk-go/awscdk/v2/awsecspatterns

Étape 2 : utilisez le AWS CDK pour définir un serveur Web conteneurisé sur Fargate

Utilisez l’image du conteneur amazon-ecs-sample. Cette image contient une application Web PHP qui s'exécute sur nginx.

Dans le AWS CDK projet que vous avez créé, modifiez le fichier contenant la définition de la pile pour qu'il ressemble à l'un des exemples suivants.

Note

Une pile est une unité de déploiement. Toutes les ressources doivent se trouver dans une pile et toutes les ressources d'une pile sont déployées en même temps. Si une ressource ne parvient pas à se déployer, toutes les autres ressources déjà déployées sont annulées. Un AWS CDK l'application peut contenir plusieurs piles, et les ressources d'une pile peuvent faire référence à des ressources d'une autre pile.

TypeScript

Mise à jour lib/hello-ecs-stack.ts de sorte qu'il ressemble à ce qui suit.

import * as cdk from 'aws-cdk-lib'; import { Construct } from 'constructs'; import * as ecs from 'aws-cdk-lib/aws-ecs'; import * as ecsp from 'aws-cdk-lib/aws-ecs-patterns'; export class HelloEcsStack extends cdk.Stack { constructor(scope: Construct, id: string, props?: cdk.StackProps) { super(scope, id, props); new ecsp.ApplicationLoadBalancedFargateService(this, 'MyWebServer', { taskImageOptions: { image: ecs.ContainerImage.fromRegistry('public.ecr.aws/ecs-sample-image/amazon-ecs-sample:latest'), }, publicLoadBalancer: true }); } }
JavaScript

Mise à jour lib/hello-ecs-stack.js de sorte qu'il ressemble à ce qui suit.

const cdk = require('aws-cdk-lib'); const { Construct } = require('constructs'); const ecs = require('aws-cdk-lib/aws-ecs'); const ecsp = require('aws-cdk-lib/aws-ecs-patterns'); class HelloEcsStack extends cdk.Stack { constructor(scope = Construct, id = string, props = cdk.StackProps) { super(scope, id, props); new ecsp.ApplicationLoadBalancedFargateService(this, 'MyWebServer', { taskImageOptions: { image: ecs.ContainerImage.fromRegistry('amazon/amazon-ecs-sample'), }, publicLoadBalancer: true }); } } module.exports = { HelloEcsStack }
Python

Mise à jour hello-ecs/hello_ecs_stack.py de sorte qu'il ressemble à ce qui suit.

import aws_cdk as cdk from constructs import Construct import aws_cdk.aws_ecs as ecs import aws_cdk.aws_ecs_patterns as ecsp class HelloEcsStack(cdk.Stack): def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None: super().__init__(scope, construct_id, **kwargs) ecsp.ApplicationLoadBalancedFargateService(self, "MyWebServer", task_image_options=ecsp.ApplicationLoadBalancedTaskImageOptions( image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")), public_load_balancer=True )
Java

Mise à jour src/main/java/com.myorg/HelloEcsStack.java de sorte qu'il ressemble à ce qui suit.

package com.myorg; import software.constructs.Construct; import software.amazon.awscdk.Stack; import software.amazon.awscdk.StackProps; import software.amazon.awscdk.services.ecs.ContainerImage; import software.amazon.awscdk.services.ecs.patterns.ApplicationLoadBalancedFargateService; import software.amazon.awscdk.services.ecs.patterns.ApplicationLoadBalancedTaskImageOptions; public class HelloEcsStack extends Stack { public HelloEcsStack(final Construct scope, final String id) { this(scope, id, null); } public HelloEcsStack(final Construct scope, final String id, final StackProps props) { super(scope, id, props); ApplicationLoadBalancedFargateService.Builder.create(this, "MyWebServer") .taskImageOptions(ApplicationLoadBalancedTaskImageOptions.builder() .image(ContainerImage.fromRegistry("amazon/amazon-ecs-sample")) .build()) .publicLoadBalancer(true) .build(); } }
C#

Mise à jour src/HelloEcs/HelloEcsStack.cs de sorte qu'il ressemble à ce qui suit.

using Amazon.CDK; using Constructs; using Amazon.CDK.AWS.ECS; using Amazon.CDK.AWS.ECS.Patterns; namespace HelloEcs { public class HelloEcsStack : Stack { internal HelloEcsStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props) { new ApplicationLoadBalancedFargateService(this, "MyWebServer", new ApplicationLoadBalancedFargateServiceProps { TaskImageOptions = new ApplicationLoadBalancedTaskImageOptions { Image = ContainerImage.FromRegistry("amazon/amazon-ecs-sample") }, PublicLoadBalancer = true }); } } }
Go

Mise à jour hello-ecs.go de sorte qu'il ressemble à ce qui suit.

package main import ( "github.com/aws/aws-cdk-go/awscdk/v2" // "github.com/aws/aws-cdk-go/awscdk/v2/awssqs" "github.com/aws/aws-cdk-go/awscdk/v2/awsecs" "github.com/aws/aws-cdk-go/awscdk/v2/awsecspatterns" "github.com/aws/constructs-go/constructs/v10" "github.com/aws/jsii-runtime-go" ) type HelloEcsStackProps struct { awscdk.StackProps } func NewHelloEcsStack(scope constructs.Construct, id string, props *HelloEcsStackProps) awscdk.Stack { var sprops awscdk.StackProps if props != nil { sprops = props.StackProps } stack := awscdk.NewStack(scope, &id, &sprops) // The code that defines your stack goes here // example resource // queue := awssqs.NewQueue(stack, jsii.String("HelloEcsQueue"), &awssqs.QueueProps{ // VisibilityTimeout: awscdk.Duration_Seconds(jsii.Number(300)), // }) res := awsecspatterns.NewApplicationLoadBalancedFargateService(stack, jsii.String("MyWebServer"), &awsecspatterns.ApplicationLoadBalancedFargateServiceProps{ TaskImageOptions: &awsecspatterns.ApplicationLoadBalancedTaskImageOptions{ Image: awsecs.ContainerImage_FromRegistry(jsii.String("amazon/amazon-ecs-sample"), &awsecs.RepositoryImageProps{}), }, }, ) awscdk.NewCfnOutput(stack, jsii.String("LoadBalancerDNS"), &awscdk.CfnOutputProps{Value: res.LoadBalancer().LoadBalancerDnsName()}) return stack } func main() { defer jsii.Close() app := awscdk.NewApp(nil) NewHelloEcsStack(app, "HelloEcsStack", &HelloEcsStackProps{ awscdk.StackProps{ Env: env(), }, }) app.Synth(nil) } // env determines the AWS environment (account+region) in which our stack is to // be deployed. For more information see: https://docs.aws.amazon.com/cdk/latest/guide/environments.html func env() *awscdk.Environment { // If unspecified, this stack will be "environment-agnostic". // Account/Region-dependent features and context lookups will not work, but a // single synthesized template can be deployed anywhere. //--------------------------------------------------------------------------- return nil // Uncomment if you know exactly what account and region you want to deploy // the stack to. This is the recommendation for production stacks. //--------------------------------------------------------------------------- // return &awscdk.Environment{ // Account: jsii.String("123456789012"), // Region: jsii.String("us-east-1"), // } // Uncomment to specialize this stack for the AWS Account and Region that are // implied by the current CLI configuration. This is recommended for dev // stacks. //--------------------------------------------------------------------------- // return &awscdk.Environment{ // Account: jsii.String(os.Getenv("CDK_DEFAULT_ACCOUNT")), // Region: jsii.String(os.Getenv("CDK_DEFAULT_REGION")), // } }

Le court extrait précédent inclut les éléments suivants :

  • Le nom logique du service : MyWebServer.

  • L’image du conteneur, obtenue à partir de la galerie publique Amazon ECR :amazon/amazon-ecs-sample.

  • D'autres informations pertinentes, telles que le fait que l'équilibreur de charge a une adresse publique et est accessible à partir d'Internet.

Le AWS CDK créera toutes les ressources nécessaires au déploiement du serveur Web, y compris les ressources suivantes. Ces ressources ont été omises dans cet exemple.

  • Cluster Amazon ECS

  • Instances Amazon VPC et Amazon EC2

  • Groupe Auto Scaling

  • Application Load Balancer

  • Rôles et politiques IAM

Certaines ressources allouées automatiquement sont partagées par tous les Amazon ECS services définis dans la pile.

Enregistrez le fichier source, puis exécutez la commande cdk synth dans le répertoire principal de l'application. Le AWS CDK lance l'application et synthétise un CloudFormation modèle à partir de celui-ci, puis affiche le modèle. Le modèle est un fichier YAML d'environ 600 lignes. Le début du fichier est illustré ici. Votre modèle peut être différent de cet exemple.

Resources: MyWebServerLB3B5FD3AB: Type: AWS::ElasticLoadBalancingV2::LoadBalancer Properties: LoadBalancerAttributes: - Key: deletion_protection.enabled Value: "false" Scheme: internet-facing SecurityGroups: - Fn::GetAtt: - MyWebServerLBSecurityGroup01B285AA - GroupId Subnets: - Ref: EcsDefaultClusterMnL3mNNYNVpcPublicSubnet1Subnet3C273B99 - Ref: EcsDefaultClusterMnL3mNNYNVpcPublicSubnet2Subnet95FF715A Type: application DependsOn: - EcsDefaultClusterMnL3mNNYNVpcPublicSubnet1DefaultRouteFF4E2178 - EcsDefaultClusterMnL3mNNYNVpcPublicSubnet2DefaultRouteB1375520 Metadata: aws:cdk:path: HelloEcsStack/MyWebServer/LB/Resource MyWebServerLBSecurityGroup01B285AA: Type: AWS::EC2::SecurityGroup Properties: GroupDescription: Automatically created Security Group for ELB HelloEcsStackMyWebServerLB06757F57 SecurityGroupIngress: - CidrIp: 0.0.0.0/0 Description: Allow from anyone on port 80 FromPort: 80 IpProtocol: tcp ToPort: 80 VpcId: Ref: EcsDefaultClusterMnL3mNNYNVpc7788A521 Metadata: aws:cdk:path: HelloEcsStack/MyWebServer/LB/SecurityGroup/Resource # and so on for another few hundred lines

Pour déployer le service dans votre Compte AWS, exécutez le cdk deploy commande dans le répertoire principal de votre application. Vous êtes invité à approuver les politiques IAM que le AWS CDK généré.

Le déploiement dure plusieurs minutes, au cours desquelles AWS CDK crée plusieurs ressources. Les dernières lignes de la sortie du déploiement incluent le nom d'hôte public de l'équilibreur de charge et l'URL de votre nouveau serveur web. Ce sont les suivants.

Outputs: HelloEcsStack.MyWebServerLoadBalancerDNSXXXXXXX = Hello-MyWeb-ZZZZZZZZZZZZZ-ZZZZZZZZZZ.us-west-2.elb.amazonaws.com HelloEcsStack.MyWebServerServiceURLYYYYYYYY = http://Hello-MyWeb-ZZZZZZZZZZZZZ-ZZZZZZZZZZ.us-west-2.elb.amazonaws.com

Étape 3 : Tester le service web

Copiez l'URL de la sortie de déploiement et collez-la dans votre navigateur web. Le message de bienvenue suivant provenant du serveur web s'affiche.

Capture d'écran de l'exemple d'application Amazon ECS. La sortie indique « Amazon ECS ».

Étape 4 : nettoyer

Une fois que vous avez terminé d'utiliser le serveur web, arrêtez le service à l'aide du CDK en exécutant la commande cdk destroy dans le répertoire principal de votre application. Cela vous évite de subir des frais imprévus à l'future.

Étapes suivantes

Pour en savoir plus sur la façon de développer AWS infrastructure utilisant le AWS CDK, consultez le AWS CDK Guide du développeur.

Pour plus d'informations sur l'écriture AWS CDK applications dans la langue de votre choix, consultez les rubriques suivantes :

TypeScript

En collaboration avec le AWS CDK dans TypeScript

JavaScript

En collaboration avec le AWS CDK dans JavaScript

Python

En collaboration avec le AWS CDK en Python

Java

En collaboration avec le AWS CDK en Java

C#

En collaboration avec le AWS CDK en C#

Go

En collaboration avec le AWS CDK en Go

Pour plus d'informations sur le AWS Modules Construct Library utilisés dans cette rubrique, voir ce qui suit AWS CDK Aperçus des références d'API.