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:
+ [Como implantar contêineres Docker - AWS](https://aws.amazon.com/getting-started/tutorials/deploy-docker-containers)
+ [Como fazer a configuração com o Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/get-set-up-for-amazon-ecs.html)
+ [Conceitos básicos do Amazon ECS usando o Fargate](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_GetStarted.html)
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.
**Example**
```
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language typescript
```
```
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language javascript
```
```
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language python
source .venv/bin/activate # On Windows, run '.\venv\Scripts\activate' instead
pip install -r requirements.txt
```
```
mkdir MyEcsConstruct
cd MyEcsConstruct
cdk init --language java
```
Agora podemos importar o projeto Maven para o nosso IDE.
```
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*:
**Example**
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";
```
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");
```
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)
```
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.*;
```
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:
**Example**
```
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
});
```
```
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
});
```
```
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
```
```
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();
```
```
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
```