DEV Community

Cover image for Bicep: A Linguagem Moderna de IaC para Azure
Luis Cruz
Luis Cruz

Posted on

Bicep: A Linguagem Moderna de IaC para Azure

#devops #azure #bicep #iac

Se você já trabalhou com ARM Templates na Azure, sabe bem o quanto pode ser frustrante: arquivos JSON verbosos, difíceis de ler e ainda mais difíceis de manter. O Bicep chegou para resolver exatamente isso, uma linguagem de domínio específico (DSL) criada pela Microsoft para declarar infraestrutura no Azure de forma limpa, simples e poderosa.

O que é o Bicep?

Bicep é uma linguagem de IaC (Infrastructure as Code) desenvolvida pela Microsoft que compila diretamente para ARM Templates. Ou seja, por baixo dos panos, a Azure ainda usa ARM, mas você escreve um código muito mais legível e produtivo.

"Bicep é o ARM Template que você sempre quis escrever."

Lançado em 2021 como GA (Generally Available), o Bicep é hoje a forma recomendada pela Microsoft para definir recursos Azure via código.

Por que usar Bicep e não ARM Templates puro?

Veja a diferença para criar um simples Storage Account:

ARM Template (JSON):

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "storageAccountName": {
      "type": "string"
    }
  },
  "resources": [
    {
      "type": "Microsoft.Storage/storageAccounts",
      "apiVersion": "2022-09-01",
      "name": "[parameters('storageAccountName')]",
      "location": "[resourceGroup().location]",
      "sku": {
        "name": "Standard_LRS"
      },
      "kind": "StorageV2"
    }
  ]
}
Enter fullscreen mode Exit fullscreen mode

Bicep (equivalente):

param storageAccountName string

resource storageAccount 'Microsoft.Storage/storageAccounts@2022-09-01' = {
  name: storageAccountName
  location: resourceGroup().location
  sku: {
    name: 'Standard_LRS'
  }
  kind: 'StorageV2'
}
Enter fullscreen mode Exit fullscreen mode

Muito mais limpo, não é? Menos linhas, sem JSON aninhado e sem aquelas funções [parameters(...)] espalhadas por todo lado.

Bicep vs ARM vs Terraform: qual escolher?

Característica Bicep ARM Template Terraform
Sintaxe Limpa, DSL própria JSON verboso HCL
Multi-cloud ❌ Apenas Azure ❌ Apenas Azure ✅ Sim
Suporte a recursos Azure ✅ Primeiro dia ✅ Primeiro dia ⚠️ Depende do provider
Curva de aprendizado Baixa Alta Média
State file ❌ Não precisa ❌ Não precisa ✅ Necessário
Módulos ✅ Sim ⚠️ Linked templates ✅ Sim
Integração nativa Azure DevOps/GitHub ✅ Nativa ✅ Nativa Requer setup

Resumo prático:

  • Se você trabalha exclusivamente com Azure → Bicep é a melhor escolha
  • Se precisa de multi-cloud → Terraform
  • Se está migrando ARM existente → Bicep (tem conversor automático!)

Instalação

Pré-requisitos

Instalar o Bicep CLI 

# Via Azure CLI (recomendado)
az bicep install

# Verificar versão
az bicep version
Enter fullscreen mode Exit fullscreen mode

Extensão para VS Code

Instale a extensão oficial Bicep da Microsoft no VS Code. Ela oferece:

  • IntelliSense completo
  • Validação em tempo real
  • Autocompletar de tipos de recursos e propriedades
  • Visualização do diagrama de dependências

Conceitos Fundamentais

1. Parâmetros (param) 

@description('Nome do ambiente')
@allowed(['dev', 'staging', 'prod'])
param environment string = 'dev'

@minLength(3)
@maxLength(24)
param storageAccountName string
Enter fullscreen mode Exit fullscreen mode

Os decorators (@description, @allowed, @minLength) substituem as validações que no ARM eram feitas dentro do JSON.

2. Variáveis (var) 

var location = resourceGroup().location
var tags = {
  environment: environment
  project: 'meu-projeto'
  managedBy: 'bicep'
}
Enter fullscreen mode Exit fullscreen mode

3. Recursos (resource) 

resource appServicePlan 'Microsoft.Web/serverfarms@2022-03-01' = {
  name: 'plan-${environment}'
  location: location
  tags: tags
  sku: {
    name: 'B1'
    tier: 'Basic'
  }
}
Enter fullscreen mode Exit fullscreen mode

4. Outputs (output) 

output appServicePlanId string = appServicePlan.id
output storageAccountEndpoint string = storageAccount.properties.primaryEndpoints.blob
Enter fullscreen mode Exit fullscreen mode

