Regra de política de estrutura de definição de política do Azure

A regra de if política consiste em e then bloqueia. if No bloco , você define uma ou mais condições que especificam quando a política é imposta. Pode aplicar operadores lógicos a estas condições para definir com precisão o cenário de uma política.

Para obter detalhes completos sobre cada efeito, ordem de avaliação, propriedades e exemplos, consulte Noções básicas de efeitos de definições de Política do Azure.

then No bloco , você define o efeito que acontece quando as if condições são cumpridas.

{
  "if": {
      <condition> | <logical operator>
  },
  "then": {
    "effect": "deny | audit | modify | denyAction | append | auditIfNotExists | deployIfNotExists | disabled"
  }
}

Para obter mais informações sobre policyRule, vá para o esquema de definição de política.

Operadores lógicos

Os operadores lógicos suportados são:

• "not": {condition or operator}
• "allOf": [{condition or operator},{condition or operator}]
• "anyOf": [{condition or operator},{condition or operator}]

A not sintaxe inverte o resultado da condição. A allOf sintaxe (semelhante à operação lógica and ) requer que todas as condições sejam verdadeiras. A anyOf sintaxe (semelhante à operação lógica or ) requer uma ou mais condições para ser verdadeira.

Você pode aninhar operadores lógicos. O exemplo a seguir mostra uma not operação aninhada em uma allOf operação.

"if": {
  "allOf": [
    {
      "not": {
        "field": "tags",
        "containsKey": "application"
      }
    },
    {
      "field": "type",
      "equals": "Microsoft.Storage/storageAccounts"
    }
  ]
},

Condições

Uma condição avalia se um valor atende a determinados critérios. As condições suportadas são:

• "equals": "stringValue"
• "notEquals": "stringValue"
• "like": "stringValue"
• "notLike": "stringValue"
• "match": "stringValue"
• "matchInsensitively": "stringValue"
• "notMatch": "stringValue"
• "notMatchInsensitively": "stringValue"
• "contains": "stringValue"
• "notContains": "stringValue"
• "in": ["stringValue1","stringValue2"]
• "notIn": ["stringValue1","stringValue2"]
• "containsKey": "keyName"
• "notContainsKey": "keyName"
• "less": "dateValue" | "less": "stringValue" | "less": intValue
• "lessOrEquals": "dateValue" | "lessOrEquals": "stringValue" | "lessOrEquals": intValue
• "greater": "dateValue" | "greater": "stringValue" | "greater": intValue
• "greaterOrEquals": "dateValue" | "greaterOrEquals": "stringValue" | "greaterOrEquals": intValue
• "exists": "bool"

Para less, lessOrEquals, greatere , se greaterOrEqualso tipo de propriedade não corresponder ao tipo de condição, um erro será gerado. As comparações de cadeia de caracteres são feitas usando InvariantCultureIgnoreCase.

Ao usar as like condições e , você fornece um caractere notLike curinga (*) no valor. O valor não deve ter mais de um caractere curinga.

