0Pricing
Cloud & IT Cert Prep · Aula

Escrevendo Modelos ARM

Crie um modelo ARM parametrizado em JSON para implantar uma conta de armazenamento e uma VM e use funções e variáveis de modelo para tornar os modelos reutilizáveis.

Escrevendo Modelos ARM é uma aula grátis de Cloud & IT Cert Prep no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Cloud & IT Cert Prep, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Cloud & IT Cert Prep inclui 4 aulas no total.

Por que usar modelos do ARM?

Os modelos do ARM permitem definir a infraestrutura do Azure como código no formato JSON. Isso possibilita implantações repetíveis e consistentes, que podem ser controladas por versão junto com o código da sua aplicação. Os modelos são idempotentes — executar o mesmo modelo várias vezes produz o mesmo resultado, tornando seguro reaplicá-lo após alterações.

Estrutura básica e esquema do modelo

Todo modelo do ARM começa com uma propriedade $schema que aponta para a URL do esquema do modelo, seguida por uma cadeia de caracteres contentVersion. O esquema informa ao portal do Azure e às extensões do editor como validar o modelo e fornecer IntelliSense para ele. As cinco seções principais seguintes são parameters, variables, functions, resources e outputs.

{
  '$schema': 'https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#',
  'contentVersion': '1.0.0.0',
  'parameters': {},
  'variables': {},
  'functions': [],
  'resources': [],
  'outputs': {}
}

Definindo parâmetros

Parameters tornam os modelos reutilizáveis ao aceitar entradas no momento da implantação. Cada parâmetro tem um type (string, int, bool, object, array, secureString), um defaultValue opcional e allowedValues opcionais para validação. Usar secureString para senhas garante que o valor nunca seja registrado no histórico da implantação.

"parameters": {
  "storageAccountName": {
    "type": "string",
    "minLength": 3,
    "maxLength": 24,
    "metadata": { "description": "Globally unique storage account name" }
  },
  "sku": {
    "type": "string",
    "defaultValue": "Standard_LRS",
    "allowedValues": ["Standard_LRS", "Standard_GRS", "Premium_LRS"]
  }
}

Usando variáveis para valores calculados

Variables armazenam valores calculados a partir de parâmetros ou funções do modelo, reduzindo repetições e facilitando a manutenção dos modelos. As variáveis são avaliadas uma vez e referenciadas em toda a seção de recursos usando a expressão [variables('name')]. Um padrão comum é criar um nome de recurso concatenando um parâmetro com um sufixo exclusivo.

"variables": {
  "uniqueStorageName": "[concat(parameters('storageAccountName'), uniqueString(resourceGroup().id))]",
  "location": "[resourceGroup().location]"
}

Definindo recursos

A matriz resources é o núcleo de um modelo do ARM. Cada elemento descreve um recurso do Azure com campos obrigatórios: type, apiVersion, name e location. A apiVersion fixa a versão do esquema do provedor de recursos — sempre use uma versão estável recente para acessar os recursos mais novos e evitar propriedades obsoletas.

"resources": [
  {
    "type": "Microsoft.Storage/storageAccounts",
    "apiVersion": "2023-01-01",
    "name": "[variables('uniqueStorageName')]",
    "location": "[variables('location')]",
    "sku": { "name": "[parameters('sku')]" },
    "kind": "StorageV2",
    "properties": {
      "supportsHttpsTrafficOnly": true,
      "minimumTlsVersion": "TLS1_2"
    }
  }
]

Funções e expressões de modelos

As expressões dos modelos do ARM são envolvidas por colchetes [...] e são compatíveis com funções internas para cadeias de caracteres, matrizes, objetos e IDs de recursos. Entre as funções comuns estão concat(), resourceGroup(), resourceId(), uniqueString() e parameters(). Essas funções são avaliadas no lado do servidor pelo ARM no momento da implantação, e não localmente.

// Reference a resource ID inside a template
"subnetId": "[resourceId('Microsoft.Network/virtualNetworks/subnets', 'myVNet', 'mySubnet')]"

// Build a unique, deterministic name
"name": "[concat('storage', uniqueString(resourceGroup().id))]"

// Conditionally include a resource
"condition": "[equals(parameters('deployStorage'), true)]"

Outputs: retornando valores

A seção outputs define os valores que o ARM retorna após uma implantação bem-sucedida. Os outputs são essenciais para encadear modelos — você implanta um modelo de rede e retorna o ID do recurso de sub-rede; depois, passa esse ID como parâmetro para um modelo de VM. Os outputs podem referenciar qualquer expressão, inclusive propriedades de recursos da implantação.

