Criar políticas para propriedades de matriz em recursos do Azure

  • Artigo

As propriedades do Azure Resource Manager são normalmente definidas como cadeias de caracteres e boolianos. Quando existe uma relação um-para-muitos, as propriedades complexas são definidas como matrizes. No Azure Policy, as matrizes são usadas de várias maneiras diferentes:

Este artigo aborda cada uso pelo Azure Policy e fornece várias definições de exemplo.

Matrizes de parâmetros

Definir uma matriz de parâmetros

A definição de um parâmetro como uma matriz permite a flexibilidade da política quando mais de um valor é necessário. Essa definição de política permite qualquer local único para o parâmetro allowedLocations e usa eastus2 como padrão:

"parameters": {
    "allowedLocations": {
        "type": "string",
        "metadata": {
            "description": "The list of allowed locations for resources.",
            "displayName": "Allowed locations",
            "strongType": "location"
        },
        "defaultValue": "eastus2"
    }
}

Como type era string, apenas um valor pode ser definido ao atribuir a política. Se essa política for atribuída, os recursos no escopo só serão permitidos em uma região do Azure. A maioria das definições de política precisa permitir uma lista de opções aprovadas, como permitir eastus2, eastus e westus2.

Para criar a definição de política a fim de permitir várias opções, use o tipomatriz. A mesma política pode ser reescrita da seguinte maneira:

"parameters": {
    "allowedLocations": {
        "type": "array",
        "metadata": {
            "description": "The list of allowed locations for resources.",
            "displayName": "Allowed locations",
            "strongType": "location"
        },
        "defaultValue": [
            "eastus2"
        ],
        "allowedValues": [
            "eastus2",
            "eastus",
            "westus2"
        ]

    }
}

Observação

Quando uma definição de política é salva, a propriedade type em um parâmetro não pode ser alterada.

Essa nova definição de parâmetro usa mais de um valor durante a atribuição de política. Com a propriedade de matriz allowedValues definida, os valores disponíveis durante a atribuição são limitados ainda mais à lista predefinida de opções. O uso de allowedValues é opcional.

Passar valores para uma matriz de parâmetros durante a atribuição

Ao atribuir a política por meio do portal do Azure, um parâmetro do tipomatriz é exibido como uma caixa de texto. A dica diz "Use ; para separar valores. (por exemplo, Londres; Nova York)". Para passar os valores de local permitidos de eastus2, eastus e westus2 para o parâmetro, use a seguinte cadeia de caracteres:

eastus2;eastus;westus2

O formato do valor do parâmetro é diferente ao usar CLI do Azure, o Azure PowerShell ou a API REST. Os valores são passados por meio de uma cadeia de caracteres JSON que também inclui o nome do parâmetro.

{
    "allowedLocations": {
        "value": [
            "eastus2",
            "eastus",
            "westus2"
        ]
    }
}

Para usar essa cadeia de caracteres com cada SDK, use os seguintes comandos:

  • CLI do Azure: Comando az policy assignment create com o parâmetro params
  • Azure PowerShell: Cmdlet New-AzPolicyAssignment com o parâmetro PolicyParameter
  • API REST: na operação PUTcreate enquanto parte do corpo da solicitação, como o valor da propriedade properties.parameters

Usando matrizes em condições

In e notIn

As condições in e notIn só funcionam com valores de matriz. Elas verificam a existência de um valor em uma matriz. A matriz em questão pode ser uma matriz JSON literal ou uma referência a um parâmetro de matriz. Por exemplo:

{
      "field": "tags.environment",
      "in": [ "dev", "test" ]
}

{
      "field": "location",
      "notIn": "[parameters('allowedLocations')]"
}

Contagem de valor

A expressão contagem de valor conta quantos membros da matriz atendem a uma condição. Ela fornece uma maneira de avaliar a mesma condição várias vezes, usando valores diferentes em cada iteração. Por exemplo, a condição a seguir verifica se o nome do recurso corresponde a qualquer padrão de uma matriz de padrões:

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

