Sistemas multiagentes costumam nascer em um docker-compose.yml, onde cada agente encontra o outro pelo nome do serviço e tudo parece simples. O problema aparece no dia em que esse ecossistema precisa ir para a nuvem: os nomes flight-agent e flights-mcp deixam de resolver, o stream SSE que alimenta a interface é cortado pelo balanceador depois de 60 segundos e o Redis, que guardava sessões e ofertas com TTL, vira um ponto único de falha sem criptografia. Nesta série levamos o Concierge de Viagens, um orquestrador que conversa com agentes especialistas via protocolo Agent-to-Agent (A2A) em JSON-RPC 2.0, e esses agentes com servidores Model Context Protocol (MCP) que falam com Kiwi.com, Booking.com e um RAG de políticas corporativas, para a AWS. Nesta primeira parte construímos a fundação: rede, registro de imagens, cluster ECS Fargate com Service Connect preservando os mesmos nomes DNS do compose, ElastiCache com TLS e um Application Load Balancer preparado para Server-Sent Events.
Pré-requisitos
Terraform 1.7.0 ou superior, provider hashicorp/aws 5.80+, AWS CLI v2 autenticada em uma conta com permissão para criar VPC, ECS, ElastiCache, ECR, IAM e ELB, Docker com Buildx e o repositório do projeto clonado. O código Terraform completo está em infra/aws/ e foi validado com terraform validate; os trechos abaixo são recortes desses arquivos. Usamos us-east-1 como região padrão porque a Parte 2 depende de modelos do Amazon Bedrock disponíveis nela; troque a variável region se o modelo escolhido estiver disponível mais perto de você.
Passo a Passo
A arquitetura que vamos materializar
Antes de escrever uma linha de HCL, vale olhar o que roda localmente e o que muda na nuvem. Localmente temos onze containers; na AWS o LLM local (llama.cpp) sai de cena e dá lugar ao Bedrock, assunto da Parte 2. O restante é o mesmo código, a mesma imagem e os mesmos comandos.
flowchart LR U[Usuário] -->|HTTPS| ALB[Application Load Balancer<br/>idle_timeout 900s] ALB --> FE[frontend<br/>nginx + React] subgraph ECS["ECS Fargate · namespace concierge.internal (Service Connect)"] FE -->|/api/* SSE| OR[orchestrator :8000] OR -->|A2A JSON-RPC| FA[flight-agent :8011] OR -->|A2A JSON-RPC| HA[hotel-agent :8012] OR -->|A2A JSON-RPC| PA[policy-agent :8013] FA -->|MCP SSE| FM[flights-mcp :8001] HA -->|MCP SSE| HM[hotels-mcp :8002] PA -->|MCP SSE| PM[policies-mcp :8003] end OR --> R[(ElastiCache Redis<br/>TLS)] FM --> R HM --> R FM -->|MCP remoto| KIWI[Kiwi.com MCP] PM -->|Parte 2| BR[Amazon Bedrock] A decisão central é como os agentes se descobrem. O orquestrador lê FLIGHT_AGENT_URL=http://flight-agent:8011, busca o /.well-known/agent-card.json e só então despacha tarefas. Se trocássemos esses endereços por DNS do Cloud Map (flight-agent.concierge.internal) ou por endereços de load balancers internos, teríamos uma configuração diferente para cada ambiente, e o AgentCard que cada agente publica deixaria de bater com o endereço real.
Rede e isolamento: onde cada peça mora
Como garantir que só o balanceador seja público e que a malha leste-oeste fique fechada entre os próprios agentes? Usamos duas zonas de disponibilidade, sub-redes privadas para todas as tasks e sub-redes públicas apenas para o ALB e o NAT Gateway, que dá às tasks saída para o MCP remoto do Kiwi.com. Um único security group para as tasks, com regra self = true, libera o tráfego entre agentes sem abrir portas para o mundo; o Redis aceita conexões apenas desse grupo.
module "vpc" { source = "terraform-aws-modules/vpc/aws" version = "~> 5.16" name = "${var.name}-${var.environment}" cidr = var.vpc_cidr azs = local.azs private_subnets = [for i, _ in local.azs : cidrsubnet(var.vpc_cidr, 4, i)] public_subnets = [for i, _ in local.azs : cidrsubnet(var.vpc_cidr, 8, 200 + i)] enable_nat_gateway = true single_nat_gateway = var.environment != "prod" enable_dns_hostnames = true } resource "aws_security_group" "tasks" { name = "${var.name}-tasks" vpc_id = module.vpc.vpc_id ingress { from_port = 0 to_port = 0 protocol = "-1" self = true # agentes falam entre si } ingress { from_port = 80 to_port = 80 protocol = "tcp" security_groups = [aws_security_group.alb.id] # so o ALB chega no frontend } egress { from_port = 0 to_port = 0 protocol = "-1" cidr_blocks = ["0.0.0.0/0"] } } O single_nat_gateway condicionado ao ambiente é uma economia consciente: em desenvolvimento um NAT basta; em produção cada zona ganha o seu, e a falha de uma AZ não derruba a saída para os provedores de voos.
Estado compartilhado: ElastiCache com criptografia em trânsito
Por que não manter o Redis como mais um container? Porque ele guarda três coisas que não podem sumir em um redeploy: as ofertas com TTL de 15 minutos (o preço garantido ao viajante), as chaves de idempotência da Saga de reserva e as conversas salvas. Um replication group com transit_encryption_enabled exige que o cliente use rediss://, e esse é o único ajuste de configuração na aplicação: a biblioteca redis-py já entende o esquema.
resource "aws_elasticache_replication_group" "redis" { replication_group_id = "${var.name}-${var.environment}" description = "Sessoes, ofertas com TTL e aprovacoes do concierge" engine = "redis" engine_version = "7.1" node_type = "cache.t4g.small" num_cache_clusters = var.environment == "prod" ? 2 : 1 automatic_failover_enabled = var.environment == "prod" subnet_group_name = aws_elasticache_subnet_group.redis.name security_group_ids = [aws_security_group.redis.id] at_rest_encryption_enabled = true transit_encryption_enabled = true } locals { redis_url = "rediss://${aws_elasticache_replication_group.redis.primary_endpoint_address}:6379/0" } Service Connect: os mesmos nomes do compose dentro do cluster
Como fazer http://flights-mcp:8001/sse funcionar no ECS sem tocar no código? O ECS Service Connect injeta um proxy Envoy em cada task e registra client aliases no namespace. Se o alias tiver exatamente o nome do serviço do compose, todo container do namespace passa a resolver flights-mcp para o proxy local, que encaminha para uma task saudável. Modelamos os sete serviços Python como um mapa e geramos task definitions e services com for_each, porque todos usam a mesma imagem e mudam apenas comando, porta e variáveis.
locals { python_services = { "flight-agent" = { port = 8011, cpu = 256, memory = 512, role = "default" command = ["uvicorn", "agents.flight_agent:app", "--host", "0.0.0.0", "--port", "8011"] env = { FLIGHTS_MCP_SSE_URL = "http://flights-mcp:8001/sse" AGENT_PUBLIC_URL = "http://flight-agent:8011/a2a" } } # ... flights-mcp, hotels-mcp, policies-mcp, hotel-agent, policy-agent, orchestrator } } resource "aws_ecs_service" "python" { for_each = local.python_services name = each.key cluster = aws_ecs_cluster.main.id task_definition = aws_ecs_task_definition.python[each.key].arn launch_type = "FARGATE" desired_count = 1 network_configuration { subnets = module.vpc.private_subnets security_groups = [aws_security_group.tasks.id] } service_connect_configuration { enabled = true namespace = aws_service_discovery_http_namespace.mesh.arn service { port_name = each.key discovery_name = each.key client_alias { port = each.value.port dns_name = each.key # o mesmo nome do docker-compose } timeout { idle_timeout_seconds = 900 per_request_timeout_seconds = 0 # SSE longo: sem corte por requisicao } } } deployment_circuit_breaker { enable = true rollback = true } } O bloco timeout é o detalhe que mais custa caro quando esquecido. O Envoy do Service Connect encerra requisições HTTP longas por padrão, e o orquestrador mantém um stream SSE aberto durante toda a análise de política. Para que o portMappings seja tratado como HTTP pelo proxy, a task definition declara appProtocol = "http" e dá um name à porta, que é o port_name referenciado acima.
O fluxo de uma cotação, já dentro do cluster, fica assim:
sequenceDiagram participant FE as frontend (nginx) participant OR as orchestrator participant SC as Envoy (Service Connect) participant FA as flight-agent participant FM as flights-mcp participant R as ElastiCache FE->>OR: POST /chat/quote/stream (SSE) OR->>SC: GET http://flight-agent:8011/.well-known/agent-card.json SC->>FA: encaminha para task saudável FA-->>OR: AgentCard (skills) OR->>FA: JSON-RPC message/send search_flight_offers FA->>FM: MCP tools/call (SSE) FM->>R: SETEX oferta TTL 900s FM-->>FA: ofertas normalizadas FA-->>OR: Task completed + artifacts OR-->>FE: data: {"type":"step"...} a cada salto O balanceador e o stream que não pode cair
O frontend é um nginx que serve o React e faz proxy de /api/ para orchestrator:8000, resolvido pelo Service Connect; por isso o serviço do frontend habilita Service Connect sem bloco service, como cliente puro da malha. No ALB, o idle_timeout padrão de 60 segundos derrubaria a análise de política, que leva de um a três minutos. Subimos para 900 segundos e, como segunda linha de defesa, o orquestrador emite um comentário SSE : keepalive a cada 15 segundos quando não há eventos novos.
resource "aws_lb" "web" { name = "${var.name}-${var.environment}" load_balancer_type = "application" subnets = module.vpc.public_subnets security_groups = [aws_security_group.alb.id] idle_timeout = 900 } O heartbeat no gateway é pequeno e vale para qualquer nuvem:
SSE_HEARTBEAT_SECONDS = float(os.getenv("SSE_HEARTBEAT_SECONDS", "15")) async def gen(): ... while True: try: event = await asyncio.wait_for(queue.get(), timeout=SSE_HEARTBEAT_SECONDS) except asyncio.TimeoutError: # comentario SSE: o cliente ignora, mas ALB/Envoy veem trafego yield ": keepalive\n\n" continue yield f"data: {json.dumps(event, ensure_ascii=False)}\n\n" if event["type"] in ("result", "error"): break Construindo, publicando e subindo
O pipeline é deliberadamente simples: aplicamos primeiro só o ECR, publicamos as duas imagens com a tag do commit e então aplicamos o restante, passando a mesma tag. Os repositórios são IMMUTABLE, então cada deploy é rastreável até um SHA.
cd infra/aws terraform init terraform apply -target=aws_ecr_repository.app TAG=$(git rev-parse --short HEAD) REGISTRY=$(terraform output -json ecr_repositories | jq -r '."travel-app"' | cut -d/ -f1) aws ecr get-login-password | docker login --username AWS --password-stdin "$REGISTRY" docker buildx build --platform linux/amd64 -t "$REGISTRY/concierge/travel-app:$TAG" --push ../.. docker buildx build --platform linux/amd64 -t "$REGISTRY/concierge/travel-frontend:$TAG" --push ../../frontend terraform apply -var image_tag="$TAG" Validando a fundação
A validação acontece em três camadas: infraestrutura, malha e interface. Na infraestrutura, todos os serviços precisam estar estáveis e com o número desejado de tasks:
aws ecs describe-services --cluster concierge-dev \ --services orchestrator flight-agent hotel-agent policy-agent flights-mcp hotels-mcp policies-mcp frontend \ --query 'services[].[serviceName,runningCount,desiredCount,deployments[0].rolloutState]' --output table Todas as linhas devem mostrar runningCount igual a desiredCount e COMPLETED. Na malha, o teste mais honesto é pedir ao próprio orquestrador que descubra os agentes. Com ECS Exec habilitado no serviço, abrimos um shell na task e chamamos o /health, que só responde com os três agentes se os AgentCards forem alcançáveis pelos aliases do Service Connect:
TASK=$(aws ecs list-tasks --cluster concierge-dev --service-name orchestrator --query 'taskArns[0]' --output text) aws ecs execute-command --cluster concierge-dev --task "$TASK" --container orchestrator \ --interactive --command "curl -s http://localhost:8000/health" A resposta esperada é a mesma que obtemos no ambiente local:
{"status":"ok","discovered_agents":["FlightBookingAgent","HotelBookingAgent","TravelPolicyAgent"], "registered_skills":["search_flight_offers","issue_flight_order","search_hotel_offers","book_hotel_stay", "evaluate_travel_policy","answer_policy_question"]} Na interface, abrimos o app_url do output do Terraform. O badge "Online" no topo confirma que o nginx alcançou o orquestrador pela malha.
A aba Serviços do painel técnico mostra o resultado do /health e a topologia esperada; se um agente não aparecer em "agentes (AgentCard)", o problema está no alias do Service Connect daquele serviço.
Por fim, uma cotação real ("fln para recife de 10 a 17 de dezembro") exercita a malha inteira. O grafo marca cada salto no momento em que acontece; se ele congelar no meio, o corte está entre o ALB e o orquestrador, e não nos agentes.
As capturas desta série foram feitas no ambiente local (Docker), que executa exatamente as mesmas imagens; na AWS a única diferença visível é a URL do balanceador.
Solução de Problemas Comuns
O primeiro erro típico é o orquestrador subir, mas o /health responder discovered_agents: [] e o log mostrar httpx.ConnectError para flight-agent:8011. Isso acontece quando o serviço do agente não declarou service_connect_configuration com client_alias ou quando a porta da task definition não tem name igual ao port_name; sem isso o alias não é publicado e o nome não resolve. Verifique com aws ecs describe-services --query 'services[].deployments[0].serviceConnectConfiguration'.
O segundo é a interface mostrar a cotação, mas a conferência de política terminar com "Perdi a conexão com o servidor no meio do pedido" depois de exatamente 60 segundos, ou de 15 segundos no caso do Envoy. É timeout: confira o idle_timeout do ALB, o bloco timeout do Service Connect no serviço do orquestrador e se a imagem em uso já tem o heartbeat SSE. Um curl -N no endpoint /api/policies/ask/stream deve exibir linhas : keepalive a cada 15 segundos.
Conclusão
Com rede privada, imagens imutáveis, ElastiCache criptografado e Service Connect preservando os nomes do compose, levamos um ecossistema A2A + MCP para o ECS sem alterar a lógica de descoberta: os AgentCards continuam válidos, os agentes continuam se encontrando pelo nome e o stream SSE sobrevive ao balanceador. A malha está pronta, mas o agente de políticas ainda não tem um modelo para raciocinar. Na Parte 2 substituímos o llama.cpp pelo Amazon Bedrock, com Claude para extrair limites das políticas e Titan Embeddings para o RAG híbrido, sem mudar a interface do agente.
Referências
Amazon Web Services. (2024). Amazon ECS Service Connect. AWS Documentation.
Google. (2025). Agent2Agent (A2A) Protocol Specification. a2a-protocol.org.
Anthropic. (2024). Model Context Protocol Specification. modelcontextprotocol.io.





