Exemplo: Crie um AWS Fargate serviço usando o AWS CDK - AWS Cloud Development Kit (AWS CDK) v2
Criar um projeto de CDKCriar um serviço FargateLimpeza

Este é o Guia do Desenvolvedor AWS CDK v2. O CDK v1 antigo entrou em manutenção em 1º de junho de 2022 e encerrou o suporte em 1º de junho de 2023.

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Exemplo: Crie um AWS Fargate serviço usando o AWS CDK

Neste exemplo, mostramos como criar um AWS Fargate serviço executado em um cluster do Amazon Elastic Container Service (Amazon ECS) que é liderado por um Application Load Balancer voltado para a Internet a partir de uma imagem no Amazon ECR.

O Amazon ECS é um serviço de gerenciamento de contêineres altamente escalável e rápido que facilita a execução, a parada e o gerenciamento Docker contêineres em um cluster. Você pode hospedar seu cluster em uma infraestrutura sem servidor gerenciada pelo Amazon ECS ao iniciar seus serviços ou tarefas usando o tipo de inicialização Fargate. Para obter mais controle, você pode hospedar suas tarefas em um cluster de instâncias do Amazon Elastic Compute Cloud (Amazon EC2) que você gerencia usando o tipo de EC2 lançamento da Amazon.

Neste exemplo, lançamos alguns serviços usando o tipo de inicialização do Fargate. Se você usou o AWS Management Console para criar um serviço Fargate, sabe que há muitas etapas a serem seguidas para realizar essa tarefa. AWS tem vários tutoriais e tópicos de documentação que orientam você na criação de um serviço Fargate, incluindo:

Este exemplo cria um serviço Fargate semelhante usando o AWS CDK.

A construção do Amazon ECS usada neste exemplo ajuda você a usar AWS serviços fornecendo os seguintes benefícios:

  • Configura automaticamente um balanceador de carga.

  • Abre automaticamente um grupo de segurança para balanceadores de carga. Isso permite que os balanceadores de carga se comuniquem com as instâncias sem precisar criar explicitamente um grupo de segurança.

  • Ordena automaticamente a dependência entre o serviço e o balanceador de carga vinculado a um grupo-alvo, onde o AWS CDK impõe a ordem correta de criação do receptor antes da criação de uma instância.

  • Configura automaticamente os dados do usuário em grupos de escalabilidade automática. Isso cria a configuração correta à qual associar um cluster AMIs.

  • Valida as combinações de parâmetros com antecedência. Isso expõe AWS CloudFormation problemas mais cedo, economizando tempo de implantação. Por exemplo, dependendo da tarefa, é fácil definir incorretamente as configurações de memória. Anteriormente, não encontrávamos nenhum erro até implantarmos nossa aplicação. Mas agora eles AWS CDK podem detectar uma configuração incorreta e emitir um erro quando sintetizamos nosso aplicativo.

  • Adicionar permissões automaticamente para o Amazon Elastic Container Registry (Amazon ECR) se usarmos uma imagem do Amazon ECR.

  • Escalar automaticamente. Ele AWS CDK fornece um método para que possamos escalar instâncias automaticamente quando usamos um EC2 cluster da Amazon. Isso acontece automaticamente quando usamos uma instância em um cluster Fargate.

    Além disso, AWS CDK evita que uma instância seja excluída quando o escalonamento automático tenta interromper uma instância, mas uma tarefa está em execução ou está programada nessa instância.

    Anteriormente, precisávamos criar uma função do Lambda para ter essa funcionalidade.

  • Fornece suporte de ativos, para que possamos implantar uma fonte de nossa máquina no Amazon ECS em uma única etapa. Anteriormente, para usar uma fonte de aplicativo, precisávamos realizar várias etapas manuais, como fazer o upload para o Amazon ECR e criar um Docker imagem.

Importante

As ApplicationLoadBalancedFargateService construções que usaremos incluem vários AWS componentes, alguns dos quais têm custos não triviais se deixados provisionados em nossa AWS conta, mesmo que não os usemos. Certifique-se de limpar (cdk destroy) se você seguir este exemplo.

Criar um projeto de CDK

Começamos criando um projeto CDK. Esse é um diretório que armazena nosso AWS CDK código, incluindo nosso aplicativo 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

Agora podemos importar o projeto Maven para o nosso IDE.

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

Agora podemos abrir o src/MyEcsConstruct.sln no Visual Studio.

Em seguida, executamos a aplicação e confirmamos que ele cria uma pilha vazia.

cdk synth

Criar um serviço Fargate

Há duas maneiras diferentes de executar nossas tarefas de contêiner com o Amazon ECS:

  • Usar o tipo de lançamento Fargate, em que o Amazon ECS gerencia as máquinas físicas nas quais nossos contêineres estão sendo executados para nós.

  • Usar o tipo de lançamento EC2, onde fazemos o gerenciamento, como especificar o escalonamento automático.

Neste exemplo, criaremos um serviço Fargate executado em um cluster Amazon ECS, liderado por um Application Load Balancer voltado para a Internet.

Adicionamos as seguintes importações do módulo AWS Construct Library ao nosso arquivo de pilha:

TypeScript

Arquivo: 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

Arquivo: 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

Arquivo: 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

Arquivo: 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#

Arquivo: src/MyEcsConstruct/MyEcsConstructStack.cs

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

Em nossa pilha, adicionamos o seguinte código:

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
                }
            );

Em seguida, validamos nosso código executando o seguinte para sintetizar nossa pilha:

cdk synth

A pilha tem centenas de linhas, então não a mostraremos aqui. A pilha deve conter uma instância padrão, uma sub-rede privada e uma sub-rede pública para as três zonas de disponibilidade e um grupo de segurança.

Para implantar a pilha, executamos o seguinte:

cdk deploy

AWS CloudFormation exibe informações sobre as dezenas de etapas necessárias ao implantar nosso aplicativo.

Após a conclusão da implantação, criamos com sucesso um serviço Amazon ECS baseado em Fargate para executar um Docker imagem.

Limpeza

Como prática recomendada de manutenção geral, e para minimizar custos desnecessários, excluímos nossa pilha quando concluída:

cdk destroy