Para avaliar a expressão, a Azure Policy avalia a condição where três vezes, uma para cada membro de [ "test*", "dev*", "prod*" ], contando quantas vezes ela foi avaliada como true. Em cada iteração, o valor do membro da matriz atual é emparelhado com o nome do índice pattern definido por count.name. Esse valor pode então ser referenciado dentro da condiçãowhere chamando uma função de modelo especial: current('pattern').

Iteração current('pattern') returned value
1 "test*"
2 "dev*"
3 "prod*"

A condição será verdadeira somente se a contagem resultante for maior que 0.

Para tornar a condição acima mais genérica, use a referência de parâmetro em vez de uma matriz literal:

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

Quando a expressão de contagem de valor não está sob nenhuma outra expressão de contagem, count.name é opcional e a função current() pode ser usada sem argumentos:

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

A contagem de valor também oferece suporte a matrizes de objetos complexos, permitindo condições mais complexas. Por exemplo, a condição a seguir define um valor de marca desejado para cada padrão de nome e verifica se o nome do recurso corresponde ao padrão, mas não tem o valor de marca necessário:

{
    "count": {
        "value": [
            { "pattern": "test*", "envTag": "dev" },
            { "pattern": "dev*", "envTag": "dev" },
            { "pattern": "prod*", "envTag": "prod" },
        ],
        "name": "namePatternRequiredTag",
        "where": {
            "allOf": [
                {
                    "field": "name",
                    "like": "[current('namePatternRequiredTag').pattern]"
                },
                {
                    "field": "tags.env",
                    "notEquals": "[current('namePatternRequiredTag').envTag]"
                }
            ]
        }
    },
    "greater": 0
}

Para obter exemplos úteis, consulte exemplos de contagem de valor.

Referenciando propriedades de recurso de matriz

Em muitos casos, é necessário trabalhar com propriedades de matriz no recurso avaliado. Alguns cenários exigem referenciar uma matriz inteira (por exemplo, verificando seu comprimento). Outros exigem a aplicação de uma condição a cada membro de matriz individual (por exemplo, verificar se todas as regras de firewall bloqueiam acesso a partir da Internet). Entender as diferentes maneiras em que o Azure Policy pode referenciar propriedades de recurso e como essas referências se comportam quando se referem a propriedades de matriz é a chave para escrever condições que abrangem esses cenários.

Referenciando propriedades de recurso

As propriedades de recurso podem ser referenciadas com o Azure Policy usando aliases. Há duas maneiras de referenciar os valores de uma propriedade de recurso no Azure Policy:

  • Use a condição campo para verificar se todas as propriedades de recurso selecionadas atendem a uma condição. Exemplo:

    {
  "field" : "Microsoft.Test/resourceType/property",
  "equals": "value"
}

  • Use a funçãofield() para acessar o valor de uma propriedade. Exemplo:

    {
  "value": "[take(field('Microsoft.Test/resourceType/property'), 7)]",
  "equals": "prefix_"
}

A condição de campo tem um comportamento implícito de "todos". Se o alias representar uma coleção de valores, ela verificará se todos os valores individuais atendem à condição. A função field() retorna os valores representados pelo alias no estado em que se encontram, e estes podem ser manipulados por outras funções de modelo.

Referenciando campos de matriz

As propriedades de recurso de matriz são representadas por dois tipos diferentes de aliases. Um alias “normal” e aliases de matriz que têm [*] anexado:

  • Microsoft.Test/resourceType/stringArray
  • Microsoft.Test/resourceType/stringArray[*]

Referenciando a matriz

O primeiro alias representa um único valor, o valor da propriedade stringArray do conteúdo da solicitação. Como o valor dessa propriedade é uma matriz, ela não é útil em condições de política. Por exemplo:

{
  "field": "Microsoft.Test/resourceType/stringArray",
  "equals": "..."
}

