DEV Community

Cover image for Orquestrando Ecossistemas Autônomos Multicloud: Implementando o Protocolo Agent-to-Agent (A2A) entre AWS e Azure
Cláudio Filipe Lima Rapôso
Cláudio Filipe Lima Rapôso

Posted on

Orquestrando Ecossistemas Autônomos Multicloud: Implementando o Protocolo Agent-to-Agent (A2A) entre AWS e Azure

A proliferação de agentes baseados em Modelos de Linguagem Grandes (LLMs) em ambientes corporativos criou um novo paradigma de silos operacionais. Quando um agente especializado hospedado na Amazon Web Services (AWS) precisa delegar uma análise de conformidade financeira a um agente autônomo executado na Microsoft Azure, integrações baseadas em APIs REST estáticas ou prompts acoplados colapsam sob o peso da ambiguidade semântica. Sem um contrato de descoberta dinâmica e negociação de tarefas, falhas silenciosas, loops infinitos de alucinação e vazamentos de contexto comprometem a governança distribuída. O protocolo Agent-to-Agent (A2A) resolve essa fragilidade ao estabelecer um padrão aberto de interoperabilidade para sistemas multiagentes. Ao combinar cartões de capacidade padronizados (Agent Cards), transporte assíncrono via JSON-RPC e Arquitetura Hexagonal, engenheiros constroem malhas cognitivas resilientes onde agentes especializados negociam, delegam e auditam tarefas complexas através de fronteiras de nuvem com segurança criptográfica e determinismo operacional.

Pré-requisitos

A construção de uma arquitetura distribuída baseada no protocolo Agent-to-Agent exige domínio sólido sobre sistemas orientados a eventos, segurança Zero Trust e padrões de comunicação assíncrona. A camada de infraestrutura demanda o Terraform versão 1.7.0 ou superior, integrado ao HashiCorp AWS Provider versão 5.40.0 e ao AzureRM Provider versão 3.90.0. O núcleo de execução dos agentes requer Python 3.12, acompanhado das bibliotecas fastapi versão 0.110.0, uvicorn versão 0.27.0, pydantic versão 2.6.0 e httpx versão 0.27.0 para chamadas assíncronas não bloqueantes. A federação de identidade exige o OpenID Connect (OIDC) ativo entre o AWS IAM e o Microsoft Entra ID para emissão de tokens de curta duração, eliminando segredos estáticos no tráfego entre provedores.

Provisionando a Infraestrutura de Descoberta e Roteamento

A interoperabilidade entre agentes autônomos começa pela capacidade de descoberta dinâmica de habilidades sem acoplamento prévio em tempo de compilação. Provisionamos os endpoints de borda na AWS utilizando o Amazon API Gateway e na Azure através do Azure API Management, expondo a rota padronizada /.well-known/agent.json. A justificativa arquitetural para expor esse manifesto público autenticado reside na descentralização da topologia. Um agente orquestrador na AWS não deve armazenar configurações estáticas sobre a localização interna ou os parâmetros exigidos pelo agente auditor na Azure. Ao consultar o Agent Card via HTTPS, o orquestrador inspeciona as capacidades declaradas, os esquemas de entrada e saída suportados e os requisitos de autenticação em tempo de execução. O Terraform garante que ambas as nuvens apliquem políticas rigorosas de limitação de taxa (rate limiting) e validação de tokens JWT na camada de borda, impedindo que agentes comprometidos ou mal configurados iniciem ataques de negação de serviço através de delegações recursivas descontroladas.

# Provisionamento do Endpoint de Descoberta A2A na AWS
resource "aws_apigatewayv2_api" "a2a_agent_gateway" {
  name          = "aws-financial-orchestrator-a2a"
  protocol_type = "HTTP"
  description   = "Gateway de borda para interoperabilidade Agent-to-Agent"
}

resource "aws_apigatewayv2_route" "agent_card_route" {
  api_id    = aws_apigatewayv2_api.a2a_agent_gateway.id
  route_key = "GET /.well-known/agent.json"
  target    = "integrations/${aws_apigatewayv2_integration.lambda_a2a.id}"
}

