Utilize um objeto como um parâmetro num modelo Azure Resource ManagerUse an object as a parameter in an Azure Resource Manager template

Quando criar modelos Azure Resource Manager, pode especificar valores de propriedade de recurso diretamente no modelo ou definir um parâmetro e forneça valores durante a implementação.When you author Azure Resource Manager templates, you can either specify resource property values directly in the template or define a parameter and provide values during deployment. Não há problema em utilizar um parâmetro para cada valor de propriedade para Implantações pequenas, mas existe um limite de 255 parâmetros por implementação.It's fine to use a parameter for each property value for small deployments, but there is a limit of 255 parameters per deployment. Depois de obter para Implantações maiores e mais complexas que poderá ficar sem parâmetros.Once you get to larger and more complex deployments you may run out of parameters.

Uma forma de resolver esse problema é usar um objeto como um parâmetro em vez de um valor.One way to solve this problem is to use an object as a parameter instead of a value. Para tal, defina o parâmetro no seu modelo e especifique um objeto JSON em vez de um único valor durante a implementação.To do this, define the parameter in your template and specify a JSON object instead of a single value during deployment. Em seguida, subproperties de usar o parâmetro de referência a [ parameter() função] azure-resource-manager-functions e o operador de ponto no seu modelo.Then, reference the subproperties of the parameter using the parameter() function and dot operator in your template.

Vamos dar uma olhada num exemplo que implementa um recurso de rede virtual.Let's take a look at an example that deploys a virtual network resource. Em primeiro lugar, permite especificar uma VNetSettings parâmetro no nosso modelo e defina a type para object:First, let's specify a VNetSettings parameter in our template and set the type to object:

...
"parameters": {
    "VNetSettings":{"type":"object"}
},

Em seguida, vamos fornecer valores para o VNetSettings objeto:Next, let's provide values for the VNetSettings object:

Nota

Para saber como fornecer valores de parâmetro durante a implementação, consulte a parâmetros secção [compreender a estrutura e a sintaxe de modelos Azure Resource Manager] azure-resource-manager-authoring-templates .To learn how to provide parameter values during deployment, see the parameters section of understand the structure and syntax of Azure Resource Manager templates.

"parameters":{
    "VNetSettings":{
        "value":{
            "name":"VNet1",
            "addressPrefixes": [
                {
                    "name": "firstPrefix",
                    "addressPrefix": "10.0.0.0/22"
                }
            ],
            "subnets":[
                {
                    "name": "firstSubnet",
                    "addressPrefix": "10.0.0.0/24"
                },
                {
                    "name":"secondSubnet",
                    "addressPrefix":"10.0.1.0/24"
                }
            ]
        }
    }
}

Como pode ver, o nosso único parâmetro especifica, na verdade, três subproperties: name, addressPrefixes, e subnets.As you can see, our single parameter actually specifies three subproperties: name, addressPrefixes, and subnets. Cada um desses subproperties ou especifica um valor ou outros subproperties.Each of these subproperties either specifies a value or other subproperties. O resultado é que o nosso único parâmetro especifica todos os valores necessários para implementar a nossa rede virtual.The result is that our single parameter specifies all the values necessary to deploy our virtual network.

Agora vamos dar uma olhada no resto do nosso modelo para ver como o VNetSettings objeto é usado:Now let's have a look at the rest of our template to see how the VNetSettings object is used:

...
"resources": [
    {
        "apiVersion": "2015-06-15",
        "type": "Microsoft.Network/virtualNetworks",
        "name": "[parameters('VNetSettings').name]",
        "location":"[resourceGroup().location]",
        "properties": {
          "addressSpace":{
              "addressPrefixes": [
                "[parameters('VNetSettings').addressPrefixes[0].addressPrefix]"
              ]
          },
          "subnets":[
              {
                  "name":"[parameters('VNetSettings').subnets[0].name]",
                  "properties": {
                      "addressPrefix": "[parameters('VNetSettings').subnets[0].addressPrefix]"
                  }
              },
              {
                  "name":"[parameters('VNetSettings').subnets[1].name]",
                  "properties": {
                      "addressPrefix": "[parameters('VNetSettings').subnets[1].addressPrefix]"
                  }
              }
          ]
        }
    }
  ]

Os valores de nosso VNetSettings objeto são aplicadas para as propriedades necessárias por nossos recursos de rede virtual com o parameters() função com ambos os [] indexador e o operador de ponto de matriz.The values of our VNetSettings object are applied to the properties required by our virtual network resource using the parameters() function with both the [] array indexer and the dot operator. Essa abordagem funciona se pretender aplicar estaticamente os valores do objeto de parâmetro ao recurso.This approach works if you just want to statically apply the values of the parameter object to the resource. No entanto, se pretender atribuir dinamicamente uma matriz de valores de propriedade durante a implementação pode utilizar um ciclo de cópia.However, if you want to dynamically assign an array of property values during deployment you can use a copy loop. Para usar um loop de cópia, é fornecer uma matriz JSON de recurso valores de propriedade e do ciclo de cópia dinamicamente aplica-se os valores para propriedades do recurso.To use a copy loop, you provide a JSON array of resource property values and the copy loop dynamically applies the values to the resource's properties.

