Selecione suas preferências de cookies

Usamos cookies essenciais e ferramentas semelhantes que são necessárias para fornecer nosso site e serviços. Usamos cookies de desempenho para coletar estatísticas anônimas, para que possamos entender como os clientes usam nosso site e fazer as devidas melhorias. Cookies essenciais não podem ser desativados, mas você pode clicar em “Personalizar” ou “Recusar” para recusar cookies de desempenho.

Se você concordar, a AWS e terceiros aprovados também usarão cookies para fornecer recursos úteis do site, lembrar suas preferências e exibir conteúdo relevante, incluindo publicidade relevante. Para aceitar ou recusar todos os cookies não essenciais, clique em “Aceitar” ou “Recusar”. Para fazer escolhas mais detalhadas, clique em “Personalizar”.

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

Modo de foco
Exemplo: criar um serviço AWS Fargate usando o AWS CDK - AWS Cloud Development Kit (AWS CDK) v2

Este é o Guia do Desenvolvedor AWS CDK v2. A CDK v1 mais antiga 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á.

Este é o Guia do Desenvolvedor AWS CDK v2. A CDK v1 mais antiga 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á.

Neste exemplo, mostramos como criar um serviço 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 Docker 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) 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 AWS Management Console para criar um serviço 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 Fargate, incluindo:

Este exemplo cria um serviço 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-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 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 nosso aplicativo. Mas agora o AWS CDK pode 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. 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 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 uma imagem Docker.

Importante

Os constructos ApplicationLoadBalancedFargateService que usaremos incluem vários componentes AWS, alguns dos quais têm custos não triviais se deixados provisionados em nossa conta AWS, 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 código AWS CDK, 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.

mkdir MyEcsConstruct cd MyEcsConstruct cdk init --language typescript

Em seguida, executamos o aplicativo 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 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;

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";

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

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 nosso aplicativo.

Após a conclusão da implantação, criamos com sucesso um serviço Amazon ECS baseado em Fargate para executar uma imagem 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
PrivacidadeTermos do sitePreferências de cookies
© 2025, Amazon Web Services, Inc. ou suas afiliadas. Todos os direitos reservados.