resource "aws_apigatewayv2_route" "task_execution_route" {
  api_id             = aws_apigatewayv2_api.a2a_agent_gateway.id
  route_key          = "POST /a2a/tasks"
  authorization_type = "JWT"
  authorizer_id      = aws_apigatewayv2_authorizer.entra_id_federation.id
  target             = "integrations/${aws_apigatewayv2_integration.lambda_a2a.id}"
}

# Provisionamento Simétrico na Microsoft Azure
resource "azurerm_api_management" "azure_auditor_gateway" {
  name                = "apim-azure-compliance-agent"
  location            = azurerm_resource_group.a2a_multicloud.location
  resource_group_name = azurerm_resource_group.a2a_multicloud.name
  publisher_name      = "Enterprise Architecture"
  publisher_email     = "architecture@enterprise.internal"
  sku_name            = "Developer_1"
}

Enter fullscreen mode Exit fullscreen mode
sequenceDiagram
    autonumber
    participant AWS_Agent as Agente Orquestrador (AWS)
    participant AZ_APIM as Azure API Management
    participant AZ_Agent as Agente Auditor (Azure)
    participant AZ_Queue as Azure Service Bus

    AWS_Agent->>AZ_APIM: GET /.well-known/agent.json
    AZ_APIM-->>AWS_Agent: Retorna Agent Card (Capacidades & Esquemas)
    AWS_Agent->>AZ_APIM: POST /a2a/tasks (JSON-RPC 2.0 + JWT OIDC)
    AZ_APIM->>AZ_Agent: Encaminha Tarefa Validada
    AZ_Agent->>AZ_Queue: Enfileira Processamento Cognitivo Longo
    AZ_Agent-->>AWS_Agent: HTTP 202 Accepted (TaskID + Status: WORKING)
    Note over AWS_Agent,AZ_Agent: Streaming SSE ou Webhook para Conclusão
    AZ_Agent-->>AWS_Agent: Notifica Artefato Finalizado (Status: COMPLETED)

Uma vez que o gateway de borda está exposto e protegido, como estruturamos a camada de aplicação do agente na Azure para publicar seu manifesto de capacidades e negociar tarefas complexas mantendo o núcleo cognitivo completamente isolado do protocolo de rede?

Encapsulando o Núcleo Cognitivo com Arquitetura Hexagonal

Protegemos a lógica de raciocínio e validação do agente contra mudanças nos protocolos de transporte aplicando rigorosamente a Arquitetura Hexagonal em Python. O núcleo do agente (domínio) contém apenas as regras de auditoria, prompts estruturados e validações de invariantes de negócio, ignorando completamente a existência do FastAPI, JSON-RPC ou SDKs da Azure e AWS. A camada externa atua como um adaptador primário que traduz as requisições HTTP padronizadas pelo protocolo A2A em objetos de transferência de dados imutáveis. Quando o agente orquestrador da AWS solicita o manifesto em /.well-known/agent.json, o adaptador serializa o contrato de habilidades do domínio. Quando uma tarefa é submetida via JSON-RPC 2.0 para /a2a/tasks, o adaptador valida a estrutura da mensagem, instancia o ciclo de vida da tarefa com um identificador único e delega a execução ao serviço de domínio, garantindo testabilidade unitária determinística sem depender de chamadas reais a modelos fundacionais durante os testes de integração.

from abc import ABC, abstractmethod
from dataclasses import dataclass
from typing import Dict, Any, List
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

# Núcleo de Domínio (Agnóstico de Infraestrutura e Protocolo)
@dataclass(frozen=True)
class AuditTaskInput:
    task_id: str
    transaction_ledger: List[Dict[str, Any]]
    regulatory_framework: str

class ComplianceAuditorPort(ABC):
    @abstractmethod
    async def evaluate_compliance(self, task_input: AuditTaskInput) -> Dict[str, Any]:
        pass

class CoreComplianceAgentService(ComplianceAuditorPort):
    async def evaluate_compliance(self, task_input: AuditTaskInput) -> Dict[str, Any]:
        if not task_input.transaction_ledger:
            raise ValueError("O livro-razão de transações não pode estar vazio.")

        flagged_items = [
            tx for tx in task_input.transaction_ledger 
            if float(tx.get("amount", 0)) > 50000.00 and not tx.get("tax_clearance_id")
        ]

        return {
            "task_id": task_input.task_id,
            "framework": task_input.regulatory_framework,
            "compliant": len(flagged_items) == 0,
            "anomalies_detected": len(flagged_items),
            "details": flagged_items
        }

