DEV Community

Cover image for Escalando Containers com ECS Fargate Baseado em Mensagens SQS
Gustavo Aleixo
Gustavo Aleixo

Posted on

Escalando Containers com ECS Fargate Baseado em Mensagens SQS

#aws #serverless #community #fargate

Em sistemas modernos, a necessidade de escalabilidade e processamento sob demanda é cada vez mais comum. Para lidar com grandes volumes de dados de forma eficiente, a combinação de serviços de mensageria, como o Amazon SQS, com uma plataforma de orquestração de containers, como o Amazon ECS, permite armazenar e distribuir mensagens de maneira assíncrona, garantindo que as aplicações processem as informações no seu próprio ritmo.

Neste artigo, vamos explorar como configurar essa arquitetura, utilizando o Amazon ECS Fargate para hospedar containers que escalam automaticamente com base no volume de mensagens na fila do SQS.

Requisitos

Para a realização deste laboratório, é necessário:

  • Possuir uma conta AWS.
  • Ter o AWS CLI instalado e configurado em sua máquina.

Arquitetura

Imagem da arquitetura proposta

Recursos da Arquitetura

  • Amazon SQS: Serviço de filas AWS.
  • Amazon ECS Fargate: Serviço de containers serverless.
  • AWS CloudWatch: Serviço de monitoramento e geração de métricas para autoscaling.
  • Application Auto Scaling: Serviço de gerenciamento automático de escalabilidade.

Fluxo da Arquitetura

  1. Um sistema externo ou API envia mensagens para a fila SQS.
  2. O Amazon CloudWatch monitora o número de mensagens na fila.
  3. O Application Auto Scaling ajusta dinamicamente o número de tasks no ECS Fargate com base nas métricas do CloudWatch.
  4. As tasks do ECS Fargate consomem e processam as mensagens.

Criando a Fila SQS

Com o AWS CLI configurado para sua conta, acesse o terminal e execute o comando abaixo, substituindo <regiao> pela sua região AWS:

aws sqs create-queue --region <regiao> --queue-name consumer-queue-ecs-sample.fifo --attributes '{"FifoQueue":"true"}'
Enter fullscreen mode Exit fullscreen mode

Saída esperada no terminal:

{
    "QueueUrl": "https://sqs.<regiao>.amazonaws.com/<conta-aws>/consumer-queue-ecs-sample.fifo"
}
Enter fullscreen mode Exit fullscreen mode

Copie a URL da fila que foi retornada pelo terminal e armazene!

Criando e Disponibilizando a Imagem no ECR

Para exemplificar, utilizaremos um script previamente criado para consumir as mensagens da fila. Vamos iniciar?

Clonando o Repositório do GitHub 

git clone https://github.com/GustavoAleixo/consumer-queue-ecs-sample.git
Enter fullscreen mode Exit fullscreen mode

Acesse a pasta do repositório:

cd consumer-queue-ecs-sample
Enter fullscreen mode Exit fullscreen mode

Nesta pasta encontraremos:

|_ ecs
|  |__ ecs-trust-policy.json
|  |__ task-definition.json
|_ Dockerfile
|_ index.mjs
|_ README.md
|_ .env.example
Enter fullscreen mode Exit fullscreen mode

Edite o arquivo task-definition.json e substitua <conta-aws> pelo número da sua conta AWS e <regiao> pela região utilizada anteriormente na criação da fila.

Renomeie o arquivo .env.example para .env e edite-o, substituindo <regiao> pela região utilizada e <url-fila> pela URL da fila armazenada anteriormente.

Criando a Função IAM para o ECS

O ECS precisa de permissões para acessar a fila SQS e registrar logs no CloudWatch. Execute os comandos abaixo:

aws iam create-role --role-name ecsTaskExecutionRole --assume-role-policy-document file://ecs/ecs-trust-policy.json
Enter fullscreen mode Exit fullscreen mode

Agora, anexe as permissões necessárias:

aws iam attach-role-policy --role-name ecsTaskExecutionRole --policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
aws iam attach-role-policy --role-name ecsTaskExecutionRole --policy-arn arn:aws:iam::aws:policy/AmazonSQSFullAccess
Enter fullscreen mode Exit fullscreen mode

Criando e Configurando o ECS

Crie um cluster ECS:

aws ecs create-cluster --cluster-name consumer-queue-ecs-sample-cluster
Enter fullscreen mode Exit fullscreen mode

Depois, registre a definição da task:

aws ecs register-task-definition --cli-input-json file://ecs/task-definition.json
Enter fullscreen mode Exit fullscreen mode

Crie o serviço no ECS, substituindo <ID-SUBNET> e <ID-SECURITY-GROUP> pelos valores obtidos anteriormente:

