Étape 1 : Configurez votre AWS CDK projet Étape 2 : utilisez le AWS CDK pour définir un serveur Web conteneurisé sur Fargate Étape 3 : Tester le service web Étape 4 : Nettoyer Étapes suivantes

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

AWS Cloud Development Kit (AWS CDK) Il s'agit d'un framework d'infrastructure en tant que code (IAC) que vous pouvez utiliser pour définir l'infrastructure AWS 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 dans un AWS CloudFormation modèle 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 on Fargate. AWS CDK

La bibliothèque AWS Construct, incluse dans le CDK, fournit des modules que vous pouvez utiliser pour modéliser les ressources Services AWS fournies. 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 environnement de AWS CDK développement et installez-le AWS CDK en exécutant la commande suivante. Pour obtenir des instructions sur la configuration de votre environnement de AWS CDK développement, consultez Getting Started with the AWS CDK - Prérequis.


npm install -g aws-cdk

Note

Ces instructions supposent que vous utilisez la AWS CDK version 2.

Rubriques

Étape 1 : Configurez votre AWS CDK projet
Étape 2 : utilisez le AWS CDK pour définir un serveur Web conteneurisé sur Fargate
Étape 3 : Tester le service web
Étape 4 : Nettoyer
Étapes suivantes

Étape 1 : Configurez votre AWS CDK projet

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

Note

Le modèle AWS CDK d'application utilise le nom du répertoire du projet pour générer des noms pour les classes et les fichiers sources. 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 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.

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

Utilisez l'image du conteneur amazon-ecs-sampleprovenant de DockerHub. Cette image contient une application web PHP fonctionnant sous Amazon Linux 2.

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. Une AWS CDK application peut contenir plusieurs piles, et les ressources d'une pile peuvent faire référence aux 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('amazon/amazon-ecs-sample'),
      },
      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 DockerHub :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.

Cela 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. AWS CDK Exécute l'application et synthétise un AWS CloudFormation modèle à partir de celle-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 la cdk deploy commande dans le répertoire principal de votre application. Il vous est demandé d'approuver les politiques IAM AWS CDK générées.

Le déploiement prend plusieurs minutes au cours desquelles plusieurs ressources sont créées. AWS CDK 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 que « Votre application s'exécute maintenant sur 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 le développement d'une AWS infrastructure à l'aide de AWS CDK, consultez le guide du AWS CDK développeur.

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

Pour plus d'informations sur les modules AWS Construct Library utilisés dans cette rubrique, consultez les aperçus des références AWS CDK d'API suivants.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Déploiement d'un exemple d'application Amazon ECS à l'aide de la CLI AWS Copilot

Création de ressources à l'aide de AWS CloudFormation