Tutorial: Usar arquivos de parâmetro para implantar seu modelo do ARM

Artigo
06/20/2024

Neste tutorial, você aprenderá a usar os arquivos de parâmetro para armazenar os valores que você passa durante a implantação. Nos tutoriais anteriores, você usou parâmetros embutidos com seu comando de implantação. Essa abordagem funcionou para testar seu modelo do ARM (Azure Resource Manager), mas, ao automatizar implantações, pode ser mais fácil passar um conjunto de valores para seu ambiente. Os arquivos de parâmetro tornam mais fácil empacotar valores de parâmetro para um ambiente específico. Neste tutorial, você criará arquivos de parâmetro para ambientes de desenvolvimento e produção. Essa instrução levar cerca de 12 minutos para ser concluída.

Pré-requisitos

Recomendamos que você conclua o tutorial sobre marcas, mas isso não é obrigatório.

É necessário ter o Visual Studio Code com a extensão Ferramentas do Resource Manager e o Azure PowerShell ou a CLI (interface de linha de comando) do Azure. Para obter mais informações, confira Ferramentas de modelo.

Examinar modelo

Seu modelo tem muitos parâmetros que você pode fornecer durante a implantação. No final do tutorial anterior, o modelo tinha o seguinte arquivo JSON:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "storagePrefix": {
      "type": "string",
      "minLength": 3,
      "maxLength": 11
    },
    "storageSKU": {
      "type": "string",
      "defaultValue": "Standard_LRS",
      "allowedValues": [
        "Standard_LRS",
        "Standard_GRS",
        "Standard_RAGRS",
        "Standard_ZRS",
        "Premium_LRS",
        "Premium_ZRS",
        "Standard_GZRS",
        "Standard_RAGZRS"
      ]
    },
    "location": {
      "type": "string",
      "defaultValue": "[resourceGroup().location]"
    },
    "appServicePlanName": {
      "type": "string",
      "defaultValue": "exampleplan"
    },
    "webAppName": {
      "type": "string",
      "metadata": {
        "description": "Base name of the resource such as web app name and app service plan "
      },
      "minLength": 2
    },
    "linuxFxVersion": {
      "type": "string",
      "defaultValue": "php|7.0",
      "metadata": {
        "description": "The Runtime stack of current web app"
      }
    },
    "resourceTags": {
      "type": "object",
      "defaultValue": {
        "Environment": "Dev",
        "Project": "Tutorial"
      }
    }
  },
  "variables": {
    "uniqueStorageName": "[concat(parameters('storagePrefix'), uniqueString(resourceGroup().id))]",
    "webAppPortalName": "[concat(parameters('webAppName'), uniqueString(resourceGroup().id))]"
  },
  "resources": [
    {
      "type": "Microsoft.Storage/storageAccounts",
      "apiVersion": "2021-09-01",
      "name": "[variables('uniqueStorageName')]",
      "location": "[parameters('location')]",
      "tags": "[parameters('resourceTags')]",
      "sku": {
        "name": "[parameters('storageSKU')]"
      },
      "kind": "StorageV2",
      "properties": {
        "supportsHttpsTrafficOnly": true
      }
    },
    {
      "type": "Microsoft.Web/serverfarms",
      "apiVersion": "2021-03-01",
      "name": "[parameters('appServicePlanName')]",
      "location": "[parameters('location')]",
      "tags": "[parameters('resourceTags')]",
      "sku": {
        "name": "B1",
        "tier": "Basic",
        "size": "B1",
        "family": "B",
        "capacity": 1
      },
      "kind": "linux",
      "properties": {
        "perSiteScaling": false,
        "reserved": true,
        "targetWorkerCount": 0,
        "targetWorkerSizeId": 0
      }
    },
    {
      "type": "Microsoft.Web/sites",
      "apiVersion": "2021-03-01",
      "name": "[variables('webAppPortalName')]",
      "location": "[parameters('location')]",
      "dependsOn": [
        "[parameters('appServicePlanName')]"
      ],
      "tags": "[parameters('resourceTags')]",
      "kind": "app",
      "properties": {
        "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', parameters('appServicePlanName'))]",
        "siteConfig": {
          "linuxFxVersion": "[parameters('linuxFxVersion')]"
        }
      }
    }
  ],
  "outputs": {
    "storageEndpoint": {
      "type": "object",
      "value": "[reference(variables('uniqueStorageName')).primaryEndpoints]"
    }
  }
}

Esse modelo funciona bem, mas agora convém gerenciar facilmente os parâmetros que você passa para o modelo.

Adicionar arquivos de parâmetro

Os arquivos de parâmetro são arquivos JSON com uma estrutura semelhante ao modelo. No arquivo, você fornece os valores de parâmetro que você deseja passar durante a implantação.

No arquivo de parâmetros, forneça valores para os parâmetros em seu modelo. O nome de cada parâmetro nesse arquivo deve corresponder ao nome de um parâmetro no modelo. O nome não diferencia maiúsculas de minúsculas, mas, para ver com mais facilidade os valores correspondentes, recomendamos que você faça a correspondência com o uso de maiúsculas e minúsculas do modelo.

Você não precisa fornecer um valor para cada parâmetro. Se um parâmetro não especificado tiver um valor padrão, esse valor será usado durante a implantação. Se um parâmetro não tiver um valor padrão e não for especificado no arquivo de parâmetros, será solicitado que você forneça um valor durante a implantação.

