Distribuir agentes entre nuvens é tentador pelos motivos certos: cada provedor tem o melhor serviço para uma parte do problema, a dependência de um único fornecedor diminui e uma região inteira pode cair sem derrubar o produto. O risco também é concreto. Uma chamada A2A que dentro de uma VPC era tráfego leste-oeste confiável passa a atravessar a internet, e o agente do outro lado não tem como saber se o message/send veio do orquestrador ou de qualquer um que descobriu o endereço. Nesta série distribuímos o Concierge de Viagens entre as duas nuvens das séries anteriores. O orquestrador, o agente de voos e o servidor MCP de voos ficam na AWS, perto do Kiwi.com. O agente de hotéis e o agente de políticas, com o RAG no Microsoft Foundry, ficam na Azure. Nesta primeira parte resolvemos a pergunta que vem antes de qualquer outra: como um agente na Azure confia em uma chamada que veio da AWS.
Pré-requisitos
As séries AWS e Azure aplicadas (raízes infra/aws e infra/azure), Terraform 1.7.0 ou superior com os providers aws 5.80+, azurerm 4.40+ e tls 4.0+, e PyJWT[crypto] 2.9 ou superior na imagem (já no requirements.txt). Também os IPs públicos dos NAT Gateways da VPC AWS, que entram como variável. A raiz infra/multicloud contém apenas os recursos que ligam as duas nuvens e foi validada com terraform validate.
Passo a Passo
Quem mora onde, e por quê
Por que não espelhar o sistema inteiro nas duas nuvens? Porque espelhar dobra custo e operação sem resolver o que motivou a distribuição. A divisão aqui segue afinidade de dados e de serviço. Voos dependem do MCP remoto do Kiwi.com e da emissão, que fica junto do orquestrador para manter a Saga em uma nuvem só. Políticas dependem do modelo no Foundry e dos documentos da empresa, que no exemplo moram no ecossistema Microsoft. Hotéis seguem a política por proximidade de dados.
flowchart LR U[Usuário] --> FE[frontend + orchestrator<br/>AWS ECS] subgraph AWS["AWS · us-east-1"] FE --> FA[flight-agent] FA --> FM[flights-mcp] --> KIWI[Kiwi.com MCP] FE --> R1[(ElastiCache)] SM[(Secrets Manager<br/>chave privada ES256)] -.-> FE end subgraph AZ["Azure · eastus2"] HA[hotel-agent<br/>ingress externo + IP allowlist] --> HM[hotels-mcp] PA[policy-agent<br/>ingress externo + IP allowlist] --> PM[policies-mcp] --> AIF[Claude no Foundry] KV[(Key Vault<br/>chave pública)] -.-> HA KV -.-> PA end FE ==>|"A2A HTTPS + Bearer JWT<br/>origem: IPs do NAT"| HA FE ==>|"A2A HTTPS + Bearer JWT"| PA Os agentes da Azure deixam de ter ingress interno, porque o orquestrador está fora do ambiente, e passam a ter ingress externo com duas barreiras independentes: restrição de IP de origem e validação de token por chamada.
Por que JWT assimétrico, e não uma chave compartilhada
Se as duas pontas conhecessem o mesmo segredo, qualquer vazamento do lado da Azure permitiria forjar chamadas como se fossem do orquestrador. Com assinatura ES256, só o orquestrador tem a chave privada, guardada no AWS Secrets Manager. A Azure recebe apenas a chave pública, que não serve para assinar nada. Cada chamada leva um token de 60 segundos com aud igual ao nome do agente. Um token capturado vale só para aquele agente e por um minuto, e um token emitido para o agente de hotéis é recusado pelo de políticas.
resource "tls_private_key" "a2a" { algorithm = "ECDSA" ecdsa_curve = "P256" } resource "aws_secretsmanager_secret" "a2a_signing_key" { name = "${var.name}/a2a/signing-key" recovery_window_in_days = 7 } resource "aws_secretsmanager_secret_version" "a2a_signing_key" { secret_id = aws_secretsmanager_secret.a2a_signing_key.id secret_string = tls_private_key.a2a.private_key_pem_pkcs8 } resource "azurerm_key_vault_secret" "a2a_public_key" { name = "a2a-trusted-public-key" key_vault_id = data.azurerm_key_vault.apps.id value = tls_private_key.a2a.public_key_pem content_type = "application/x-pem-file" } A geração da chave pelo provider tls é prática, mas grava a chave privada no state do Terraform. Em produção, use um backend criptografado com acesso restrito ou gere a chave fora do Terraform e importe apenas o secret.
O módulo de confiança
O código fica em shared/a2a_auth.py e é desligado por padrão: sem A2A_SIGNING_KEY e A2A_TRUSTED_PUBLIC_KEY, nada muda no ambiente local. O detalhe de segurança mais importante está na verificação: o algoritmo aceito é fixo em ES256 e nunca vem do cabeçalho do token, o que fecha a classe de ataques que troca o algoritmo para none ou para HMAC usando a chave pública como segredo.
def sign_token(audience: str, skill: str, private_key_pem: Optional[str] = None, now: Optional[float] = None) -> Optional[str]: key = private_key_pem or _pem("A2A_SIGNING_KEY") if not key: return None issued = int(now or time.time()) claims = {"iss": ISSUER, "aud": audience, "iat": issued, "exp": issued + TOKEN_TTL_SECONDS, "jti": uuid.uuid4().hex, "skill": skill} return jwt.encode(claims, key, algorithm="ES256", headers={"kid": os.getenv("A2A_KEY_ID", "a2a-1")}) def verify_token(token: Optional[str], audience: str, public_key_pem: Optional[str] = None) -> Dict[str, Any]: key = public_key_pem or _pem("A2A_TRUSTED_PUBLIC_KEY") if not key: return {"auth": "disabled"} if not token: raise A2AAuthError("token ausente") try: return jwt.decode(token, key, algorithms=["ES256"], audience=audience, issuer=ISSUER, leeway=CLOCK_SKEW_SECONDS, options={"require": ["exp", "iat", "iss", "aud"]}) except jwt.PyJWTError as exc: raise A2AAuthError(f"{exc.__class__.__name__}: {exc}") from exc A integração toca dois pontos já existentes. No orquestrador, o dispatch_skill acrescenta o cabeçalho antes do POST, usando como audience o nome do agente que veio no AgentCard. No agente, o handler /a2a verifica antes de despachar para o MCP:
# orchestrator/gateway.py, dentro de dispatch_skill token = a2a_auth.sign_token(audience=card.name, skill=skill_id) headers = {"Authorization": f"Bearer {token}"} if token else {} resp = await client.post(target_url, json=rpc_req.model_dump(), headers=headers) # agents/hotel_agent.py from fastapi import Header, HTTPException from shared import a2a_auth @app.post("/a2a", response_model=JsonRpcResponse) async def handle_a2a_rpc(request: JsonRpcRequest, authorization: str | None = Header(default=None)) -> JsonRpcResponse: try: a2a_auth.verify_token(a2a_auth.bearer(authorization), audience=AGENT_CARD.name) except a2a_auth.A2AAuthError as exc: log.warning("chamada A2A recusada: %s", exc) # motivo no log raise HTTPException(status_code=401, detail="unauthorized") # nada de detalhe para o chamador ... O AgentCard continua público em /.well-known/agent-card.json, como pede o protocolo: a descoberta é aberta, a execução é autenticada.
sequenceDiagram participant OR as orchestrator (AWS) participant SM as Secrets Manager participant NAT as NAT Gateway (IP fixo) participant IG as Ingress ACA (allowlist) participant HA as hotel-agent (Azure) participant KV as Key Vault Note over OR,SM: no start da task, A2A_SIGNING_KEY vem do Secrets Manager Note over HA,KV: na revisão, A2A_TRUSTED_PUBLIC_KEY vem do Key Vault OR->>NAT: GET /.well-known/agent-card.json NAT->>IG: origem = IP do NAT IG->>HA: permitido HA-->>OR: AgentCard (name=HotelBookingAgent) OR->>OR: sign_token(aud=HotelBookingAgent, exp=+60s) OR->>IG: POST /a2a + Authorization: Bearer ... IG->>HA: permitido HA->>HA: verify_token(ES256, aud, iss, exp) HA-->>OR: Task completed + artifacts A segunda barreira: origem da chamada
O JWT prova quem assinou, mas não impede que o mundo inteiro tente bater no agente. O ingress do Container Apps aceita regras ip_security_restriction, e liberamos somente os IPs dos NAT Gateways da VPC AWS, por onde saem todas as chamadas do orquestrador. O bloco entra no app de cada agente exposto em infra/azure/containerapps.tf:
ingress { external_enabled = true target_port = each.value.port transport = "http" traffic_weight { latest_revision = true percentage = 100 } dynamic "ip_security_restriction" { for_each = var.aws_nat_public_ips content { name = "aws-nat-${ip_security_restriction.key}" action = "Allow" ip_address_range = "${ip_security_restriction.value}/32" } } } Do lado da AWS, as variáveis HOTEL_AGENT_URL e POLICY_AGENT_URL do orquestrador passam a apontar para os FQDNs HTTPS dos apps na Azure. O A2A_SIGNING_KEY entra como secrets da task definition, referenciando o ARN do Secrets Manager, e não como variável em texto.
Validando
O módulo de confiança tem testes que rodam sem nenhuma nuvem. Eles geram um par de chaves, aceitam o token válido e recusam audience errada, chave de outro emissor, token expirado e token ausente:
pip install "pyjwt[crypto]" httpx cryptography python tests/test_multicloud_modules.py # a2a_auth: token valido aceito # a2a_auth: recusado (audience errada) -> InvalidAudienceError: Audience doesn't match # a2a_auth: recusado (chave de outro emissor) -> InvalidSignatureError: Signature verification failed # a2a_auth: recusado (token expirado) -> ExpiredSignatureError: Signature has expired # a2a_auth: recusado (token ausente) -> token ausente Com as duas nuvens no ar, três chamadas provam as barreiras. Da sua máquina, fora da allowlist, o ingress responde 403 antes de chegar ao agente. De dentro da task do orquestrador na AWS, sem token, o agente responde 401. Pelo próprio orquestrador, com token, a cotação funciona:
curl -s -o /dev/null -w '%{http_code}\n' -X POST "https://$HOTEL_FQDN/a2a" -d '{}' # 403 (origem fora da allowlist) aws ecs execute-command --cluster concierge-dev --task "$TASK" --container orchestrator --interactive \ --command "curl -s -o /dev/null -w '%{http_code}' -X POST https://$HOTEL_FQDN/a2a -H 'Content-Type: application/json' -d '{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"message/send\",\"params\":{}}'" # 401 (sem token) aws ecs execute-command --cluster concierge-dev --task "$TASK" --container orchestrator --interactive \ --command "curl -s http://localhost:8000/health" # discovered_agents com os três agentes: a descoberta atravessou as nuvens Na interface, nada muda para o viajante. A diferença aparece no painel técnico. Na aba Payloads, a requisição e a resposta de cada chamada mostram que o fluxo de cotação passou pelos agentes das duas nuvens. Na aba Eventos, as latências dos saltos para a Azure ficam visivelmente maiores que as dos saltos locais, um dado útil para decidir o que pode ser síncrono.
As capturas são do ambiente local, com todos os agentes na mesma máquina; em produção, os mesmos painéis mostram os saltos entre as nuvens.
Solução de Problemas Comuns
InvalidAudienceError no log do agente, com 401 para o orquestrador, indica que o aud assinado não bate com AGENT_CARD.name. Isso acontece quando o orquestrador usa o nome do serviço (hotel-agent) como audience em vez do nome publicado no AgentCard (HotelBookingAgent). Use sempre o card.name obtido na descoberta, o que também garante que o token vale para o agente que realmente respondeu.
ExpiredSignatureError intermitente, só em algumas chamadas, aponta para relógio dessincronizado ou para um token reaproveitado entre retentativas. Containers gerenciados sincronizam o relógio, então quase sempre a causa é cache do token. O módulo já tolera 30 segundos de diferença (A2A_CLOCK_SKEW_SECONDS), mas o certo é assinar um token novo a cada message/send. Já um 403 com corpo HTML vem do ingress, não do agente: a origem não está na allowlist, geralmente porque um NAT Gateway foi recriado e mudou de IP.
Conclusão
Distribuir o Concierge entre AWS e Azure exigiu tornar explícito o que a rede privada dava de graça: identidade de quem chama. Com JWT ES256 por chamada, chave privada só na AWS, chave pública na Azure, audience por agente e allowlist de origem no ingress, cada agente exposto só executa o que o orquestrador assinou no último minuto. Na Parte 2 tratamos do que acontece quando uma das nuvens falha: failover de agentes pelo AgentCard, DNS com health check e o que fazer com o estado das conversas.
Referências
Jones, M., Bradley, J., & Sakimura, N. (2015). JSON Web Token (JWT). RFC 7519. IETF.
Jones, M. (2015). JSON Web Algorithms (JWA). RFC 7518. IETF.
Google. (2025). Agent2Agent (A2A) Protocol Specification. a2a-protocol.org.