# Adaptador Primário A2A (Camada de Transporte FastAPI)
class JsonRpcTaskRequest(BaseModel):
    jsonrpc: str = "2.0"
    id: str
    method: str
    params: Dict[str, Any]

app = FastAPI(title="Azure Compliance Agent A2A")
domain_service = CoreComplianceAgentService()

@app.get("/.well-known/agent.json")
async def get_agent_card() -> Dict[str, Any]:
    return {
        "name": "AzureRegulatoryAuditor",
        "version": "1.2.0",
        "protocolVersion": "a2a-v1",
        "capabilities": {
            "streaming": True,
            "pushNotifications": True
        },
        "skills": [
            {
                "id": "cross-border-tax-audit",
                "description": "Valida conformidade fiscal de lotes financeiros multicloud",
                "inputModes": ["application/json"],
                "outputModes": ["application/json"]
            }
        ]
    }

@app.post("/a2a/tasks")
async def handle_a2a_task(rpc_request: JsonRpcTaskRequest) -> Dict[str, Any]:
    if rpc_request.method != "tasks/send":
        raise HTTPException(status_code=400, detail="Método JSON-RPC não suportado.")

    try:
        payload = rpc_request.params.get("message", {}).get("parts", [{}])[0].get("data", {})
        task_input = AuditTaskInput(
            task_id=rpc_request.params["id"],
            transaction_ledger=payload.get("ledger", []),
            regulatory_framework=payload.get("framework", "BACEN-4893")
        )

        artifact_result = await domain_service.evaluate_compliance(task_input)

        return {
            "jsonrpc": "2.0",
            "id": rpc_request.id,
            "result": {
                "id": task_input.task_id,
                "status": {"state": "completed"},
                "artifacts": [{"parts": [{"type": "data", "data": artifact_result}]}]
            }
        }
    except ValueError as err:
        raise HTTPException(status_code=422, detail=str(err))

Enter fullscreen mode Exit fullscreen mode

Como o agente orquestrador hospedado na AWS gerencia falhas parciais, timeouts de raciocínio e prevenção de loops infinitos quando múltiplos agentes colaboram de forma encadeada através das nuvens?

Gerenciando Delegação Assíncrona e Governança de Profundidade na AWS

Controlamos a estabilidade da malha cognitiva implementando um cliente orquestrador na AWS que impõe limites rígidos de profundidade de delegação (Hop Count) e rastreamento de estado baseado em eventos. Tarefas executadas por agentes autônomos frequentemente envolvem múltiplas etapas de inferência e consultas a bases vetoriais, podendo levar dezenas de segundos para concluir. Manter conexões HTTP síncronas abertas entre a AWS e a Azure durante esse período esgota os pools de conexão e provoca timeouts em cascata nos gateways. O adaptador de saída na AWS utiliza o protocolo A2A em modo assíncrono, enviando a tarefa com um cabeçalho de controle de linhagem (X-A2A-Delegation-Depth) e um token OIDC federado. Se a profundidade ultrapassar o limite arquitetural estipulado, o cliente aborta a delegação imediatamente, bloqueando ciclos infinitos onde dois agentes ficam solicitando revisões mútuas indefinidamente.

import uuid
import httpx
from typing import Dict, Any

MAX_DELEGATION_DEPTH = 3