Há um problema a ter em consideração se usar a abordagem dinâmica.There is one issue to be aware of if you use the dynamic approach. Para demonstrar o problema, vamos dar uma olhada numa matriz típica de valores de propriedade.To demonstrate the issue, let's take a look at a typical array of property values. Neste exemplo, os valores para nossas propriedades são armazenados numa variável.In this example the values for our properties are stored in a variable. Tenha em atenção que tem duas matrizes aqui—denominado firstProperty e outra com o nome secondProperty.Notice we have two arrays here—one named firstProperty and one named secondProperty.

"variables": {
    "firstProperty": [
        {
            "name": "A",
            "type": "typeA"
        },
        {
            "name": "B",
            "type": "typeB"
        },
        {
            "name": "C",
            "type": "typeC"
        }
    ],
    "secondProperty": [
        "one","two", "three"
    ]
}

Agora vamos dar uma olhada na forma podemos acessar as propriedades na variável usando um loop de cópia.Now let's take a look at the way we access the properties in the variable using a copy loop.

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    ...
    "copy": {
        "name": "copyLoop1",
        "count": "[length(variables('firstProperty'))]"
    },
    ...
    "properties": {
        "name": { "value": "[variables('firstProperty')[copyIndex()].name]" },
        "type": { "value": "[variables('firstProperty')[copyIndex()].type]" },
        "number": { "value": "[variables('secondProperty')[copyIndex()]]" }
    }
}

O copyIndex() função retorna a iteração atual do ciclo de cópia, e podemos usá-lo como um índice em cada uma das duas matrizes em simultâneo.The copyIndex() function returns the current iteration of the copy loop, and we use that as an index into each of the two arrays simultaneously.

Isso funciona bem quando as duas matrizes são o mesmo tamanho.This works fine when the two arrays are the same length. O problema surge se cometeu um erro e as duas matrizes são diferentes comprimentos—neste caso, seu modelo falhará a validação durante a implementação.The issue arises if you've made a mistake and the two arrays are different lengths—in this case your template will fail validation during deployment. Pode evitar este problema, incluindo todas as suas propriedades num único objeto, porque é mais fácil ver quando está em falta um valor.You can avoid this issue by including all your properties in a single object, because it is much easier to see when a value is missing. Por exemplo, vamos dar uma olhada outro objeto de parâmetro no qual cada elemento do propertyObject matriz é a União do firstProperty e secondProperty matrizes de partir anteriormente.For example, let's take a look another parameter object in which each element of the propertyObject array is the union of the firstProperty and secondProperty arrays from earlier.

"variables": {
    "propertyObject": [
        {
            "name": "A",
            "type": "typeA",
            "number": "one"
        },
        {
            "name": "B",
            "type": "typeB",
            "number": "two"
        },
        {
            "name": "C",
            "type": "typeC"
        }
    ]
}

Observe o terceiro elemento na matriz?Notice the third element in the array? Ele está em falta o number propriedade, mas do muito mais fácil a observar que já perdeu este evento quando estiver criando os valores de parâmetro dessa maneira.It's missing the number property, but it's much easier to notice that you've missed it when you're authoring the parameter values this way.

Usando um objeto de propriedade num loop de cópiaUsing a property object in a copy loop

Esta abordagem se torna ainda mais útil quando combinado com o [loop cópia serial] [azure-resource-manager-criar-vários], particularmente para implementar recursos subordinados.This approach becomes even more useful when combined with the [serial copy loop][azure-resource-manager-create-multiple], particularly for deploying child resources.

Para demonstrar isso, vamos dar uma olhada num modelo que implementa uma [grupo de segurança de rede (NSG)] nsg com duas regras de segurança.To demonstrate this, let's look at a template that deploys a network security group (NSG) with two security rules.

Em primeiro lugar, vamos dar uma olhada em nosso parâmetros.First, let's take a look at our parameters. Quando olhamos nossos, veremos que definimos um parâmetro com o nome de modelo networkSecurityGroupsSettings que inclui uma matriz chamada securityRules.When we look at our template we'll see that we've defined one parameter named networkSecurityGroupsSettings that includes an array named securityRules. Essa matriz contém dois objetos JSON que especifique um número de definições para uma regra de segurança.This array contains two JSON objects that specify a number of settings for a security rule.

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentParameters.json#",
    "contentVersion": "1.0.0.0",
    "parameters":{
      "networkSecurityGroupsSettings": {
      "value": {
          "securityRules": [
            {
              "name": "RDPAllow",
              "description": "allow RDP connections",
              "direction": "Inbound",
              "priority": 100,
              "sourceAddressPrefix": "*",
              "destinationAddressPrefix": "10.0.0.0/24",
              "sourcePortRange": "*",
              "destinationPortRange": "3389",
              "access": "Allow",
              "protocol": "Tcp"
            },
            {
              "name": "HTTPAllow",
              "description": "allow HTTP connections",
              "direction": "Inbound",
              "priority": 200,
              "sourceAddressPrefix": "*",
              "destinationAddressPrefix": "10.0.1.0/24",
              "sourcePortRange": "*",
              "destinationPortRange": "80",
              "access": "Allow",
              "protocol": "Tcp"
            }
          ]
        }
      }
    }
  }