"outputs": {
  "storageAccountName": {
    "type": "string",
    "value": "[variables('uniqueStorageName')]"
  },
  "blobEndpoint": {
    "type": "string",
    "value": "[reference(variables('uniqueStorageName')).primaryEndpoints.blob]"
  }
}

Modelos vinculados e aninhados

Para arquiteturas complexas, o ARM é compatível com modelos vinculados (que fazem referência a URLs de modelos externos) e modelos aninhados (que incorporam um modelo na matriz de recursos usando o tipo Microsoft.Resources/deployments). Isso permite dividir uma implantação de infraestrutura grande em partes modulares e reutilizáveis, mantendo um único modelo de orquestração como ponto de entrada.

{
  "type": "Microsoft.Resources/deployments",
  "apiVersion": "2021-04-01",
  "name": "networkDeploy",
  "properties": {
    "mode": "Incremental",
    "templateLink": {
      "uri": "https://raw.githubusercontent.com/contoso/templates/main/network.json",
      "contentVersion": "1.0.0.0"
    },
    "parameters": {
      "vnetName": { "value": "[parameters('vnetName')]" }
    }
  }
}

Arquivos de parâmetros

Em vez de passar parâmetros na linha de comando, armazene-os em um arquivo de parâmetros separado — um arquivo JSON com um objeto parameters contendo pares de nome e valor. Os arquivos de parâmetros podem ser específicos de cada ambiente (por exemplo, dev.parameters.json e prod.parameters.json) e armazenados no controle de código-fonte, mantendo os valores confidenciais em referências ao Azure Key Vault, em vez de texto simples.

// dev.parameters.json
{
  '$schema': 'https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#',
  'contentVersion': '1.0.0.0',
  'parameters': {
    'storageAccountName': { 'value': 'devstorageacct' },
    'sku': { 'value': 'Standard_LRS' }
  }
}

// Deploy with parameters file
// az deployment group create -g MyRG -f azuredeploy.json -p dev.parameters.json

Implantando e validando modelos

Use o comando da Azure CLI az deployment group create para implantar um modelo em um grupo de recursos. Antes de implantar em produção, execute az deployment group validate para detectar erros de esquema e lógica, e az deployment group what-if para visualizar as alterações nos recursos. Esses três comandos formam um pipeline de implantação seguro: validar, visualizar e implantar.

# Step 1: Validate the template syntax
az deployment group validate \
  --resource-group MyRG \
  --template-file azuredeploy.json \
  --parameters @dev.parameters.json

# Step 2: Preview changes
az deployment group what-if \
  --resource-group MyRG \
  --template-file azuredeploy.json \
  --parameters @dev.parameters.json

# Step 3: Deploy
az deployment group create \
  --resource-group MyRG \
  --template-file azuredeploy.json \
  --parameters @dev.parameters.json

Práticas recomendadas para modelos do ARM

Siga estas práticas recomendadas para modelos do ARM: use parâmetros para valores específicos do ambiente, use variáveis para evitar repetições, fixe as versões da API em versões estáveis, use secureString para senhas, adicione descrições de metadados aos parâmetros e divida modelos grandes em módulos vinculados. Armazene os modelos em um repositório Git e implante-os por meio de um pipeline de CI/CD para garantir a rastreabilidade.

Verificação rápida

Teste sua compreensão dos conceitos do Microsoft Azure Fundamentals (AZ-900) abordados nesta lição.

Recapitulação da lição

Nesta lição, você aprendeu que os modelos do ARM são documentos JSON que definem declarativamente a infraestrutura do Azure; parâmetros e variáveis tornam os modelos reutilizáveis e fáceis de manter; e o fluxo de trabalho validate, what-if, deploy possibilita implantações seguras e repetíveis. A seguir, exploraremos o Bicep, uma abstração moderna sobre o JSON do ARM.

Perguntas Frequentes

A aula “Escrevendo Modelos ARM” é grátis?

Sim — o texto completo de “Escrevendo Modelos ARM” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Cloud & IT Cert Prep, atualize para CoddyKit PRO. O curso de Cloud & IT Cert Prep inclui 4 aulas no total.

O que vou aprender em “Escrevendo Modelos ARM”?

Crie um modelo ARM parametrizado em JSON para implantar uma conta de armazenamento e uma VM e use funções e variáveis de modelo para tornar os modelos reutilizáveis. Você pratica Cloud & IT Cert Prep com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Cloud & IT Cert Prep?

Nenhuma experiência prévia é necessária. Cloud & IT Cert Prep no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Escrevendo Modelos ARM”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Cloud & IT Cert Prep?

Sim. Cada aula de Cloud & IT Cert Prep inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Como funciona o Azure Resource Manager
  2. Escrevendo Modelos ARM
  3. Bicep: IaC moderno do Azure
  4. Terraform no Azure
← Voltar para Cloud & IT Cert Prep