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 } 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" } 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 } } } } 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 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; } 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" 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 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" 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.
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.
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.