Agora vamos dar uma olhada no nosso modelo.Now let's take a look at our template. Nosso primeiro com o nome de recurso NSG1 implementa o NSG.Our first resource named NSG1 deploys the NSG. Nosso segundo recurso com o nome loop-0 executa duas funções: primeiro, ele dependsOn o NSG para a implementação não começa até NSG1 estiver concluída, e é a primeira iteração de loop seqüencial.Our second resource named loop-0 performs two functions: first, it dependsOn the NSG so its deployment doesn't begin until NSG1 is completed, and it is the first iteration of the sequential loop. Nosso terceiro recurso é um modelo aninhado que implementa as nossas regras de segurança com um objeto para seus valores de parâmetro como no último exemplo.Our third resource is a nested template that deploys our security rules using an object for its parameter values as in the last example.

{
  "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
      "networkSecurityGroupsSettings": {"type":"object"}
  },
  "variables": {},
  "resources": [
    {
      "apiVersion": "2015-06-15",
      "type": "Microsoft.Network/networkSecurityGroups",
      "name": "NSG1",
      "location":"[resourceGroup().location]",
      "properties": {
          "securityRules":[]
      }
    },
    {
        "apiVersion": "2015-01-01",
        "type": "Microsoft.Resources/deployments",
        "name": "loop-0",
        "dependsOn": [
            "NSG1"
        ],
        "properties": {
            "mode":"Incremental",
            "parameters":{},
            "template": {
                "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
                "contentVersion": "1.0.0.0",
                "parameters": {},
                "variables": {},
                "resources": [],
                "outputs": {}
            }
        }
    },
    {
        "apiVersion": "2015-01-01",
        "type": "Microsoft.Resources/deployments",
        "name": "[concat('loop-', copyIndex(1))]",
        "dependsOn": [
          "[concat('loop-', copyIndex())]"
        ],
        "copy": {
          "name": "iterator",
          "count": "[length(parameters('networkSecurityGroupsSettings').securityRules)]"
        },
        "properties": {
          "mode": "Incremental",
          "template": {
            "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
            "contentVersion": "1.0.0.0",
           "parameters": {},
            "variables": {},
            "resources": [
                {
                    "name": "[concat('NSG1/' , parameters('networkSecurityGroupsSettings').securityRules[copyIndex()].name)]",
                    "type": "Microsoft.Network/networkSecurityGroups/securityRules",
                    "apiVersion": "2016-09-01",
                    "location":"[resourceGroup().location]",
                    "properties":{
                        "description": "[parameters('networkSecurityGroupsSettings').securityRules[copyIndex()].description]",
                        "priority":"[parameters('networkSecurityGroupsSettings').securityRules[copyIndex()].priority]",
                        "protocol":"[parameters('networkSecurityGroupsSettings').securityRules[copyIndex()].protocol]",
                        "sourcePortRange": "[parameters('networkSecurityGroupsSettings').securityRules[copyIndex()].sourcePortRange]",
                        "destinationPortRange": "[parameters('networkSecurityGroupsSettings').securityRules[copyIndex()].destinationPortRange]",
                        "sourceAddressPrefix": "[parameters('networkSecurityGroupsSettings').securityRules[copyIndex()].sourceAddressPrefix]",
                        "destinationAddressPrefix": "[parameters('networkSecurityGroupsSettings').securityRules[copyIndex()].destinationAddressPrefix]",
                        "access":"[parameters('networkSecurityGroupsSettings').securityRules[copyIndex()].access]",
                        "direction":"[parameters('networkSecurityGroupsSettings').securityRules[copyIndex()].direction]"
                        }
                  }
            ],
            "outputs": {}
          }
        }
    }
  ],
  "outputs": {}
}

Vamos dar uma análise detalhada das como especificamos nossos valores de propriedade no securityRules recursos subordinados.Let's take a closer look at how we specify our property values in the securityRules child resource. Todas as nossas propriedades serão referenciadas usando o parameter() função e, em seguida, vamos utilizar o operador de ponto para fazer referência a nossa securityRules matriz, indexado pelo valor atual da iteração.All of our properties are referenced using the parameter() function, and then we use the dot operator to reference our securityRules array, indexed by the current value of the iteration. Finalmente, usamos outro operador de ponto para referenciar o nome do objeto.Finally, we use another dot operator to reference the name of the object.

Experimentar o modeloTry the template

Um modelo de exemplo está disponível no GitHub.An example template is available on GitHub. Para implementar o modelo, clone o repositório e execute o seguinte [CLI do Azure] cli comandos:To deploy the template, clone the repo and run the following Azure CLI commands:

git clone https://github.com/mspnp/template-examples.git
cd template-examples/example3-object-param
az group create --location <location> --name <resource-group-name>
az group deployment create -g <resource-group-name> \
    --template-uri https://raw.githubusercontent.com/mspnp/template-examples/master/example3-object-param/deploy.json \
    --parameters deploy.parameters.json

Passos SeguintesNext steps