Essa condição compara toda a matriz stringArray a um único valor de cadeia de caracteres. A maioria das condições, incluindo equals, aceita apenas valores de cadeia de caracteres. Portanto, não há muita utilidade em comparar uma matriz a uma cadeia de caracteres. O cenário principal em que pode ser útil referenciar a propriedade de matriz é quando se verifica se ela existe:

{
  "field": "Microsoft.Test/resourceType/stringArray",
  "exists": "true"
}

Com a função field(), o valor retornado é a matriz do conteúdo da solicitação, que pode ser usada com qualquer uma das funções de modelo com suporte que aceitam argumentos de matriz. Por exemplo, a condição a seguir verifica se o comprimento do stringArray é maior que 0:

{
  "value": "[length(field('Microsoft.Test/resourceType/stringArray'))]",
  "greater": 0
}

Referenciando a coleção de membros da matriz

Os aliases que usam a sintaxe [*] representam uma coleção de valores de propriedade selecionados de uma propriedade de matriz, o que é diferente de selecionar a própria propriedade da matriz. No caso do Microsoft.Test/resourceType/stringArray[*], ele retorna uma coleção que tem todos os membros do stringArray. Como mencionado anteriormente, uma condição field verifica se todas as propriedades de recurso selecionadas atendem à condição. Portanto, a condição a seguir será verdadeira somente se todos os membros de stringArray forem iguais a "valor".

{
  "field": "Microsoft.Test/resourceType/stringArray[*]",
  "equals": "value"
}

Se a matriz estiver vazia, a condição será avaliada como true porque nenhum membro da matriz está em violação. Nesse cenário, é recomendável usar a expressão de contagem. Se a matriz contiver objetos, poderá ser usado um alias [*] para selecionar o valor de uma propriedade específica a partir de cada membro da matriz. Exemplo:

{
  "field": "Microsoft.Test/resourceType/objectArray[*].property",
  "equals": "value"
}

Essa condição será verdadeira se os valores de todas as propriedades property no objectArray forem iguais a "value". Para obter mais exemplos, confira Exemplos de aliases adicionais [*].

Ao usar a função field() para fazer referência a um alias de matriz, o valor retornado é uma matriz de todos os valores selecionados. Esse comportamento implica que o caso de uso comum da função field(), a capacidade de aplicar funções de modelo aos valores de propriedade de recurso, é limitado. As únicas funções de modelo que podem ser usadas neste caso são aquelas que aceitam argumentos de matriz. Por exemplo, é possível obter o comprimento da matriz com [length(field('Microsoft.Test/resourceType/objectArray[*].property'))]. No entanto, cenários mais complexos, como aplicar a função de modelo a cada membro da matriz e compará-lo a um valor desejado só são possíveis usando a expressão count. Para obter mais informações, consulte Expressão de contagem de campo.

Resumidamente, consulte o seguinte conteúdo de recurso de exemplo e os valores selecionados retornados por vários aliases:

{
  "tags": {
    "env": "prod"
  },
  "properties":
  {
    "stringArray": [ "a", "b", "c" ],
    "objectArray": [
      {
        "property": "value1",
        "nestedArray": [ 1, 2 ]
      },
      {
        "property": "value2",
        "nestedArray": [ 3, 4 ]
      }
    ]
  }
}

Ao usar a condição de campo no conteúdo do recurso de exemplo, os resultados são os seguintes:

Alias Valores selecionados
Microsoft.Test/resourceType/missingArray null
Microsoft.Test/resourceType/missingArray[*] Uma coleção vazia de valores.
Microsoft.Test/resourceType/missingArray[*].property Uma coleção vazia de valores.
Microsoft.Test/resourceType/stringArray ["a", "b", "c"]
Microsoft.Test/resourceType/stringArray[*] "a", "b", "c"
Microsoft.Test/resourceType/objectArray[*] { "property": "value1", "nestedArray": [ 1, 2 ] },
{ "property": "value2", "nestedArray": [ 3, 4 ] }
Microsoft.Test/resourceType/objectArray[*].property "value1", "value2"
Microsoft.Test/resourceType/objectArray[*].nestedArray [ 1, 2 ], [ 3, 4 ]
Microsoft.Test/resourceType/objectArray[*].nestedArray[*] 1, 2, 3, 4

