Tutorial: Use ficheiros de parâmetros para implementar o seu modelo ARM

Neste tutorial, aprende-se a usar ficheiros de parâmetros para armazenar os valores que transmite durante a implementação. Nos tutoriais anteriores, utilizou parâmetros inline com o seu comando de implantação. Esta abordagem funcionou para testar o seu modelo de Resource Manager Azure (modelo ARM), mas ao automatizar implementações pode ser mais fácil passar um conjunto de valores para o seu ambiente. Os ficheiros de parâmetros facilitam a embalagem dos valores dos parâmetros para um ambiente específico. Neste tutorial, cria-se ficheiros de parâmetros para ambientes de desenvolvimento e produção. Esta instrução leva 12 minutos para ser completada.

Pré-requisitos

Recomendamos que complete o tutorial sobre etiquetas, mas não é necessário.

É necessário ter o Código do Estúdio Visual com a extensão Resource Manager Tools, e Azure PowerShell ou Azure Command-Line Interface (CLI). Para obter mais informações, consulte as ferramentas do modelo.

Modelo de revisão

O seu modelo tem muitos parâmetros que pode fornecer durante a implementação. No final do tutorial anterior, o seu modelo tinha o seguinte ficheiro 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]"
    }
  }
}

Este modelo funciona bem, mas agora você quer gerir facilmente os parâmetros que você passa para o modelo.

Adicionar ficheiros de parâmetros

Os ficheiros de parâmetros são ficheiros JSON com uma estrutura semelhante ao seu modelo. No ficheiro, fornece os valores de parâmetro que pretende transmitir durante a implementação.

Dentro do ficheiro de parâmetros, fornece valores para os parâmetros do seu modelo. O nome de cada parâmetro no seu ficheiro de parâmetro precisa de corresponder ao nome de um parâmetro no seu modelo. O nome é insensibilidade, mas para ver facilmente os valores correspondentes recomendamos que corresponda ao invólucro do modelo.

Não tens de fornecer um valor para cada parâmetro. Se um parâmetro não especificado tiver um valor padrão, esse valor é utilizado durante a implantação. Se um parâmetro não tiver um valor padrão e não estiver especificado no ficheiro do parâmetro, é solicitado que forneça um valor durante a implementação.

Não é possível especificar um nome de parâmetro no seu ficheiro de parâmetro que não corresponda a um nome de parâmetro no modelo. Obtém-se um erro quando fornece parâmetros desconhecidos.

No Código do Estúdio Visual, crie um novo ficheiro com o seguinte conteúdo. Guarde o ficheiro 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"
      }
    }
  }
}

Este ficheiro é o seu arquivo de parâmetros para o ambiente de desenvolvimento. Note que utiliza Standard_LRS para a conta de armazenamento, nomeia recursos com um prefixo dev , e define a Environment etiqueta para Dev.

Mais uma vez, crie um novo ficheiro com o seguinte conteúdo. Guarde o ficheiro 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"
      }
    }
  }
}

Este ficheiro é o seu arquivo de parâmetros para o ambiente de produção. Note que utiliza Standard_GRS para a conta de armazenamento, nomeia recursos com um prefixo contoso , e define a Environment etiqueta para a Produção. Num ambiente de produção real, você também gostaria de usar um serviço de aplicações com um SKU diferente de gratuito, mas usamos esse SKU para este tutorial.

Implementar o modelo

Utilize o Azure CLI ou Azure PowerShell para implementar o gabarito.

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

Para as variáveis do modelo e dos parâmetros, substitua {path-to-the-template-file}, {path-to-azuredeploy.parameters.dev.json}, , , {path-to-azuredeploy.parameters.prod.json}e os aparelhos {} encaracolados com o seu modelo e caminhos de arquivo de parâmetros.

Primeiro, vamos para o ambiente dev.

$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, vamos implantar-nos 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

Nota

Se a implementação falhar, use o verbose interruptor para obter informações sobre os recursos que está a criar. Use o debug interruptor para obter mais informações para depuração.

Verificar a implementação

Pode verificar a implementação explorando os grupos de recursos a partir do portal do Azure.

  1. Inicie sessão no portal do Azure.
  2. A partir do menu esquerdo, selecione Grupos de Recursos.
  3. Vê os dois novos grupos de recursos que implementa neste tutorial.
  4. Selecione qualquer um dos grupos de recursos e veja os recursos implantados. Note que correspondem aos valores especificados no seu ficheiro de parâmetros para esse ambiente.

Limpar os recursos

  1. A partir do portal do Azure, selecione grupos de recursos do menu esquerdo.

  2. Selecione o nome do grupo de recursos hiperligados ao lado da caixa de verificação. Se completar esta série, tem três grupos de recursos para eliminar - myResourceGroup, myResourceGroupDev e myResourceGroupProd.

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

    Atenção

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

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

Passos seguintes

Parabéns! Terminou esta introdução para implantar modelos para Azure. Informe-nos se tiver algum comentário e sugestões na secção de comentários.

A próxima série tutorial vai para mais detalhes sobre a implementação de modelos.