Exemplo Prático: Web App com Storage

Vamos criar um arquivo Bicep que provisiona um App Service + Storage Account completo:

// main.bicep

@description('Prefixo para os recursos')
param prefix string

@description('Ambiente de deploy')
@allowed(['dev', 'staging', 'prod'])
param environment string = 'dev'

var location = resourceGroup().location
var tags = {
  environment: environment
  managedBy: 'bicep'
}

// Storage Account
resource storageAccount 'Microsoft.Storage/storageAccounts@2022-09-01' = {
  name: '${prefix}${environment}st'
  location: location
  tags: tags
  sku: {
    name: 'Standard_LRS'
  }
  kind: 'StorageV2'
  properties: {
    accessTier: 'Hot'
    supportsHttpsTrafficOnly: true
    minimumTlsVersion: 'TLS1_2'
  }
}

// App Service Plan
resource appServicePlan 'Microsoft.Web/serverfarms@2022-03-01' = {
  name: '${prefix}-${environment}-plan'
  location: location
  tags: tags
  sku: {
    name: environment == 'prod' ? 'S1' : 'B1'
  }
}

// Web App
resource webApp 'Microsoft.Web/sites@2022-03-01' = {
  name: '${prefix}-${environment}-app'
  location: location
  tags: tags
  properties: {
    serverFarmId: appServicePlan.id
    httpsOnly: true
    siteConfig: {
      appSettings: [
        {
          name: 'STORAGE_CONNECTION'
          value: 'DefaultEndpointsProtocol=https;AccountName=${storageAccount.name};AccountKey=${storageAccount.listKeys().keys[0].value}'
        }
      ]
    }
  }
}

output webAppUrl string = 'https://${webApp.properties.defaultHostName}'
output storageAccountName string = storageAccount.name
Enter fullscreen mode Exit fullscreen mode

Deploy 

# Criar Resource Group
az group create --name rg-meu-projeto-dev --location brazilsouth

# Preview do que será criado (What-If)
az deployment group what-if \
  --resource-group rg-meu-projeto-dev \
  --template-file main.bicep \
  --parameters prefix=meuprojeto environment=dev

# Deploy
az deployment group create \
  --resource-group rg-meu-projeto-dev \
  --template-file main.bicep \
  --parameters prefix=meuprojeto environment=dev
Enter fullscreen mode Exit fullscreen mode

Módulos: reutilizando código

Uma das funcionalidades mais poderosas do Bicep são os módulos, que permitem quebrar a infraestrutura em partes reutilizáveis:

// modules/storage.bicep
param name string
param location string = resourceGroup().location

resource storageAccount 'Microsoft.Storage/storageAccounts@2022-09-01' = {
  name: name
  location: location
  sku: { name: 'Standard_LRS' }
  kind: 'StorageV2'
}

output id string = storageAccount.id
Enter fullscreen mode Exit fullscreen mode 
// main.bicep — usando o módulo
module storage './modules/storage.bicep' = {
  name: 'storageDeployment'
  params: {
    name: 'mystorageaccount'
  }
}

output storageId string = storage.outputs.id
Enter fullscreen mode Exit fullscreen mode

Você também pode referenciar módulos diretamente de um Bicep Registry (ACR) para compartilhar entre times:

module storage 'br:meuregistry.azurecr.io/bicep/storage:v1.0' = {
  name: 'storageDeployment'
  params: {
    name: 'mystorageaccount'
  }
}
Enter fullscreen mode Exit fullscreen mode

Convertendo ARM Templates existentes para Bicep

Se você já tem ARM Templates, a migração é simples:

# Decompila ARM Template para Bicep
az bicep decompile --file template.json

# Converte Bicep de volta para ARM (útil para debug)
az bicep build --file main.bicep
Enter fullscreen mode Exit fullscreen mode

Dicas e Boas Práticas

  1. Use parâmetros com defaults para ambientes distintos (dev, staging, prod)
  2. Adicione tags em todos os recursos para facilitar o custo e governança
  3. Use what-if antes de todo deploy em produção
  4. Organize em módulos desde o início evita refatorações grandes depois
  5. Versione no Git junto ao código da aplicação (mesmo repositório)
  6. Use o Bicep Registry (Azure Container Registry) para compartilhar módulos entre projetos e times

Próximos passos

O Bicep é, sem dúvida, a evolução natural para quem trabalha com IaC na Azure. Se você ainda usa ARM Templates puros, vale muito a pena considerar a migração, pois a curva de aprendizado é baixa e os ganhos em produtividade e manutenibilidade são imediatos.

E você, já está usando Bicep nos seus projetos? Deixa nos comentários!

Top comments (0)