aws ecs create-service \
    --cluster consumer-queue-ecs-sample-cluster \
    --service-name consumer-queue-ecs-sample-service \
    --task-definition consumer-queue-ecs-sample-task \
    --launch-type FARGATE \
    --desired-count 1 \
    --network-configuration "awsvpcConfiguration={subnets=[ID-SUBNET],securityGroups=[<ID-SECURITY-GROUP>],assignPublicIp=ENABLED}"
Enter fullscreen mode Exit fullscreen mode

Configurando Auto Scaling 

aws application-autoscaling register-scalable-target \
    --service-namespace ecs \
    --scalable-dimension ecs:service:DesiredCount \
    --resource-id service/consumer-queue-ecs-sample-cluster/consumer-queue-ecs-sample-service \
    --min-capacity 0 \
    --max-capacity 10
Enter fullscreen mode Exit fullscreen mode

Crie uma política de auto scaling baseada na fila:

aws application-autoscaling put-scaling-policy \
    --service-namespace ecs \
    --scalable-dimension ecs:service:DesiredCount \
    --resource-id service/consumer-queue-ecs-sample-cluster/consumer-queue-ecs-sample-service \
    --policy-name SQS-Scaling-Policy \
    --policy-type StepScaling \
    --step-scaling-policy-configuration '{"AdjustmentType": "ChangeInCapacity","StepAdjustments": [{"MetricIntervalLowerBound": 1,"ScalingAdjustment": 1}]}'
Enter fullscreen mode Exit fullscreen mode

Agora, vincule a política a uma métrica do CloudWatch:

aws cloudwatch put-metric-alarm \
    --alarm-name "SQS-Messages-Alarm" \
    --metric-name ApproximateNumberOfMessagesVisible \
    --namespace AWS/SQS \
    --statistic Sum \
    --period 60 \
    --threshold 1 \
    --comparison-operator GreaterThanOrEqualToThreshold \
    --dimensions Name=QueueName,Value=consumer-queue-ecs-sample.fifo \
    --evaluation-periods 1 \
    --alarm-actions <POLITICA-ARN> \
    --unit Count
Enter fullscreen mode Exit fullscreen mode

Tudo pronto!!! 🚀

Testando o Auto Scaling

Agora que todos os componentes foram configurados, vamos validar se o Auto Scaling está funcionando corretamente.

  1. Acesse o Console da AWS e navegue até a região onde os recursos foram criados.
  2. No campo de busca, procure por ECS e selecione o serviço Amazon Elastic Container Service.

Imagem do console aws, pesquisando pelo serviço ECS

  1. No painel do ECS, clique no cluster consumer-queue-ecs-sample-cluster.
  2. Selecione o serviço consumer-queue-ecs-sample-service e clique na aba Tasks para visualizar as instâncias em execução.

Imagem do console AWS, dentro do service do ECS

Enviando Mensagens para a Fila SQS

Agora, vamos testar o comportamento do Auto Scaling enviando mensagens para a fila SQS. Abra o terminal e execute os comandos abaixo, substituindo <regiao> e <conta-aws> pelos valores correspondentes:

  1. Envie a primeira mensagem: 
   aws sqs send-message \
       --queue-url https://sqs.<regiao>.amazonaws.com/<conta-aws>/consumer-queue-ecs-sample.fifo \
       --message-body "Message of number 1" \
       --message-group-id "example" \
       --message-deduplication-id "number1"
Enter fullscreen mode Exit fullscreen mode
  1. Aguarde alguns segundos e envie a segunda mensagem: 
aws sqs send-message \
    --queue-url https://sqs.<regiao>.amazonaws.com/<conta-aws>/consumer-queue-ecs-sample.fifo \
    --message-body "Message of number 2" \
    --message-group-id "example" \
    --message-deduplication-id "number2"
Enter fullscreen mode Exit fullscreen mode

Validando a Escala Automática

Após alguns instantes, volte ao console do ECS e atualize a página. Você verá novas tasks sendo iniciadas automaticamente para processar as mensagens da fila.

Imagem de duas tasks sendo executadas no console da AWS

Parabéns! 🎉 Agora, seu ambiente está configurado para escalar dinamicamente conforme a demanda.

Conclusão

Com essa arquitetura implementada, conseguimos criar um sistema que processa mensagens de forma eficiente e escalável. O Amazon ECS Fargate, aliado ao Amazon SQS e ao Application Auto Scaling, garante que nossa aplicação consiga lidar com diferentes cargas de trabalho automaticamente. Esse modelo permite otimizar recursos, reduzir custos e melhorar a eficiência do processamento de mensagens em sistemas distribuídos.

Top comments (0)