Ao usar as match condições e notMatch , forneça uma hashtag (#) para corresponder a um dígito, ponto de interrogação (?) para uma letra e um ponto (.) para corresponder a qualquer caractere, e qualquer outro caractere para corresponder a esse caractere real. Embora match diferenciem maiúsculas de minúsculas notMatch , todas as outras condições que avaliam um stringValue diferenciam maiúsculas de minúsculas. Alternativas que não diferenciam maiúsculas de minúsculas estão disponíveis em matchInsensitively e notMatchInsensitively.

Campos

As condições que avaliam se os valores das propriedades na carga útil da solicitação de recurso atendem a determinados critérios podem ser formadas usando uma field expressão. Os seguintes campos são suportados:

• name

• fullName

  • Retorna o nome completo do recurso. O nome completo de um recurso é o nome do recurso precedido por qualquer nome de recurso pai (por exemplo myServer/myDatabase, ).

• kind

• type

• location

  • Os campos de localização são normalizados para suportar vários formatos. Por exemplo, East US 2 é considerado igual a eastus2.
  • Use global para recursos que são agnósticos à localização.

• id

  • Retorna a ID do recurso que está sendo avaliado.
  • Exemplo: /subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myRG/providers/Microsoft.KeyVault/vaults/myVault

• identity.type

  • Retorna o tipo de identidade gerenciada habilitada no recurso.

• tags

• tags['<tagName>']

  • Esta sintaxe entre parênteses suporta nomes de marcas com pontuação, como hífen, ponto ou espaço.
  • Onde tagName é o nome da tag para validar a condição.
  • Exemplos: tags['Acct.CostCenter'] onde Acct.CostCenter é o nome da tag.

• tags['''<tagName>''']

  • Esta sintaxe entre parênteses suporta nomes de etiquetas que têm apóstrofos ao escapar com apóstrofos duplos.
  • Onde tagName é o nome da tag para validar a condição.
  • Exemplo: tags['''My.Apostrophe.Tag'''] onde 'My.Apostrophe.Tag' é o nome da tag.

  Nota

  tags.<tagName>, tags[tagName]e tags[tag.with.dots] ainda são formas aceitáveis de declarar um campo de tags. No entanto, as expressões preferidas são as listadas acima.

• aliases de propriedade - para obter uma lista, consulte Aliases.

  Nota

  Em field expressões referentes ao alias [*] da matriz, cada elemento da matriz é avaliado individualmente com lógica and entre os elementos. Para obter mais informações, consulte Referenciando propriedades de recursos de matriz.

As condições que usam field expressões podem substituir a sintaxe "source": "action"de definição de política herdada , que costumava funcionar para operações de gravação. Por exemplo, isso não é mais suportado:

{
  "source": "action",
  "like": "Microsoft.Network/publicIPAddresses/*"
}

Mas o comportamento desejado pode ser alcançado usando field a lógica:

{
  "field": "type",
  "equals": "Microsoft.Network/publicIPAddresses"
}

Usar tags com parâmetros

Um valor de parâmetro pode ser passado para um campo de tag. Passar um parâmetro para um campo de marca aumenta a flexibilidade da definição de política durante a atribuição de política.

No exemplo a seguir, concat é usado para criar uma pesquisa de campo de tags para a tag chamada o valor do tagName parâmetro. Se essa tag não existir, o modify efeito será usado para adicionar a tag usando o valor da mesma tag nomeada definida no grupo de recursos pai de recursos auditados usando a resourcegroup() função de pesquisa.

{
  "if": {
    "field": "[concat('tags[', parameters('tagName'), ']')]",
    "exists": "false"
  },
  "then": {
    "effect": "modify",
    "details": {
      "operations": [
        {
          "operation": "add",
          "field": "[concat('tags[', parameters('tagName'), ']')]",
          "value": "[resourcegroup().tags[parameters('tagName')]]"
        }
      ],
      "roleDefinitionIds": [
        "/providers/microsoft.authorization/roleDefinitions/4a9ae827-6dc8-4573-8ac7-8239d42aa03f"
      ]
    }
  }
}

Value

As condições que avaliam se um valor atende a determinados critérios podem ser formadas usando uma value expressão. Os valores podem ser literais, os valores de parâmetros ou os valores retornados de quaisquer funções de modelo suportadas.

Aviso

Se o resultado de uma função de modelo for um erro, a avaliação da política falhará. Uma avaliação falhada é implícita deny. Para obter mais informações, consulte Evitando falhas de modelo. Use enforcementMode of doNotEnforce para evitar o impacto de uma avaliação com falha em recursos novos ou atualizados ao testar e validar uma nova definição de política.

Exemplos de valor

Este exemplo de regra de política usa value para comparar o resourceGroup() resultado da função e a propriedade retornada name com uma like condição de *netrg. A regra nega qualquer recurso que não seja do Microsoft.Network/*type em qualquer grupo de recursos cujo nome termine em *netrg.

{
  "if": {
    "allOf": [
      {
        "value": "[resourceGroup().name]",
        "like": "*netrg"
      },
      {
        "field": "type",
        "notLike": "Microsoft.Network/*"
      }
    ]
  },
  "then": {
    "effect": "deny"
  }
}

Este exemplo de regra de política usa value para verificar se o resultado de várias funções equalstrueaninhadas . A regra nega qualquer recurso que não tenha pelo menos três tags.

{
  "mode": "indexed",
  "policyRule": {
    "if": {
      "value": "[less(length(field('tags')), 3)]",
      "equals": "true"
    },
    "then": {
      "effect": "deny"
    }
  }
}

Evitando falhas de modelo

O uso de funções de modelo em value permite muitas funções aninhadas complexas. Se o resultado de uma função de modelo for um erro, a avaliação da política falhará. Uma avaliação falhada é implícita deny. Um exemplo de um value que falha em determinados cenários:

{
  "policyRule": {
    "if": {
      "value": "[substring(field('name'), 0, 3)]",
      "equals": "abc"
    },
    "then": {
      "effect": "audit"
    }
  }
}

A regra de política de exemplo acima usa substring() para comparar os três primeiros caracteres de name com .abc Se name for menor que três caracteres, a substring() função resulta em um erro. Esse erro faz com que a política se torne um deny efeito.

Em vez disso, use a função if() para verificar se os três primeiros caracteres são iguais nameabc sem permitir que um name menor que três caracteres cause um erro:

{
  "policyRule": {
    "if": {
      "value": "[if(greaterOrEquals(length(field('name')), 3), substring(field('name'), 0, 3), 'not starting with abc')]",
      "equals": "abc"
    },
    "then": {
      "effect": "audit"
    }
  }
}

Com a regra de política revisada, if() verifica o comprimento de antes de tentar obter um substring() valor com menos de name três caracteres. Se name for muito curto, o valor "não começando com abc" é retornado em vez disso e comparado a abc. Um recurso com um nome curto que não começa com abc ainda falha na regra de política, mas não causa mais um erro durante a avaliação.

Count

As condições que contam quantos membros de uma matriz atendem a determinados critérios podem ser formadas usando uma count expressão. Os cenários comuns são verificar se "pelo menos um dos", "exatamente um dos", "todos os" ou "nenhum dos" membros da matriz satisfazem uma condição. O count avalia cada membro da matriz para uma expressão de condição e soma os resultados verdadeiros , que são então comparados com o operador de expressão.

Contagem de campos

Conte quantos membros de uma matriz na carga útil da solicitação satisfazem uma expressão de condição. A estrutura das field count expressões é:

{
  "count": {
    "field": "<[*] alias>",
    "where": {
      /* condition expression */
    }
  },
  "<condition>": "<compare the count of true condition expression array members to this value>"
}