Não é possível especificar um nome de parâmetro no arquivo de parâmetros que não corresponda a um nome de parâmetro no modelo. Você receberá um erro quando forem fornecidos parâmetros desconhecidos.

No Visual Studio Code, crie um arquivo com o conteúdo a seguir. Salve o arquivo com o nome azuredeploy.parameters.dev.json.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "storagePrefix": {
      "value": "devstore"
    },
    "storageSKU": {
      "value": "Standard_LRS"
    },
    "appServicePlanName": {
      "value": "devplan"
    },
    "webAppName": {
      "value": "devapp"
    },
    "resourceTags": {
      "value": {
        "Environment": "Dev",
        "Project": "Tutorial"
      }
    }
  }
}

Esse arquivo é seu arquivo de parâmetro para o ambiente de desenvolvimento. Observe que ele usa Standard_LRS para a conta de armazenamento, nomeia recursos com um prefixo dev e define a marca Environment como Desenvolvimento.

Novamente, crie um arquivo com o conteúdo a seguir. Salve o arquivo com o nome azuredeploy.parameters.prod.json.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "storagePrefix": {
      "value": "contosodata"
    },
    "storageSKU": {
      "value": "Standard_GRS"
    },
    "appServicePlanName": {
      "value": "contosoplan"
    },
    "webAppName": {
      "value": "contosowebapp"
    },
    "resourceTags": {
      "value": {
        "Environment": "Production",
        "Project": "Tutorial"
      }
    }
  }
}

Esse arquivo é seu arquivo de parâmetro para o ambiente de produção. Observe que ele usa Standard_GRS para a conta de armazenamento, nomeia recursos com um prefixo contoso e define a marca Environment como Produção. Em um ambiente de produção real, também seria conveniente usar um serviço de aplicativo com um SKU que não seja gratuito, mas continuaremos usando esse SKU neste tutorial.

Implantar modelo

Use a CLI do Azure ou o Azure PowerShell para implantar o modelo.

Como um teste final do seu modelo, vamos criar dois novos grupos de recursos. Um para o ambiente de desenvolvimento e outro para o ambiente de produção.

Para as variáveis de modelo e parâmetro, substitua {path-to-the-template-file}, {path-to-azuredeploy.parameters.dev.json}, {path-to-azuredeploy.parameters.prod.json} e as chaves {} pelos caminhos de modelo e arquivo de parâmetro.

Primeiro, vamos implementar no ambiente de desenvolvimento.

PowerShell
CLI do Azure

$templateFile = "{path-to-the-template-file}"
$parameterFile="{path-to-azuredeploy.parameters.dev.json}"
New-AzResourceGroup `
  -Name myResourceGroupDev `
  -Location "East US"
New-AzResourceGroupDeployment `
  -Name devenvironment `
  -ResourceGroupName myResourceGroupDev `
  -TemplateFile $templateFile `
  -TemplateParameterFile $parameterFile

Para executar esse comando de implantação, você precisa ter a versão mais recente da CLI do Azure.

templateFile="{path-to-the-template-file}"
devParameterFile="{path-to-azuredeploy.parameters.dev.json}"
az group create \
  --name myResourceGroupDev \
  --location 'East US'
az deployment group create \
  --name devenvironment \
  --resource-group myResourceGroupDev \
  --template-file $templateFile \
  --parameters $devParameterFile

Agora, vamos implantar no ambiente de produção.

PowerShell
CLI do Azure

$parameterFile="{path-to-azuredeploy.parameters.prod.json}"
New-AzResourceGroup `
  -Name myResourceGroupProd `
  -Location "West US"
New-AzResourceGroupDeployment `
  -Name prodenvironment `
  -ResourceGroupName myResourceGroupProd `
  -TemplateFile $templateFile `
  -TemplateParameterFile $parameterFile

prodParameterFile="{path-to-azuredeploy.parameters.prod.json}"
az group create \
  --name myResourceGroupProd \
  --location "West US"
az deployment group create \
  --name prodenvironment \
  --resource-group myResourceGroupProd \
  --template-file $templateFile \
  --parameters $prodParameterFile

Observação

Se a implantação falhar, use a opção verbose para obter informações sobre os recursos que você está criando. Use a opção debug para obter mais informações de depuração.

Verificar implantação

Você pode verificar a implantação explorando os grupos de recursos do portal do Azure.

Entre no portal do Azure.
No menu à esquerda, selecione Grupos de recursos.
Você verá os dois novos grupos de recursos que implantou neste tutorial.
Selecione grupo de recursos e exiba os recursos implantados. Observe que eles correspondem aos valores especificados no seu arquivo de parâmetro para esse ambiente.

Limpar os recursos

No portal do Azure, selecione Grupos de recursos no menu à esquerda.
Selecione o nome do grupo de recursos com hiperlink ao lado da caixa de seleção. Se tiver concluído essa série, você terá três grupos de recursos a serem excluídos: myResourceGroup, myResourceGroupDev e myResourceGroupProd.
Selecione Excluir grupo de recursos no menu superior.

Cuidado

A exclusão de um grupo de recursos é irreversível.
Digite o nome do grupo de recursos na janela pop-up que aparece e selecione Excluir.

Próximas etapas

Parabéns. Você concluiu esta introdução à implantação de modelos no Azure. Informe-nos se você tiver comentários e sugestões na seção de comentários.

A próxima série de tutoriais detalhará mais a implantação de modelos.

☺Implantar um modelo local

Compartilhar via