跳到正文
DEV Community· Cláudio Filipe Lima Rapôso·· 4 天前AI 評分55

AWS 上的 Agent-to-Agent 網絡(第 1 部分):以 ECS Fargate、Service Connect 和 ElastiCache 建立 Concierge A2A + MCP 基礎設施

Malha Agent-to-Agent na AWS (Parte 1): Fundações do Concierge A2A + MCP com ECS Fargate, Service Connect e ElastiCache

AI 導讀

文章示範如何將 Concierge 的 A2A + MCP 多智能體系統部署至 AWS ECS Fargate,並建置服務發現、共享狀態及長時間 SSE 連線所需的基礎設施。

正文

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.

Tela inicial do Concierge com o status Online e o painel técnico ao lado

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.

Aba Serviços do painel técnico listando agentes e skills A2A descobertos

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.

Grafo multiagente animando as chamadas A2A e MCP em tempo real durante a cotação

Resultado da cotação com voos, hotéis e a conferência de política em andamento

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.

來源:DEV Community · dev.to