Ao usar a condição field() no conteúdo do recurso de exemplo, os resultados são os seguintes:

Expression Valor retornado
[field('Microsoft.Test/resourceType/missingArray')] ""
[field('Microsoft.Test/resourceType/missingArray[*]')] []
[field('Microsoft.Test/resourceType/missingArray[*].property')] []
[field('Microsoft.Test/resourceType/stringArray')] ["a", "b", "c"]
[field('Microsoft.Test/resourceType/stringArray[*]')] ["a", "b", "c"]
[field('Microsoft.Test/resourceType/objectArray[*]')] [{ "property": "value1", "nestedArray": [ 1, 2 ] }, { "property": "value2", "nestedArray": [ 3, 4 ] }]
[field('Microsoft.Test/resourceType/objectArray[*].property')] ["value1", "value2"]
[field('Microsoft.Test/resourceType/objectArray[*].nestedArray')] [[ 1, 2 ], [ 3, 4 ]]
[field('Microsoft.Test/resourceType/objectArray[*].nestedArray[*]')] [1, 2, 3, 4]

Expressões de contagem de campos

As expressões de contagem de campos contam quantos membros da matriz atendem a uma condição e comparam a contagem com um valor de destino. Count é mais intuitivo e versátil para avaliar matrizes em comparação com condições field. A sintaxe do é:

{
  "count": {
    "field": <[*] alias>,
    "where": <optional policy condition expression>
  },
  "equals|greater|less|any other operator": <target value>
}

Quando usado sem uma condição where, count apenas retorna o comprimento de uma matriz. Para o conteúdo do recurso de exemplo da seção anterior, a expressão count a seguir é avaliada como true, pois stringArray tem três membros:

{
  "count": {
    "field": "Microsoft.Test/resourceType/stringArray[*]"
  },
  "equals": 3
}

Esse comportamento também ocorre com matrizes aninhadas. Por exemplo, a expressão count a seguir é avaliada como true, pois há quatro membros de matriz nas matrizesnestedArray:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*].nestedArray[*]"
  },
  "greaterOrEquals": 4
}

O poder do count está na condição where. Quando especificado, o Azure Policy enumera os membros da matriz e avalia cada um em relação à condição, contando quantos membros da matriz foram avaliados como true. Especificamente, em cada iteração de avaliação da condição where, o Azure Policy seleciona um único membro de matriz i e avalia o conteúdo do recurso em relação à condição wherecomo se i fosse o único membro da matriz. Ter apenas um membro de matriz disponível em cada iteração possibilita uma maneira de aplicar condições complexas em cada membro de matriz individual.

Exemplo:

{
  "count": {
    "field": "Microsoft.Test/resourceType/stringArray[*]",
    "where": {
      "field": "Microsoft.Test/resourceType/stringArray[*]",
      "equals": "a"
    }
  },
  "equals": 1
}

Para avaliar a expressão count, a Azure Policy avalia a condição where três vezes, uma para cada membro do stringArray, e conta quantas vezes ela foi avaliada como true. Quando a condição where se refere aos membros da matriz Microsoft.Test/resourceType/stringArray[*], em vez de selecionar todos os membros do stringArray, ela sempre selecionará apenas um único membro de matriz, todas as vezes:

Iteração Valores selecionados em Microsoft.Test/resourceType/stringArray[*] Resultado da avaliação de where
1 "a" true
2 "b" false
3 "c" false

O count retorna 1.

Esta é uma expressão mais complexa:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
      "allOf": [
        {
          "field": "Microsoft.Test/resourceType/objectArray[*].property",
          "equals": "value2"
        },
        {
          "field": "Microsoft.Test/resourceType/objectArray[*].nestedArray[*]",
          "greater": 2
        }
      ]
    }
  },
  "equals": 1
}
Iteração Valores selecionados Resultado da avaliação where
1 Microsoft.Test/resourceType/objectArray[*].property =>"value1"
Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>1, 2		 false
2 Microsoft.Test/resourceType/objectArray[*].property =>"value2"
Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>3, 4		 true

