Se você já passou madrugadas reiniciando pods, tentando entender por que o Ingress resolveu parar do nada, ou caçando logs em namespaces esquecidos… Você vai adorar conhecer os Azure Container Apps.

TL;DR

• Azure Container Apps é ideal para quem quer simplicidade, escalabilidade automática e não precisa de controle total da infraestrutura.
• AKS (Kubernetes) é indicado para cenários que exigem customização avançada, workloads stateful ou integração profunda com recursos do cluster.
• Se você quer começar rápido, sem se preocupar com detalhes do cluster, vá de Container Apps.
• Se precisa de controle fino, prepare-se para lidar com a complexidade do AKS.

Ir direto para os pré-requisitos

Introdução

O Azure Container Apps (ACA) é um serviço serverless para containers gerenciado pela Microsoft Azure, ideal para executar aplicações micross erviços, APIs, workers e event-driven apps sem precisar gerenciar servidores, clusters Kubernetes ou infraestrutura de rede complexa.

Ele é construído sobre o Azure Kubernetes Service (AKS), mas abstrai completamente o gerenciamento do cluster. Isso significa que você pode se concentrar apenas na aplicação, não na orquestração.

---

Devo usar Azure Container Apps?

Essa é uma pergunta muito boa que envolve um entendimento do sistema como um todo. Não existe um passo-a-passo definido, mas existem sim algumas perguntas que devem ser respondidas:

• Qual o orçamento do projeto?
• Quantas aplicações existem no sistema?
• Quantas pessoas existem para operacionar o sistema?
• O quanto se exige de flexibilidade
• O quanto se deseja abstrair ou controlar diretamente os recursos de execução?
• O que tem pronto em hoje?

Bem, sendo honesto, azure container apps vai ser o melhor para a maioria dos workloads, pois além de possuir o Plano de Consumo onde os primeiros 180.000 vCPU-seconds, 360.000 GiB-seconds e 2 milhões de solicitações por mês são gratuitos (o que já é ótimo para MVPs e POCs) você praticamente não precisa de nenhum especialista em K8S para gerenciar um Cluster propriamente dito.

Agora, caso você esteja lidando com requisitos como: controle total da infraestrutura, aplicações stateful, integrações com CRDs e você tenha também um time dedicado em K8S, talvez faça sentido você se aventurar no Azure Kubernetes Service (AKS).

Pré-requisitos

• Azure CLI instalada e atualizada.
• Uma conta no Azure.
• Docker (para build local, opcional).
• (Opcional) VS Code com extensão Bicep ou Terraform.

---

Criando um Container App com Azure CLI

1. Criar um Resource Group

az group create   --name rg-containerapps-demo   --location eastus

2. Habilitar o serviço Container Apps

az provider register --namespace Microsoft.App
az provider register --namespace Microsoft.OperationalInsights

3. Criar o ambiente do Container App

az containerapp env create   --name demo-env   --resource-group rg-containerapps-demo   --location eastus   --logs-workspace-name demo-logs   --logs-workspace-retention 30

4. Criar o Container App

az containerapp create   --name myapp   --resource-group rg-containerapps-demo   --environment demo-env   --image mcr.microsoft.com/azuredocs/containerapps-helloworld:latest   --target-port 80   --ingress 'external'   --cpu 0.5 --memory 1.0Gi

5. Testar

az containerapp show   --name myapp   --resource-group rg-containerapps-demo   --query properties.configuration.ingress.fqdn   --output tsv

Acesse a URL retornada e veja o app rodando.

---

Deploy com Bicep

---

Abaixo está um exemplo simples de arquivo Bicep que cria um Azure Container App dentro de um Environment já existente:

Arquivo main.bicep

param location string = resourceGroup().location
param environmentName string = 'demo-env'
param containerAppName string = 'myapp'
param image string = 'mcr.microsoft.com/azuredocs/containerapps-helloworld:latest'

resource logWorkspace 'Microsoft.OperationalInsights/workspaces@2021-06-01' = {
  name: 'demo-logs'
  location: location
  properties: {}
}

resource env 'Microsoft.App/managedEnvironments@2023-05-01' = {
  name: environmentName
  location: location
  properties: {
    appLogsConfiguration: {
      destination: 'log-analytics'
      logAnalyticsConfiguration: {
        customerId: logWorkspace.properties.customerId
        sharedKey: listKeys(logWorkspace.id, logWorkspace.apiVersion).primarySharedKey
      }
    }
  }
}

resource containerApp 'Microsoft.App/containerApps@2023-05-01' = {
  name: containerAppName
  location: location
  properties: {
    environmentId: env.id
    configuration: {
      ingress: {
        external: true
        targetPort: 80
      }
    }
    template: {
      containers: [
        {
          name: 'app'
          image: image
          resources: {
            cpu: 0.5
            memory: '1.0Gi'
          }
        }
      ]
    }
  }
}

Deploy

az deployment group create   --resource-group rg-containerapps-demo   --template-file main.bicep

---

Deploy com Terraform

Arquivo main.tf

provider "azurerm" {
  features {}
}

resource "azurerm_resource_group" "rg" {
  name     = "rg-containerapps-demo"
  location = "eastus"
}

resource "azurerm_log_analytics_workspace" "logs" {
  name                = "demo-logs"
  location            = azurerm_resource_group.rg.location
  resource_group_name = azurerm_resource_group.rg.name
  sku                 = "PerGB2018"
  retention_in_days   = 30
}

resource "azurerm_container_app_environment" "env" {
  name                       = "demo-env"
  location                   = azurerm_resource_group.rg.location
  resource_group_name         = azurerm_resource_group.rg.name
  log_analytics_workspace_id  = azurerm_log_analytics_workspace.logs.id
}

