DEV Community

Cláudio Filipe Lima Rapôso
Cláudio Filipe Lima Rapôso

Posted on

Malha Agent-to-Agent na Azure (Parte 1): Fundações do Concierge A2A + MCP com Azure Container Apps, Key Vault e Managed Redis

O Azure Container Apps resolve boa parte do que dói em levar microsserviços para a nuvem: não há cluster para administrar, o ingress é gerenciado e cada app recebe um nome resolvível dentro do ambiente. Para um ecossistema multiagente, porém, essas facilidades vêm com regras próprias que quebram o que funcionava no docker-compose. Os apps se chamam pela porta 80 do ingress, não pela porta do processo, então http://flight-agent:8011 deixa de funcionar. O proxy do ingress também tem limites de tempo que um stream SSE de minutos ultrapassa, e segredos como a URL do Redis e a chave do modelo não devem morar em variáveis de ambiente em texto claro. Nesta série levamos o Concierge de Viagens para a Azure. É o mesmo sistema da série AWS: um orquestrador A2A em JSON-RPC 2.0, agentes especialistas e servidores MCP para voos, hotéis e políticas corporativas. Nesta primeira parte montamos a fundação: ambiente do Container Apps com a malha fechada por ingress interno, Azure Container Registry, Key Vault com RBAC, identidade gerenciada e Azure Managed Redis com TLS.

Pré-requisitos

Terraform 1.7.0 ou superior, provider hashicorp/azurerm 4.40+ (validado com 4.81), Azure CLI autenticada (az login) em uma assinatura com permissão de Owner ou de Contributor e User Access Administrator, porque criamos atribuições de papel. Docker com Buildx e o repositório do projeto clonado. O código completo está em infra/azure/ e passou em terraform validate; os trechos abaixo são recortes desses arquivos. Usamos eastus2 como região padrão porque a Parte 2 depende de modelos do Microsoft Foundry disponíveis nela.

Passo a Passo

A arquitetura no Container Apps

O que muda em relação ao compose? O LLM local dá lugar ao Microsoft Foundry (Parte 2), as aprovações vão para Durable Functions (Parte 3) e todo o resto é a mesma imagem com os mesmos comandos. A diferença estrutural é que só o frontend tem ingress externo; os demais apps têm ingress interno e só são alcançáveis de dentro do ambiente.

flowchart LR
    U[Usuário] -->|HTTPS| FE[frontend<br/>ingress externo]
    subgraph CAE["Container Apps Environment (ingress interno)"]
        FE -->|http://orchestrator| OR[orchestrator]
        OR -->|http://flight-agent| FA[flight-agent]
        OR -->|http://hotel-agent| HA[hotel-agent]
        OR -->|http://policy-agent| PA[policy-agent]
        FA -->|http://flights-mcp/sse| FM[flights-mcp]
        HA -->|http://hotels-mcp/sse| HM[hotels-mcp]
        PA -->|http://policies-mcp/sse| PM[policies-mcp]
    end
    ID[Identidade gerenciada] -.->|AcrPull| ACR[(Container Registry)]
    ID -.->|Secrets User| KV[(Key Vault)]
    OR --> R[(Azure Managed Redis<br/>TLS :10000)]
    FM --> R
    PM -->|Parte 2| AIF[Microsoft Foundry]
    OR -->|Parte 3| FN[Durable Functions]

Identidade, registro e segredos

Como evitar senhas de registro e connection strings espalhadas pelos apps? Com uma identidade gerenciada atribuída pelo usuário, compartilhada pelos apps, que recebe dois papéis: AcrPull no registro e Key Vault Secrets User no cofre. O registro roda com admin_enabled = false, então não existe usuário e senha para vazar, e o Key Vault usa autorização por RBAC em vez de access policies.

resource "azurerm_user_assigned_identity" "apps" {
  name                = "id-${var.name}-apps"
  location            = azurerm_resource_group.main.location
  resource_group_name = azurerm_resource_group.main.name
}

