Exemplo: criação de um serviço de AWS Fargate usando o AWS CDK - AWS Kit de desenvolvimento em nuvem (AWS CDK) v2
Criar um projeto do CDKCriar um serviço do FargateLimpeza

Este é o Guia do desenvolvedor do 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: criação de um serviço de AWS Fargate usando o AWS CDK

Neste exemplo, mostramos como criar um serviço do AWS Fargate 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 interrupção e o gerenciamento de contêineres do Docker em um cluster. É possível hospedar seu cluster em uma infraestrutura com tecnologia sem servidor gerenciada pelo Amazon ECS ao iniciar seus serviços ou tarefas usando o tipo de inicialização do Fargate. Para obter mais controle, você pode hospedar suas tarefas em um cluster de instâncias do Amazon Elastic Compute Cloud (Amazon EC2) gerenciado usando o tipo de inicialização Amazon EC2.

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

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

O constructo do Amazon ECS usado neste exemplo ajuda você a usar serviços AWS 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 de destino, 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 para associar um cluster às AMIs.

  • Valida as combinações de parâmetros com antecedência. Isso expõe problemas do AWS CloudFormation 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 o AWS CDK pode detectar uma configuração incorreta e emitir um erro quando sintetizarmos nossa aplicação.

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

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

    Além disso, o AWS CDK evita que uma instância seja excluída quando o escalonamento automático tentar interromper uma instância, mas uma tarefa estiver em execução ou estiver 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 aplicação, precisávamos realizar várias etapas manuais, como fazer o carregamento no Amazon ECR e criar uma imagem do Docker.

Importante

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

Criar um projeto do CDK

Começamos criando um projeto do CDK. Esse é um diretório que armazena nosso código da AWS, incluindo nossa aplicação do 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 do 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 do 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 da Biblioteca de Constructos da AWS 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

O AWS CloudFormation exibe informações sobre as dezenas de etapas necessárias ao implantar nossa aplicação.

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

Limpeza

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

cdk destroy