As seguintes propriedades são usadas com field count:

• count.field (obrigatório): contém o caminho para a matriz e deve ser um alias de matriz.
• count.where (opcional): A expressão de condição a ser avaliada individualmente para cada membro da matriz alias do count.field. Se essa propriedade não for fornecida, todos os membros da matriz com o caminho de 'campo' serão avaliados como true. Qualquer condição pode ser usada dentro desta propriedade. Os operadores lógicos podem ser usados dentro dessa propriedade para criar requisitos de avaliação complexos.
• condition (obrigatório): O valor é comparado ao número de itens que atenderam à expressão de count.where condição. Deve ser utilizada uma condição numérica.

Para obter mais detalhes sobre como trabalhar com propriedades de matriz na Política do Azure, incluindo explicação detalhada sobre como a field count expressão é avaliada, consulte Fazendo referência a propriedades de recursos de matriz.

Contagem de valores

Conte quantos membros de uma matriz satisfazem uma condição. A matriz pode ser uma matriz literal ou uma referência ao parâmetro da matriz. A estrutura das value count expressões é:

{
  "count": {
    "value": "<literal array | array parameter reference>",
    "name": "<index name>",
    "where": {
      /* condition expression */
    }
  },
  "<condition>": "<compare the count of true condition expression array members to this value>"
}