O count retorna 1.

O fato de a expressão where ser avaliada em relação ao conteúdo inteiroda solicitação (com alterações apenas no membro da matriz que está sendo enumerado no momento) significa que a condição where também pode se referir a campos fora da matriz:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
      "field": "tags.env",
      "equals": "prod"
    }
  },
  "equals": 0
}
Iteração Valores selecionados Resultado da avaliação where
1 tags.env =>"prod" true
2 tags.env =>"prod" true

Podem ser usadas expressões de contagem aninhadas para aplicar condições a campos de matriz aninhada. Por exemplo, a condição a seguir verifica se a matrizobjectArray[*] tem exatamente dois membros com nestedArray[*] que contém um ou mais membros:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
      "count": {
        "field": "Microsoft.Test/resourceType/objectArray[*].nestedArray[*]"
      },
      "greaterOrEquals": 1
    }
  },
  "equals": 2
}
Iteração Valores selecionados Resultado da avaliação de contagem aninhada
1 Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>1, 2 nestedArray[*] tem dois membros =>true
2 Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>3, 4 nestedArray[*] tem dois membros =>true

Como ambos os membros de objectArray[*] têm uma matriz filho nestedArray[*] com dois membros, a expressão de contagem externa retorna 2.

Exemplo mais complexo: verifique se a matriz objectArray[*] tem exatamente dois membros nestedArray[*] com todos os membros iguais a 2 ou 3:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
      "count": {
        "field": "Microsoft.Test/resourceType/objectArray[*].nestedArray[*]",
        "where": {
            "field": "Microsoft.Test/resourceType/objectArray[*].nestedArray[*]",
            "in": [ 2, 3 ]
        }
      },
      "greaterOrEquals": 1
    }
  },
  "equals": 2
}
Iteração Valores selecionados Resultado da avaliação de contagem aninhada
1 Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>1, 2 nestedArray[*] contém 2 =>true
2 Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>3, 4 nestedArray[*] contém 3 =>true

Como ambos os membros de objectArray[*] têm uma matriz filho nestedArray[*] que contém 2 ou 3, a expressão de contagem externa retorna 2.

Observação

Expressões de contagem de campos aninhadas só podem fazer referência a matrizes aninhadas. Por exemplo, a expressão de contagem que faz referência a Microsoft.Test/resourceType/objectArray[*] pode ter uma contagem aninhada direcionada para a matriz aninhada Microsoft.Test/resourceType/objectArray[*].nestedArray[*], mas não pode ter um direcionamento de expressão de contagem aninhada Microsoft.Test/resourceType/stringArray[*].

Acessando o membro da matriz atual com funções de modelo

Ao usar funções de modelo, use a função current() para acessar o valor do membro da matriz atual ou os valores de qualquer uma de suas propriedades. Para acessar o valor do membro da matriz atual, passe o alias definido em count.field ou qualquer um de seus aliases filho como um argumento para a função current(). Por exemplo:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
        "value": "[current('Microsoft.Test/resourceType/objectArray[*].property')]",
        "like": "value*"
    }
  },
  "equals": 2
}
Iteração current() valor retornado Resultado da avaliação where
1 Valor de property no primeiro membro de objectArray[*]: value1 true
2 Valor de property no primeiro membro de objectArray[*]: value2 true

A função de campo interna onde as condições

A função field() também pode ser usada para acessar o valor do membro da matriz atual, desde que a expressão de contagem não esteja dentro de uma condição de existência (a função field() sempre se refere ao recurso avaliado na condição If). O comportamento de field() ao fazer referência à matriz avaliada baseia-se nos seguintes conceitos:

  1. Aliases de matriz são resolvidos em uma coleção de valores selecionados a partir de todos os membros da matriz.
  2. As funções field() que referenciam aliases de matriz retornam uma matriz com os valores selecionados.
  3. Referenciar o alias de matriz contado dentro da condição where retorna uma coleção com um único valor selecionado do membro da matriz que é avaliado na iteração atual.