resource "azurerm_container_registry" "main" {
  name                = "cr${var.name}${local.suffix}"
  resource_group_name = azurerm_resource_group.main.name
  location            = azurerm_resource_group.main.location
  sku                 = "Standard"
  admin_enabled       = false
}

resource "azurerm_role_assignment" "acr_pull" {
  scope                = azurerm_container_registry.main.id
  role_definition_name = "AcrPull"
  principal_id         = azurerm_user_assigned_identity.apps.principal_id
}

resource "azurerm_key_vault" "main" {
  name                       = "kv-${var.name}-${local.suffix}"
  location                   = azurerm_resource_group.main.location
  resource_group_name        = azurerm_resource_group.main.name
  tenant_id                  = data.azurerm_client_config.current.tenant_id
  sku_name                   = "standard"
  rbac_authorization_enabled = true
  purge_protection_enabled   = var.environment == "prod"
}

resource "azurerm_role_assignment" "kv_reader_apps" {
  scope                = azurerm_key_vault.main.id
  role_definition_name = "Key Vault Secrets User"
  principal_id         = azurerm_user_assigned_identity.apps.principal_id
}
Enter fullscreen mode Exit fullscreen mode

Redis gerenciado com TLS

O Azure Cache for Redis está em processo de aposentadoria, e o caminho atual é o Azure Managed Redis. Duas diferenças importam para a aplicação. A porta é 10000, não 6380, e o protocolo Encrypted exige TLS, ou seja, o esquema rediss:// no cliente. Montamos a URL completa e gravamos no Key Vault; nenhum app vê a chave em variável de ambiente.

resource "azurerm_managed_redis" "main" {
  name                = "redis-${var.name}-${local.suffix}"
  resource_group_name = azurerm_resource_group.main.name
  location            = azurerm_resource_group.main.location
  sku_name            = "Balanced_B0"

  default_database {
    access_keys_authentication_enabled = true
    client_protocol                    = "Encrypted"
  }
}

resource "azurerm_key_vault_secret" "redis_url" {
  name         = "redis-url"
  key_vault_id = azurerm_key_vault.main.id
  value        = "rediss://:${azurerm_managed_redis.main.default_database[0].primary_access_key}@${azurerm_managed_redis.main.hostname}:10000/0"
}
Enter fullscreen mode Exit fullscreen mode

Ingress interno e nomes sem porta

Como os agentes se encontram dentro do ambiente? No Container Apps, um app com ingress habilitado é alcançado por http://<nome-do-app>, e o ingress encaminha da porta 80 para a target_port do container. Por isso as URLs perdem a porta em relação ao compose (http://flights-mcp/sse em vez de http://flights-mcp:8001/sse). Como o código lê tudo de variáveis de ambiente e os AgentCards publicam o AGENT_PUBLIC_URL, a mudança fica inteira no Terraform. Os segredos entram como Key Vault references: o app declara o segredo pelo ID versionless e o lê com a identidade gerenciada, então rotacionar a chave no cofre não exige redeploy.

locals {
  services = {
    "flight-agent" = {
      port = 8011, cpu = 0.25, memory = "0.5Gi"
      command = ["uvicorn", "agents.flight_agent:app", "--host", "0.0.0.0", "--port", "8011"]
      env     = { FLIGHTS_MCP_SSE_URL = "http://flights-mcp/sse", AGENT_PUBLIC_URL = "http://flight-agent/a2a" }
      secrets = {}
    }
    "orchestrator" = {
      port = 8000, cpu = 0.5, memory = "1Gi"
      command = ["uvicorn", "orchestrator.gateway:app", "--host", "0.0.0.0", "--port", "8000"]
      env = {
        FLIGHT_AGENT_URL = "http://flight-agent"
        HOTEL_AGENT_URL  = "http://hotel-agent"
        POLICY_AGENT_URL = "http://policy-agent"
        POLICY_TIMEOUT   = "660"
      }
      secrets = { REDIS_URL = "redis-url" }
    }
    # ... flights-mcp, hotels-mcp, policies-mcp, hotel-agent, policy-agent
  }
}