As seguintes propriedades são usadas com value count:

• count.value (obrigatório): A matriz a ser avaliada.
• count.name (obrigatório): O nome do índice, composto por letras e dígitos em inglês. Define um nome para o valor do membro da matriz avaliado na iteração atual. O nome é usado para referenciar o valor atual dentro da count.where condição. Opcional quando a count expressão não está em um filho de outra count expressão. Quando não fornecido, o nome do índice é implicitamente definido como "default".
• count.where (opcional): A expressão de condição a ser avaliada individualmente para cada membro da matriz do count.value. Se essa propriedade não for fornecida, todos os membros da matriz serão avaliados como true. Qualquer condição pode ser usada dentro desta propriedade. Os operadores lógicos podem ser usados dentro dessa propriedade para criar requisitos de avaliação complexos. O valor do membro da matriz atualmente enumerado pode ser acessado chamando a função atual .
• condition (obrigatório): O valor é comparado ao número de itens que atenderam à expressão de count.where condição. Deve ser utilizada uma condição numérica.

A função atual

A current() função só está disponível dentro da count.where condição. Ele retorna o valor do membro da matriz que está atualmente enumerado count pela expressão evaluation.

Uso da contagem de valores

• current(<index name defined in count.name>). Por exemplo: current('arrayMember').
• current(). Permitido apenas quando a value count expressão não é filha de outra count expressão. Devolve o mesmo valor que acima.

Se o valor retornado pela chamada for um objeto, os acessadores de propriedade serão suportados. Por exemplo: current('objectArrayMember').property.

Uso da contagem de campos

• current(<the array alias defined in count.field>). Por exemplo, current('Microsoft.Test/resource/enumeratedArray[*]').
• current(). Permitido apenas quando a field count expressão não é filha de outra count expressão. Devolve o mesmo valor que acima.
• current(<alias of a property of the array member>). Por exemplo, current('Microsoft.Test/resource/enumeratedArray[*].property').

Exemplos de contagem de campos

Exemplo 1: Verificar se uma matriz está vazia

{
  "count": {
    "field": "Microsoft.Network/networkSecurityGroups/securityRules[*]"
  },
  "equals": 0
}

Exemplo 2: Verifique se apenas um membro da matriz atende à expressão de condição

{
  "count": {
    "field": "Microsoft.Network/networkSecurityGroups/securityRules[*]",
    "where": {
      "field": "Microsoft.Network/networkSecurityGroups/securityRules[*].description",
      "equals": "My unique description"
    }
  },
  "equals": 1
}

Exemplo 3: Verifique se pelo menos um membro da matriz atende à expressão de condição

{
  "count": {
    "field": "Microsoft.Network/networkSecurityGroups/securityRules[*]",
    "where": {
      "field": "Microsoft.Network/networkSecurityGroups/securityRules[*].description",
      "equals": "My common description"
    }
  },
  "greaterOrEquals": 1
}

Exemplo 4: Verifique se todos os membros da matriz de objetos atendem à expressão de condição

{
  "count": {
    "field": "Microsoft.Network/networkSecurityGroups/securityRules[*]",
    "where": {
      "field": "Microsoft.Network/networkSecurityGroups/securityRules[*].description",
      "equals": "description"
    }
  },
  "equals": "[length(field('Microsoft.Network/networkSecurityGroups/securityRules[*]'))]"
}

Exemplo 5: Verifique se pelo menos um membro da matriz corresponde a várias propriedades na expressão de condição

{
  "count": {
    "field": "Microsoft.Network/networkSecurityGroups/securityRules[*]",
    "where": {
      "allOf": [
        {
          "field": "Microsoft.Network/networkSecurityGroups/securityRules[*].direction",
          "equals": "Inbound"
        },
        {
          "field": "Microsoft.Network/networkSecurityGroups/securityRules[*].access",
          "equals": "Allow"
        },
        {
          "field": "Microsoft.Network/networkSecurityGroups/securityRules[*].destinationPortRange",
          "equals": "3389"
        }
      ]
    }
  },
  "greater": 0
}