Esse comportamento significa que, ao fazer referência ao membro da matriz contado com uma função field() dentro da condição where, ele retorna uma matriz com um único membro. Embora esse comportamento não pareça intuitivo, ele está consistente com a ideia de que os aliases de matriz sempre retornam uma coleção de propriedades selecionadas. Veja um exemplo:

{
  "count": {
    "field": "Microsoft.Test/resourceType/stringArray[*]",
    "where": {
      "field": "Microsoft.Test/resourceType/stringArray[*]",
      "equals": "[field('Microsoft.Test/resourceType/stringArray[*]')]"
    }
  },
  "equals": 0
}
Iteração Valores de expressão Resultado da avaliação where
1 Microsoft.Test/resourceType/stringArray[*] =>"a"
[field('Microsoft.Test/resourceType/stringArray[*]')] =>[ "a" ]		 false
2 Microsoft.Test/resourceType/stringArray[*] =>"b"
[field('Microsoft.Test/resourceType/stringArray[*]')] =>[ "b" ]		 false
3 Microsoft.Test/resourceType/stringArray[*] =>"c"
[field('Microsoft.Test/resourceType/stringArray[*]')] =>[ "c" ]		 false

Portanto, quando há a necessidade de acessar o valor do alias da matriz contada com uma função field(), a maneira de fazer isso é encapsulá-la com uma função de modelo first():

{
  "count": {
    "field": "Microsoft.Test/resourceType/stringArray[*]",
    "where": {
      "field": "Microsoft.Test/resourceType/stringArray[*]",
      "equals": "[first(field('Microsoft.Test/resourceType/stringArray[*]'))]"
    }
  }
}
Iteração Valores de expressão Resultado da avaliação where
1 Microsoft.Test/resourceType/stringArray[*] =>"a"
[first(field('Microsoft.Test/resourceType/stringArray[*]'))] =>"a"		 true
2 Microsoft.Test/resourceType/stringArray[*] =>"b"
[first(field('Microsoft.Test/resourceType/stringArray[*]'))] =>"b"		 true
3 Microsoft.Test/resourceType/stringArray[*] =>"c"
[first(field('Microsoft.Test/resourceType/stringArray[*]'))] =>"c"		 true

Para obter exemplos úteis, consulte Exemplos de contagem de valor.

Modificando matrizes

Anexar e modificar alteram as propriedades de um recurso durante a sua criação ou atualização. Ao trabalhar com propriedades de matriz, o comportamento desses efeitos depende de a operação estar tentando ou não modificar o alias [*]:

Observação

O uso do efeito modify com aliases está atualmente em versão prévia.

Alias Efeito Resultado
Microsoft.Storage/storageAccounts/networkAcls.ipRules append O Azure Policy acrescenta toda a matriz especificada nos detalhes do efeito, se ausente.
Microsoft.Storage/storageAccounts/networkAcls.ipRules modify com operação add O Azure Policy acrescenta toda a matriz especificada nos detalhes do efeito, se ausente.
Microsoft.Storage/storageAccounts/networkAcls.ipRules modify com operação addOrReplace O Azure Policy acrescenta toda a matriz especificada nos detalhes do efeito, se ausente.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*] append O Azure Policy acrescenta o membro da matriz especificado nos detalhes do efeito.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*] modify com operação add O Azure Policy acrescenta o membro da matriz especificado nos detalhes do efeito.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*] modify com operação addOrReplace O Azure Policy remove todos os membros da matriz existentes e acrescenta o membro da matriz especificado nos detalhes do efeito.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].action append O Azure Policy acrescenta um valor à propriedade action de cada membro da matriz.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].action modify com operação add O Azure Policy acrescenta um valor à propriedade action de cada membro da matriz.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].action modify com operação addOrReplace O Azure Policy acrescenta ou substitui a propriedade action existente em cada membro da matriz.

Para obter mais informações, consulte os exemplos de append.

Exemplos adicionais de alias [*]