resource "azurerm_container_app" "app" {
  name                         = "myapp"
  resource_group_name           = azurerm_resource_group.rg.name
  container_app_environment_id  = azurerm_container_app_environment.env.id
  revision_mode                 = "Single"

  template {
    container {
      name   = "app"
      image  = "mcr.microsoft.com/azuredocs/containerapps-helloworld:latest"
      cpu    = 0.5
      memory = "1Gi"
    }
  }

  ingress {
    external_enabled = true
    target_port      = 80
  }
}

Deploy

terraform init
terraform apply -auto-approve

---

Deploy com ARM Template

Arquivo containerapp.json

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "resources": [
    {
      "type": "Microsoft.OperationalInsights/workspaces",
      "apiVersion": "2021-06-01",
      "name": "demo-logs",
      "location": "[resourceGroup().location]",
      "properties": {}
    },
    {
      "type": "Microsoft.App/managedEnvironments",
      "apiVersion": "2023-05-01",
      "name": "demo-env",
      "location": "[resourceGroup().location]",
      "properties": {
        "appLogsConfiguration": {
          "destination": "log-analytics",
          "logAnalyticsConfiguration": {
            "customerId": "[reference(resourceId('Microsoft.OperationalInsights/workspaces', 'demo-logs'), '2021-06-01').customerId]",
            "sharedKey": "[listKeys(resourceId('Microsoft.OperationalInsights/workspaces', 'demo-logs'), '2021-06-01').primarySharedKey]"
          }
        }
      }
    },
    {
      "type": "Microsoft.App/containerApps",
      "apiVersion": "2023-05-01",
      "name": "myapp",
      "location": "[resourceGroup().location]",
      "properties": {
        "environmentId": "[resourceId('Microsoft.App/managedEnvironments', 'demo-env')]",
        "configuration": {
          "ingress": {
            "external": true,
            "targetPort": 80
          }
        },
        "template": {
          "containers": [
            {
              "name": "app",
              "image": "mcr.microsoft.com/azuredocs/containerapps-helloworld:latest",
              "resources": {
                "cpu": 0.5,
                "memory": "1.0Gi"
              }
            }
          ]
        }
      }
    }
  ]
}

Deploy via Azure CLI

az deployment group create   --resource-group rg-containerapps-demo   --template-file containerapp.json

---

Deployment de Aplicação & Revisões

Exemplo 1: Deploy Rápido com Imagem Pública

Vamos fazer um deploy rápido usando uma imagem NGINX pública, considerando que você já criou o Resource Group e o Environment:

# Criar o Container App com NGINX
az containerapp create \
  --name nginx-demo \
  --resource-group rg-aca-demo \
  --environment aca-env-demo \
  --image nginx:latest \
  --target-port 80 \
  --ingress external

✅ Acesse a URL exibida pelo comando az containerapp show e veja seu NGINX rodando em poucos segundos.

---

Exemplo 2: Deploy de Código Próprio com Dockerfile

Se você quer rodar sua própria aplicação, aqui vai um exemplo com Flask, considerando que o Resource Group e o Environment já existem.

Estrutura do Projeto

/myapp
 ├── app.py
 └── Dockerfile

app.py

from flask import Flask
app = Flask(__name__)

@app.route('/')
def home():
    return "Olá, Azure Container Apps!"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=80)

Dockerfile

FROM python:3.11-slim
WORKDIR /app
COPY . .
RUN pip install flask
CMD ["python", "app.py"]

Build e Push da Imagem

docker build -t meuusuario/helloaca:latest .
docker push meuusuario/helloaca:latest

Deploy no Container Apps

az containerapp create \
  --name helloaca \
  --resource-group rg-aca-demo \
  --environment aca-env-demo \
  --image meuusuario/helloaca:latest \
  --target-port 80 \
  --ingress external

Acesse o endpoint retornado e veja sua aplicação rodando.

---

Revisões e Controle de Tráfego

Cada novo deploy gera uma nova revisão. Você pode gerenciar revisões e dividir tráfego entre elas:

# Listar revisões
az containerapp revision list \
  --name helloaca \
  --resource-group rg-aca-demo \
  --output table

# Ativar múltiplas revisões
az containerapp update \
  --name helloaca \
  --resource-group rg-aca-demo \
  --revisions-mode multiple

# Dividir tráfego entre revisões
az containerapp ingress traffic set \
  --name helloaca \
  --resource-group rg-aca-demo \
  --revision-weight <revision1>=80 <revision2>=20

Isso permite testes graduais e blue-green deployments sem downtime.

---

Deploy Automático do Código

Com az containerapp up, você pode automatizar build, push e deploy direto no ACA:

az containerapp up \
  --name helloaca-up \
  --resource-group rg-aca-demo \
  --location eastus \
  --environment aca-env-demo \
  --ingress external

Perfeito para desenvolvedores que querem deploy rápido sem se preocupar com infraestrutura.

---

Boas Práticas

• Usar Environments por VNET para isolar aplicações sensíveis.
• Configurar variáveis de ambiente via --env-vars no CLI ou secrets no Bicep/Terraform.
• Habilitar o Application Insights para observabilidade.
• Implementar Blue-Green Deployment com revisões e traffic-split.

---

Conclusão

O Azure Container Apps oferece um modelo poderoso, escalável e simplificado para rodar containers em produção, sem precisar lidar com a complexidade do Kubernetes.

Com suporte a Bicep, Terraform, ARM e Azure CLI, você pode escolher a abordagem IaC que melhor se encaixa no seu fluxo de DevOps.

---

Referências

• Documentação oficial - Azure Container Apps
• Exemplos de Bicep - Azure Samples
• Terraform Provider AzureRM