Compartilhar via

Tutorial: Usar arquivos de parâmetro para implantar o modelo do Azure Resource Manager

Neste tutorial, você aprenderá a usar arquivos de parâmetro para armazenar os valores passados durante a implantação. Nos tutoriais anteriores, você usou parâmetros embutidos com o comando de implantação. Essa abordagem funcionou para testar o modelo do ARM (modelo do 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 facilitam o empacotamento de valores de parâmetro para um ambiente específico. Neste tutorial, você criará arquivos de parâmetro para ambientes de desenvolvimento e produção. Esta instrução leva 12 minutos para ser concluída.

Pré-requisitos

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

Você precisa ter o Visual Studio Code e o Azure PowerShell ou a CLI do Azure. Para obter mais informações, consulte as ferramentas de modelo.

Modelo de revisão

Seu modelo tem muitos parâmetros que você pode fornecer durante a implantação. No final do tutorial anterior, seu 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": "2025-06-01",
      "name": "[variables('uniqueStorageName')]",
      "location": "[parameters('location')]",
      "tags": "[parameters('resourceTags')]",
      "sku": {
        "name": "[parameters('storageSKU')]"
      },
      "kind": "StorageV2",
      "properties": {
        "supportsHttpsTrafficOnly": true
      }
    },
    {
      "type": "Microsoft.Web/serverfarms",
      "apiVersion": "2025-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": "2025-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 você deseja gerenciar facilmente os parâmetros que você passa para o modelo.

Adicionar arquivos de parâmetro

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

No arquivo de parâmetro, você fornece valores para os parâmetros em seu modelo. O nome de cada parâmetro em seu arquivo de parâmetro precisa corresponder ao nome de um parâmetro em seu 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âmetro, você será solicitado a fornecer um valor durante a implantação.

Você não pode especificar um nome de parâmetro em seu arquivo de parâmetro que não corresponda a um nome de parâmetro no modelo. Você recebe um erro ao fornecer parâmetros desconhecidos.

No Visual Studio Code, crie um novo 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 é o arquivo de parâmetro para o ambiente de desenvolvimento. Observe que ele usa Standard_LRS para a conta de armazenamento, atribui nomes aos recursos com um prefixo dev e define a Environment marca como Dev.

Novamente, crie um novo 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 é o 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 Environment tag como Produção. Em um ambiente de produção real, você também gostaria de usar um serviço de aplicativo com um SKU diferente de gratuito, mas usamos essa SKU para este tutorial.

Implantar modelo

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

Como um teste final do modelo, vamos criar dois novos grupos de recursos- um para o ambiente de desenvolvimento e um 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.

$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

Agora, implantamos no ambiente de produção.

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

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 a implantação

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

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

Limpar os recursos

  1. No portal do Azure, selecione Grupos de recursos no menu à esquerda.

  2. Selecione o nome do grupo de recursos ao lado da caixa de seleção com hiperlink. Se você concluir esta série, terá três grupos de recursos a serem excluídos : myResourceGroup, myResourceGroupDev e myResourceGroupProd.

  3. Selecione o ícone Excluir grupo de recursos no menu superior.

    Cuidado

    A exclusão de um grupo de recursos é irreversível.

  4. Digite o nome do grupo de recursos na janela pop-up que exibe e selecione Excluir.

Próximas etapas

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

A próxima série de tutoriais entra em mais detalhes sobre a implantação de modelos.

Implantar um modelo local

  • Last updated on