Exemplo 6: Use current() a função dentro das where condições para acessar o valor do membro da matriz atualmente enumerado em uma função de modelo. Esta condição verifica se uma rede virtual contém um prefixo de endereço que não esteja no intervalo CIDR 10.0.0.0/24.

{
  "count": {
    "field": "Microsoft.Network/virtualNetworks/addressSpace.addressPrefixes[*]",
    "where": {
      "value": "[ipRangeContains('10.0.0.0/24', current('Microsoft.Network/virtualNetworks/addressSpace.addressPrefixes[*]'))]",
      "equals": false
    }
  },
  "greater": 0
}

Exemplo 7: Use field() a função dentro das where condições para acessar o valor do membro da matriz atualmente enumerado. Esta condição verifica se uma rede virtual contém um prefixo de endereço que não esteja no intervalo CIDR 10.0.0.0/24.

{
  "count": {
    "field": "Microsoft.Network/virtualNetworks/addressSpace.addressPrefixes[*]",
    "where": {
      "value": "[ipRangeContains('10.0.0.0/24', first(field(('Microsoft.Network/virtualNetworks/addressSpace.addressPrefixes[*]')))]",
      "equals": false
    }
  },
  "greater": 0
}

Exemplos de contagem de valores

Exemplo 1: Verifique se o nome do recurso corresponde a algum dos padrões de nome fornecidos.

{
  "count": {
    "value": [
      "prefix1_*",
      "prefix2_*"
    ],
    "name": "pattern",
    "where": {
      "field": "name",
      "like": "[current('pattern')]"
    }
  },
  "greater": 0
}

Exemplo 2: Verifique se o nome do recurso corresponde a algum dos padrões de nome fornecidos. A current() função não especifica um nome de índice. O resultado é o mesmo do exemplo anterior.

{
  "count": {
    "value": [
      "prefix1_*",
      "prefix2_*"
    ],
    "where": {
      "field": "name",
      "like": "[current()]"
    }
  },
  "greater": 0
}

Exemplo 3: Verifique se o nome do recurso corresponde a algum dos padrões de nome fornecidos por um parâmetro de matriz.

{
  "count": {
    "value": "[parameters('namePatterns')]",
    "name": "pattern",
    "where": {
      "field": "name",
      "like": "[current('pattern')]"
    }
  },
  "greater": 0
}

Exemplo 4: Verifique se algum dos prefixos de endereço de rede virtual não está na lista de prefixos aprovados.

{
  "count": {
    "field": "Microsoft.Network/virtualNetworks/addressSpace.addressPrefixes[*]",
    "where": {
      "count": {
        "value": "[parameters('approvedPrefixes')]",
        "name": "approvedPrefix",
        "where": {
          "value": "[ipRangeContains(current('approvedPrefix'), current('Microsoft.Network/virtualNetworks/addressSpace.addressPrefixes[*]'))]",
          "equals": true
        },
      },
      "equals": 0
    }
  },
  "greater": 0
}

Exemplo 5: Verifique se todas as regras NSG reservadas estão definidas em um NSG. As propriedades das regras NSG reservadas são definidas em um parâmetro de matriz contendo objetos.

Valor do parâmetro:

[
  {
    "priority": 101,
    "access": "deny",
    "direction": "inbound",
    "destinationPortRange": 22
  },
  {
    "priority": 102,
    "access": "deny",
    "direction": "inbound",
    "destinationPortRange": 3389
  }
]

Política:

{
  "count": {
    "value": "[parameters('reservedNsgRules')]",
    "name": "reservedNsgRule",
    "where": {
      "count": {
        "field": "Microsoft.Network/networkSecurityGroups/securityRules[*]",
        "where": {
          "allOf": [
            {
              "field": "Microsoft.Network/networkSecurityGroups/securityRules[*].priority",
              "equals": "[current('reservedNsgRule').priority]"
            },
            {
              "field": "Microsoft.Network/networkSecurityGroups/securityRules[*].access",
              "equals": "[current('reservedNsgRule').access]"
            },
            {
              "field": "Microsoft.Network/networkSecurityGroups/securityRules[*].direction",
              "equals": "[current('reservedNsgRule').direction]"
            },
            {
              "field": "Microsoft.Network/networkSecurityGroups/securityRules[*].destinationPortRange",
              "equals": "[current('reservedNsgRule').destinationPortRange]"
            }
          ]
        }
      },
      "equals": 1
    }
  },
  "equals": "[length(parameters('reservedNsgRules'))]"
}

Funções de política

As funções podem ser usadas para introduzir lógica adicional em uma regra de política. Eles são resolvidos dentro da regra de política de uma definição de política e dentro de valores de parâmetros atribuídos às definições de política em uma iniciativa.

Todas as funções de modelo do Resource Manager estão disponíveis para uso dentro de uma regra de política, exceto as seguintes funções e funções definidas pelo usuário:

• copyIndex()
• dateTimeAdd()
• dateTimeFromEpoch
• dateTimeToEpoch
• deployment()
• environment()
• extensionResourceId()
• lambda() Para obter mais informações, vá para lambda
• listAccountSas()
• listKeys()
• listSecrets()
• list*
• managementGroup()
• newGuid()
• pickZones()
• providers()
• reference()
• resourceId()
• subscriptionResourceId()
• tenantResourceId()
• tenant()
• variables()

Nota

Essas funções ainda estão disponíveis na details.deployment.properties.template parte da implantação do modelo em uma deployIfNotExists definição de política.

A função a seguir está disponível para uso em uma regra de política, mas difere do uso em um modelo do Azure Resource Manager (modelo ARM):

• utcNow() - Ao contrário de um modelo ARM, esta propriedade pode ser usada fora defaultValue.
  • Retorna uma cadeia de caracteres definida para a data e hora atuais no formato yyyy-MM-ddTHH:mm:ss.fffffffZUniversal ISO 8601 DateTime.

As seguintes funções só estão disponíveis em regras de política:

• addDays(dateTime, numberOfDaysToAdd)

  • dateTime: [Obrigatório] string - String no formato Universal ISO 8601 DateTime 'aaaa-MM-ddTHH:mm:ss. FFFFFFFZ»
  • numberOfDaysToAdd: [Obrigatório] inteiro - Número de dias para adicionar

• field(fieldName)

  • fieldName: [Obrigatório] string - Nome do campo a ser recuperado
  • Retorna o valor desse campo do recurso que está sendo avaliado pela condição If.
  • field é usado principalmente com auditIfNotExists e deployIfNotExists para referenciar campos no recurso que estão sendo avaliados. Um exemplo desse uso pode ser visto no exemplo DeployIfNotExists.

• requestContext().apiVersion

  • Retorna a versão da API da solicitação que disparou a avaliação da política (exemplo: 2021-09-01). Esse valor é a versão da API que foi usada na solicitação PUT/PATCH para avaliações na criação/atualização de recursos. A versão mais recente da API é sempre usada durante a avaliação de conformidade nos recursos existentes.

• policy()

  • Retorna as seguintes informações sobre a política que está sendo avaliada. As propriedades podem ser acessadas a partir do objeto retornado (exemplo: [policy().assignmentId]).

    {
      "assignmentId": "/subscriptions/11111111-1111-1111-1111-111111111111/providers/Microsoft.Authorization/policyAssignments/myAssignment",
      "definitionId": "/providers/Microsoft.Authorization/policyDefinitions/34c877ad-507e-4c82-993e-3452a6e0ad3c",
      "setDefinitionId": "/providers/Microsoft.Authorization/policySetDefinitions/42a694ed-f65e-42b2-aa9e-8052e9740a92",
      "definitionReferenceId": "StorageAccountNetworkACLs"
    }
    