resource "azurerm_container_app" "svc" {
  for_each                     = local.services
  name                         = each.key
  container_app_environment_id = azurerm_container_app_environment.main.id
  resource_group_name          = azurerm_resource_group.main.name
  revision_mode                = "Single"
  workload_profile_name        = "Consumption"

  identity {
    type         = "UserAssigned"
    identity_ids = [azurerm_user_assigned_identity.apps.id]
  }
  registry {
    server   = azurerm_container_registry.main.login_server
    identity = azurerm_user_assigned_identity.apps.id
  }

  dynamic "secret" {
    for_each = toset(values(each.value.secrets))
    content {
      name                = secret.value
      key_vault_secret_id = local.kv_secrets[secret.value]
      identity            = azurerm_user_assigned_identity.apps.id
    }
  }

  ingress {
    external_enabled = false
    target_port      = each.value.port
    transport        = "http"
    traffic_weight {
      latest_revision = true
      percentage      = 100
    }
  }

  template {
    min_replicas = 1 # MCP via SSE mantém conexões abertas; escalar a zero derrubaria sessões em curso
    max_replicas = 3
    container {
      name    = each.key
      image   = local.app_image
      cpu     = each.value.cpu
      memory  = each.value.memory
      command = each.value.command
      dynamic "env" {
        for_each = each.value.env
        content {
          name  = env.key
          value = env.value
        }
      }
      dynamic "env" {
        for_each = each.value.secrets
        content {
          name        = env.key
          secret_name = env.value
        }
      }
      liveness_probe {
        transport = "TCP"
        port      = each.value.port
      }
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

O min_replicas = 1 é uma escolha contra a economia do scale to zero. As sessões MCP sobre SSE são conexões longas entre agente e servidor, e uma réplica derrubada por inatividade no meio de uma análise de política gera um erro difícil de reproduzir. Em ambientes de demonstração dá para aceitar o risco; em produção, não.

O frontend e o proxy configurável

O nginx do frontend fazia proxy_pass http://orchestrator:8000/, um endereço que não existe no Container Apps. Em vez de manter duas imagens, transformamos o arquivo em template. A imagem oficial do nginx aplica envsubst aos arquivos de /etc/nginx/templates ao iniciar e substitui apenas as variáveis definidas, preservando $host e as demais variáveis do próprio nginx.

FROM nginx:1.27-alpine AS runner
ENV ORCHESTRATOR_UPSTREAM=http://orchestrator:8000
# a imagem oficial do nginx aplica envsubst nos templates ao iniciar
COPY nginx.conf /etc/nginx/templates/default.conf.template
COPY --from=builder /app/dist /usr/share/nginx/html
Enter fullscreen mode Exit fullscreen mode
location /api/ {
    # ORCHESTRATOR_UPSTREAM: http://orchestrator:8000 (compose/ECS) ou http://orchestrator (Container Apps)
    proxy_pass ${ORCHESTRATOR_UPSTREAM}/;
    proxy_http_version 1.1;
    proxy_buffering off;          # SSE: repassa cada evento sem acumular
    proxy_read_timeout 720s;
}
Enter fullscreen mode Exit fullscreen mode

No Terraform, o app do frontend recebe ORCHESTRATOR_UPSTREAM = "http://orchestrator" e é o único com external_enabled = true. O fluxo de uma cotação fica assim:

sequenceDiagram
    participant B as Navegador
    participant FE as frontend (nginx)
    participant IG as Ingress do ambiente
    participant OR as orchestrator
    participant FA as flight-agent
    participant FM as flights-mcp
    B->>FE: POST /api/chat/quote/stream
    FE->>IG: http://orchestrator/chat/quote/stream
    IG->>OR: :8000
    OR->>FA: GET http://flight-agent/.well-known/agent-card.json
    OR->>FA: JSON-RPC message/send
    FA->>FM: MCP via http://flights-mcp/sse
    FM-->>FA: ofertas (TTL no Managed Redis)
    FA-->>OR: artifacts
    OR-->>B: SSE data: step... + ": keepalive" a cada 15s

Publicando e subindo

cd infra/azure
terraform init
terraform apply -target=azurerm_container_registry.main -target=azurerm_resource_group.main

ACR=$(terraform output -raw acr_login_server)
TAG=$(git rev-parse --short HEAD)
az acr login --name "${ACR%%.*}"
docker buildx build --platform linux/amd64 -t "$ACR/travel-app:$TAG" --push ../..
docker buildx build --platform linux/amd64 -t "$ACR/travel-frontend:$TAG" --push ../../frontend

terraform apply -var image_tag="$TAG"
Enter fullscreen mode Exit fullscreen mode

Validando a fundação

A primeira verificação é o estado das revisões: todos os apps precisam estar com a revisão ativa saudável e uma réplica em execução.

RG=$(terraform output -raw resource_group)
az containerapp list -g "$RG" --query "[].{app:name, fqdn:properties.configuration.ingress.fqdn, estado:properties.runningStatus}" -o table
az containerapp replica list -g "$RG" -n orchestrator --query "[].{replica:name, estado:properties.runningState}" -o table
Enter fullscreen mode Exit fullscreen mode

A malha se valida de dentro: o az containerapp exec abre um shell no orquestrador, de onde o /health só lista os três agentes se os nomes internos resolverem e os AgentCards responderem.

az containerapp exec -g "$RG" -n orchestrator --command "curl -s http://localhost:8000/health"
Enter fullscreen mode Exit fullscreen mode

A resposta deve ser a mesma do ambiente local, com FlightBookingAgent, HotelBookingAgent e TravelPolicyAgent em discovered_agents. Se a lista vier vazia, verifique se o app do agente tem ingress habilitado: sem ingress, o nome não resolve dentro do ambiente.

Pela interface, o app_url do output abre o Concierge. O badge "Online" confirma o caminho navegador, frontend, ingress e orquestrador; a aba Serviços mostra agentes e skills descobertos.

Tela inicial do Concierge com o status Online

Aba Serviços listando os agentes A2A descobertos e suas skills

Uma cotação exercita a malha inteira. No grafo, cada salto acende quando acontece; o painel de trace mostra a latência de cada chamada A2A e MCP.

Grafo multiagente com o trace completo da cotação

As capturas foram feitas no ambiente local (Docker), com as mesmas imagens publicadas no ACR; no Container Apps muda apenas o endereço.

Solução de Problemas Comuns

httpx.ConnectError do orquestrador para http://flight-agent:8011 significa que ficou uma URL com porta herdada do compose. No Container Apps, o tráfego entre apps passa pelo ingress na porta 80, e a porta do processo não é exposta. Remova a porta das variáveis *_URL e *_SSE_URL e confirme que o AGENT_PUBLIC_URL publicado no AgentCard segue o mesmo padrão.

Revisão presa em Activating com secret ... could not be retrieved indica que a identidade gerenciada ainda não tinha o papel Key Vault Secrets User quando o app foi criado, porque a atribuição de papel leva alguns minutos para propagar. O depends_on nas atribuições reduz o problema, mas não elimina a propagação. Um novo terraform apply ou az containerapp revision restart resolve depois que o papel aparecer em az role assignment list --assignee <principal_id>.

Conclusão

Com ingress interno, identidade gerenciada, Key Vault references e Managed Redis com TLS, a malha A2A + MCP roda no Container Apps sem senhas em variáveis e sem expor nenhum agente à internet. O preço da portabilidade foi pequeno: URLs sem porta e um nginx configurável por variável. Na Parte 2 o agente de políticas ganha um modelo de verdade: o Claude no Microsoft Foundry para extrair limites das políticas e um deployment de embeddings no mesmo recurso, sem mudar uma linha do agente.

Referências

Microsoft. (2025). Ingress in Azure Container Apps. Microsoft Learn.

Microsoft. (2025). Manage secrets in Azure Container Apps (Key Vault references). Microsoft Learn.

Google. (2025). Agent2Agent (A2A) Protocol Specification. a2a-protocol.org.

Top comments (0)