É recomendável usar as expressões de contagem de campo para verificar se “todos” ou ”qualquer um” dos membros de uma matriz no conteúdo da solicitação atendem a uma condição. No entanto, para algumas condições simples, é possível obter o mesmo resultado usando um acessador de campo com um alias de matriz, conforme descrito em Referenciando a coleção de membros da matriz. Esse padrão pode ser útil em regras de política que excedam o limite de expressões de contagem permitidas. Aqui estão exemplos de casos de uso comuns:

A regra de política de exemplo para a tabela de cenário abaixo:

"policyRule": {
    "if": {
        "allOf": [
            {
                "field": "Microsoft.Storage/storageAccounts/networkAcls.ipRules",
                "exists": "true"
            },
            <-- Condition (see table below) -->
        ]
    },
    "then": {
        "effect": "[parameters('effectType')]"
    }
}

Para o cenário de tabela mostrado abaixo, a matriz ipRules é da seguinte maneira:

"ipRules": [
    {
        "value": "127.0.0.1",
        "action": "Allow"
    },
    {
        "value": "192.168.1.1",
        "action": "Allow"
    }
]

Para cada exemplo de condição abaixo, substitua <field> por "field": "Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].value".

Os seguintes resultados são o resultado da combinação entre a condição, da regra de política de exemplo e da matriz de valores existentes acima:

Condição Resultado Cenário Explicação
{<field>,"notEquals":"127.0.0.1"} Nada Nenhuma correspondência Um elemento de matriz é avaliado como false (127.0.0.1 != 127.0.0.1) e outro como true (127.0.0.1 != 192.168.1.1), portanto, a condição notEquals é false e o efeito não é disparado.
{<field>,"notEquals":"10.0.4.1"} Efeito de política Nenhuma correspondência Ambos os elementos da matriz são avaliados como true (10.0.4.1 != 127.0.0.1 e 10.0.4.1 != 192.168.1.1), então a condição notEquals é true e o efeito é disparado.
"not":{<field>,"notEquals":"127.0.0.1" } Efeito de política Uma ou mais correspondências Um elemento de matriz é avaliado como false (127.0.0.1 != 127.0.0.1) e outro como true (127.0.0.1 != 192.168.1.1), então a condição notEquals é false. O operador lógico é avaliado como verdadeiro (notfalse), portanto, o efeito é disparado.
"not":{<field>,"notEquals":"10.0.4.1"} Nada Uma ou mais correspondências Ambos os elementos da matriz são avaliados como true (10.0.4.1 != 127.0.0.1 e 10.0.4.1 != 192.168.1.1), então a condição notEquals é true. O operador lógico é avaliado como falso (nottrue), portanto, o efeito não é disparado.
"not":{<field>,"Equals":"127.0.0.1"} Efeito de política Nem todos correspondem Um elemento de matriz é avaliado como true (127.0.0.1 == 127.0.0.1) e outro como false (127.0.0.1 == 192.168.1.1), então a condição Equals é false. O operador lógico é avaliado como verdadeiro (notfalse), portanto, o efeito é disparado.
"not":{<field>,"Equals":"10.0.4.1"} Efeito de política Nem todos correspondem Ambos os elementos da matriz são avaliados como false (10.0.4.1 == 127.0.0.1 e 10.0.4.1 == 192.168.1.1), então a condição Equals é false. O operador lógico é avaliado como verdadeiro (notfalse), portanto, o efeito é disparado.
{<field>,"Equals":"127.0.0.1"} Nada Todos correspondem Um elemento de matriz é avaliado como true (127.0.0.1 == 127.0.0.1) e outro como false (127.0.0.1 == 192.168.1.1), portanto, a condição Equals é false e o efeito não é disparado.
{<field>,"Equals":"10.0.4.1"} Nada Todos correspondem Ambos os elementos da matriz são avaliados como true (10.0.4.1 == 127.0.0.1 e 10.0.4.1 == 192.168.1.1), então a condição Equals é false e o efeito não é disparado.

Próximas etapas