class AwsOrchestratorA2AClient:
    def __init__(self, target_agent_url: str, oidc_token: str):
        self.target_agent_url = target_agent_url.rstrip("/")
        self.oidc_token = oidc_token

    async def discover_capabilities(self) -> Dict[str, Any]:
        async with httpx.AsyncClient(timeout=5.0) as client:
            response = await client.get(f"{self.target_agent_url}/.well-known/agent.json")
            response.raise_for_status()
            return response.json()

    async def delegate_audit_task(
        self, 
        ledger: list, 
        current_depth: int = 0
    ) -> Dict[str, Any]:
        if current_depth >= MAX_DELEGATION_DEPTH:
            raise RuntimeError(
                f"Limite de profundidade de delegação A2A excedido ({MAX_DELEGATION_DEPTH}). "
                "Loop cognitivo bloqueado preventivamente."
            )

        agent_card = await self.discover_capabilities()
        supported_skills = [skill["id"] for skill in agent_card.get("skills", [])]
        if "cross-border-tax-audit" not in supported_skills:
            raise ValueError("O agente remoto na Azure não possui a habilidade requerida.")

        task_id = f"task_{uuid.uuid4().hex}"
        rpc_payload = {
            "jsonrpc": "2.0",
            "id": str(uuid.uuid4()),
            "method": "tasks/send",
            "params": {
                "id": task_id,
                "message": {
                    "role": "user",
                    "parts": [
                        {
                            "type": "data",
                            "data": {
                                "ledger": ledger,
                                "framework": "SOX-2026"
                            }
                        }
                    ]
                }
            }
        }

        headers = {
            "Authorization": f"Bearer {self.oidc_token}",
            "Content-Type": "application/json",
            "X-A2A-Delegation-Depth": str(current_depth + 1)
        }

        async with httpx.AsyncClient(timeout=30.0) as client:
            response = await client.post(
                f"{self.target_agent_url}/a2a/tasks",
                json=rpc_payload,
                headers=headers
            )
            response.raise_for_status()
            return response.json()

Enter fullscreen mode Exit fullscreen mode

Qual estratégia de auditoria garante a rastreabilidade imutável das decisões tomadas por cada agente autônomo quando um regulador exige a reconstrução exata de uma transação aprovada de forma colaborativa entre a AWS e a Azure?

Solução de Problemas Comuns

A implantação de protocolos Agent-to-Agent entre provedores distintos enfrenta frequentemente falhas de negociação de identidade na borda do API Gateway. Se o agente na AWS receber erros HTTP 401 Unauthorized com a mensagem IDX10214: Audience validation failed vinda do Azure API Management, o token JWT emitido pelo provedor OIDC da AWS possui uma reivindicação de audiência (aud) incompatível com o ID do aplicativo registrado no Microsoft Entra ID. Para solucionar esse conflito, configure o autorizador JWT no Azure API Management para validar explicitamente o URI de identificação da federação da AWS e assegure que o emissor (iss) corresponda exatamente ao endpoint OIDC do cluster EKS ou da função Lambda originária.

Outro problema operacional recorrente manifesta-se como HTTP 504 Gateway Timeout durante a execução de tarefas cognitivas complexas. Como o raciocínio de agentes baseados em LLMs possui latência altamente variável, respostas síncronas frequentemente ultrapassam o limite rígido de 29 segundos do Amazon API Gateway. A mitigação definitiva exige a ativação do modo assíncrono previsto na especificação A2A. O agente receptor na Azure deve responder imediatamente com o estado working e um identificador de tarefa, processando o raciocínio em segundo plano via Azure Service Bus e notificando o agente da AWS através de um webhook de retorno ou via Server-Sent Events (SSE) assim que os artefatos forem consolidados.

Conclusão

A adoção do protocolo Agent-to-Agent aliado à Arquitetura Hexagonal transforma agentes isolados em uma malha cognitiva interoperável, resiliente e auditável através da AWS e da Azure. Ao padronizar a descoberta de capacidades via Agent Cards, impor limites rigorosos de profundidade de delegação e isolar o raciocínio de domínio dos adaptadores de rede, as organizações eliminam o acoplamento proprietário e mitigam riscos sistêmicos de alucinação em cascata. Como próximo passo na evolução desta arquitetura, recomenda-se integrar o Model Context Protocol (MCP) dentro de cada agente individual para padronizar o acesso local a ferramentas e bancos de dados, consolidando uma separação clara entre a comunicação vertical (agente-ferramenta via MCP) e a colaboração horizontal (agente-agente via A2A).

Referências

Google Cloud. (2025). Agent2Agent (A2A) protocol specification: Open interoperability for multi-agent ecosystems. Google Open Source Documentation.

Wooldridge, M. (2009). An introduction to multiagent systems (2nd ed.). John Wiley & Sons.

Top comments (0)