• ipRangeContains(range, targetRange)

  • range: [Required] string - String especificando um intervalo de endereços IP para verificar se o targetRange está dentro.
  • targetRange: [Obrigatório] string - String especificando um intervalo de endereços IP para validar como incluído dentro do intervalo.
  • Retorna um booleano para saber se o intervalo de endereços IP do intervalo contém o intervalo de endereços IP targetRange . Intervalos vazios ou mistura entre famílias IP não são permitidos e resultam em falha na avaliação.

  Formatos suportados:

  • Endereço IP único (exemplos: 10.0.0.0, 2001:0DB8::3:FFFE)
  • Gama CIDR (exemplos: 10.0.0.0/24, 2001:0DB8::/110)
  • Intervalo definido por endereços IP iniciais e finais (exemplos: 192.168.0.1-192.168.0.9, 2001:0DB8::-2001:0DB8::3:FFFF)

• current(indexName)

  • Função especial que só pode ser usada dentro de expressões de contagem.

Exemplo de função de política

Este exemplo de regra de política usa a resourceGroup função resource para obter a name propriedade, combinada com a concat função array e object para criar uma like condição que impõe o nome do recurso para começar com o nome do grupo de recursos.

{
  "if": {
    "not": {
      "field": "name",
      "like": "[concat(resourceGroup().name,'*')]"
    }
  },
  "then": {
    "effect": "deny"
  }
}

Limites de regras de política

Limites impostos durante a criação

Os limites à estrutura das regras de política são impostos durante a criação ou atribuição de uma política. As tentativas de criar ou atribuir definições de política que excedam estes limites irão falhar.

Limite	Value	Detalhes adicionais
Expressões de if condição na condição	4096
Expressões de condição no then bloco	128	Aplica-se ao existenceCondition de auditIfNotExists e deployIfNotExists políticas
Funções de política por regra de política	2048
Número de parâmetros da função de política	128	Exemplo: [function('parameter1', 'parameter2', ...)]
Profundidade das funções de política aninhadas	64	Exemplo: [function(nested1(nested2(...)))]
Comprimento da cadeia da expressão das funções de política	81920	Exemplo: o comprimento de "[function(....)]"
Field count expressões por matriz	5
Value count expressões por regra de política	10
Value count contagem de iteração de expressão	100	Para expressões aninhadas Value count , isso também inclui a contagem de iteração da expressão pai

Limites impostos durante a avaliação

Limites ao tamanho dos objetos que são processados por funções de política durante a avaliação das políticas. Estes limites nem sempre podem ser impostos durante a criação porque dependem do conteúdo avaliado. Por exemplo:

{
  "field": "name",
  "equals": "[concat(field('stringPropertyA'), field('stringPropertyB'))]"
}

O comprimento da cadeia de caracteres criada pela concat() função depende do valor das propriedades no recurso avaliado.

Limite	valor	Exemplo
Comprimento da cadeia devolvida por uma função	131072	[concat(field('longString1'), field('longString2'))]
Profundidade dos objetos complexos fornecidos como parâmetro a uma função ou devolvido por uma função	128	[union(field('largeObject1'), field('largeObject2'))]
Número de nós dos objetos complexos fornecidos como parâmetro a uma função ou devolvido por uma função	32768	[concat(field('largeArray1'), field('largeArray2'))]

Aviso

A política que exceder os limites acima durante a avaliação se tornará efetivamente uma deny política e poderá bloquear solicitações recebidas. Quando escrever políticas com funções complexas, esteja atento a estes limites e teste as suas políticas em recursos que tenham o potencial de os exceder.

Próximos passos

• Para obter mais informações sobre a estrutura de definição de política, vá para noções básicas, parâmetros e alias.
• Para iniciativas, vá para a estrutura de definição da iniciativa.
• Analise exemplos em Exemplos de Política do Azure.
• Veja Compreender os efeitos do Policy.
• Entenda como criar políticas de forma programática.
• Saiba como obter dados de conformidade.
• Saiba como corrigir recursos não compatíveis.
• Analise o que é um grupo de gerenciamento com Organize seus recursos com grupos de gerenciamento do Azure.