Sdílet prostřednictvím

Vytváření zásad pro vlastnosti pole v prostředcích Azure

  • Článek

Vlastnosti Azure Resource Manageru se běžně definují jako řetězce a logické hodnoty. Pokud existuje relace 1:N, jsou složité vlastnosti místo toho definovány jako pole. V Azure Policy se pole používají několika různými způsoby:

  • Typ parametru definice, který poskytuje více možností.
  • Část pravidla zásad používající podmínky in nebo notIn.
  • Část pravidla zásad, která spočítá, kolik členů pole splňuje podmínku.
  • V připojení a úpravě efektů pro aktualizaci existujícího pole

Tento článek se zabývá jednotlivými použitími ve službě Azure Policy a poskytuje několik ukázkových definic.

Pole parametrů

Definování pole parametrů

Definování parametru jako pole umožňuje flexibilitu zásad v případě potřeby více hodnot. Tato definice zásady umožňuje libovolné umístění parametru allowedLocations a výchozí hodnoty eastus2:

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

Stejně jako type řetězec lze při přiřazování zásad nastavit jenom jednu hodnotu. Pokud je tato zásada přiřazená, prostředky v oboru jsou povoleny pouze v rámci jedné oblasti Azure. Většina definic zásad musí umožňovat seznam schválených možností, jako je povolení východu 2, eastus a westus2.

Chcete-li vytvořit definici zásady, která umožňuje více možností, použijte pole type. Stejnou zásadu je možné přepsat následujícím způsobem:

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

Poznámka:

Po uložení type definice zásady nelze vlastnost parametru změnit.

Tato nová definice parametru přebírá během přiřazování zásad více než jednu hodnotu. Při definované vlastnosti allowedValues pole jsou hodnoty dostupné během přiřazení dále omezeny na předdefinovaný seznam voleb. allowedValues Použití je volitelné.

Předání hodnot do pole parametrů během přiřazení

Když zásadu přiřadíte prostřednictvím webu Azure Portal, zobrazí se parametr type pole jako jedno textové pole. Tip říká Use ; to separate values. (e.g. London;New York). Pokud chcete parametru předat povolené hodnoty umístění eastus2, eastus a westus2 , použijte následující řetězec:

eastus2;eastus;westus2

Formát hodnoty parametru se liší při použití Azure CLI, Azure PowerShellu nebo rozhraní REST API. Hodnoty se předávají prostřednictvím řetězce JSON, který obsahuje také název parametru.

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

Pokud chcete tento řetězec použít s každou sadou SDK, použijte následující příkazy:

Použití polí v podmínkách

In a notIn

Podmínky in a notIn podmínky fungují pouze s hodnotami pole. Zkontrolují existenci hodnoty v matici. Pole může být literálové pole JSON nebo odkaz na parametr pole. Příklad:

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

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

Počet hodnot

Výraz počtu hodnot spočítá, kolik členů pole splňuje podmínku. Poskytuje způsob, jak vyhodnotit stejnou podmínku vícekrát pomocí různých hodnot v každé iteraci. Například následující podmínka zkontroluje, jestli název prostředku odpovídá libovolnému vzoru z pole vzorů:

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

Aby bylo možné výraz vyhodnotit, Azure Policy vyhodnotí podmínku where třikrát, jednou pro každého člena [ "test*", "dev*", "prod*" ], počítá, kolikrát byla vyhodnocena na true. Při každé iteraci je hodnota aktuálního členu pole spárována s názvem indexu pattern definovaným .count.name Na tuto hodnotu lze v podmínce where odkazovat zavoláním speciální funkce šablony: current('pattern').

Iterace current('pattern') vrácená hodnota
1 "test*"
2 "dev*"
3 "prod*"

Podmínka platí pouze v případě, že je počet výsledek větší než 0.

Pokud chcete, aby předchozí podmínka byla obecnější, použijte parameters místo literálového pole odkaz:

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

value count Pokud výraz není pod žádným jiným count výrazem, count.name je volitelný a current() funkce se dá použít bez argumentů:

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

Podporuje value count také pole složitých objektů, což umožňuje složitější podmínky. Například následující podmínka definuje požadovanou hodnotu značky pro každý vzor názvů a zkontroluje, jestli název prostředku odpovídá vzoru, ale nemá požadovanou hodnotu značky:

{
  "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
}

Užitečné příklady najdete v příkladech počtu hodnot.

Odkazování na vlastnosti prostředku pole

Mnoho případů použití vyžaduje práci s vlastnostmi pole v vyhodnocených prostředcích. Některé scénáře vyžadují odkazování na celé pole (například kontrola jeho délky). Jiné vyžadují použití podmínky u každého jednotlivého člena pole (například zajistěte, aby všechna pravidla brány firewall blokovala přístup z internetu). Pochopení různých způsobů, jak může Azure Policy odkazovat na vlastnosti prostředku a jak se tyto odkazy chovají, když odkazují na vlastnosti pole, je klíčem pro zápis podmínek, které pokrývají tyto scénáře.

Odkazování na vlastnosti prostředku

Na vlastnosti prostředku může azure Policy odkazovat pomocí aliasů Existují dva způsoby, jak odkazovat na hodnoty vlastnosti prostředku v rámci služby Azure Policy:

  • Pomocí podmínky pole zkontrolujte, jestli všechny vybrané vlastnosti zdroje splňují podmínku. Příklad:

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

  • Funkce slouží field() k přístupu k hodnotě vlastnosti. Příklad:

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

Podmínka pole má implicitní allOf chování. Pokud alias představuje kolekci hodnot, zkontroluje, jestli všechny jednotlivé hodnoty splňují podmínku. Funkce field() vrátí hodnoty reprezentované aliasem tak, jak je, což pak mohou být manipulovány jinými funkcemi šablony.

Odkazování na pole pole

Vlastnosti prostředku pole jsou reprezentovány dvěma různými typy aliasů. Jeden normální alias a aliasy pole, které jsou [*] k němu připojené:

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

Odkazování na pole

První alias představuje jednu hodnotu, hodnotu stringArray vlastnosti z obsahu požadavku. Vzhledem k tomu, že hodnota této vlastnosti je matice, není užitečná v podmínkách zásad. Příklad:

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

Tato podmínka porovnává celé stringArray pole s jednou řetězcovou hodnotou. Většina podmínek, včetně equals, přijímá pouze řetězcové hodnoty, takže při porovnávání pole s řetězcem se moc nepoužívá. Hlavní scénář, ve kterém je odkaz na vlastnost pole užitečný, je při kontrole, jestli existuje:

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

field() U funkce je vrácená hodnota pole z obsahu požadavku, které se pak dá použít s některou z podporovaných funkcí šablony, které přijímají argumenty pole. Následující podmínka například zkontroluje, jestli je délka stringArray větší než 0:

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

Odkazování na kolekci členů pole

Aliasy, které používají [*] syntaxi, představují kolekci hodnot vlastností vybraných z vlastnosti pole, která se liší od výběru samotné vlastnosti pole. Například Microsoft.Test/resourceType/stringArray[*] vrátí kolekci, která má všechny členy stringArray. Jak už bylo zmíněno dříve, podmínka kontroluje, zda všechny vybrané vlastnosti prostředku splňují podmínku, a proto následující podmínka platí pouze v případě, field že jsou všichni členové stringArray rovni "value".

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

Pokud je pole prázdné, podmínka se vyhodnotí jako true, protože není v rozporu s žádným členem pole. V tomto scénáři doporučujeme místo toho použít výraz count. Pokud pole obsahuje objekty, [*] lze alias použít k výběru hodnoty konkrétní vlastnosti z každého člena pole. Příklad:

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

Tato podmínka platí, pokud jsou hodnoty všech property vlastností objectArray rovny "value". Další příklady najdete v tématu Další příklady aliasů.

Při použití field() funkce odkazovat na alias pole je vrácená hodnota matice všech vybraných hodnot. Toto chování znamená, že běžný případ field() použití funkce, možnost použít funkce šablony na hodnoty vlastností prostředku je omezená. Jedinými funkcemi šablony, které lze v tomto případě použít, jsou funkce, které přijímají argumenty pole. Je například možné získat délku pole s [length(field('Microsoft.Test/resourceType/objectArray[*].property'))]. Složitější scénáře, jako je použití funkce šablony u každého člena pole a jeho porovnání s požadovanou hodnotou, jsou však možné pouze při použití výrazu count . Další informace naleznete v tématu Výraz počet polí.

Shrnutí najdete v následujícím příkladu obsahu prostředků a vybraných hodnot vrácených různými aliasy:

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

Když použijete podmínku pole u ukázkového obsahu zdroje, výsledky jsou následující:

Alias Vybrané hodnoty
Microsoft.Test/resourceType/missingArray null
Microsoft.Test/resourceType/missingArray[*] Prázdná kolekce hodnot.
Microsoft.Test/resourceType/missingArray[*].property Prázdná kolekce hodnot.
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, , 34

Pokud použijete field() funkci v ukázkovém obsahu prostředku, výsledky jsou následující:

Výraz Vrácená hodnota
[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]

Výrazy počtu polí

Výrazy počtu polí sčítají, kolik členů pole splňuje podmínku, a porovnejte počet s cílovou hodnotou. Count je intuitivnější a všestrannější pro vyhodnocování polí v porovnání s field podmínkami. Syntaxe je:

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

Při použití bez where podmínky jednoduše count vrátí délku pole. S ukázkovým obsahem prostředků z předchozí části se vyhodnotí následující count výraz, protože true stringArray má tři členy:

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

Toto chování funguje také s vnořenými poli. Například následující count výraz se vyhodnotí tak, že true v nestedArray polích jsou čtyři členy pole:

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

count Síla je v podmíncewhere. Po count zadání azure Policy vyčíslí členy pole a vyhodnocuje je podle podmínky a počítá, kolik členů pole se vyhodnocuje truejako . Konkrétně v každé iteraci where vyhodnocení podmínky azure Policy vybere jeden člen i pole a vyhodnotí obsah prostředku vůči where podmínce , jako by i byl jediným členem pole. Mít v každé iteraci k dispozici pouze jeden člen pole poskytuje způsob použití složitých podmínek na každém jednotlivém členu pole.

Příklad:

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

Aby bylo možné výraz vyhodnotit, Azure Policy vyhodnotí podmínku count where třikrát, jednou pro každého člena stringArray, počítá, kolikrát byla vyhodnocena na true. Pokud podmínka where odkazuje na Microsoft.Test/resourceType/stringArray[*] členy pole místo výběru všech členů stringArray, vybere vždy pouze jeden člen pole:

Iterace Vybrané Microsoft.Test/resourceType/stringArray[*] hodnoty where Výsledek vyhodnocení
1 "a" true
2 "b" false
3 "c" false

1Vrátí count hodnotu .

Tady je složitější výraz:

{
  "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
}
Iterace Vybrané hodnoty where Výsledek vyhodnocení
0 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

1Vrátí count hodnotu .

Skutečnost, že where se výraz vyhodnotí proti celému obsahu požadavku (se změnami pouze člena pole, který je aktuálně vyčíslován), znamená, že where podmínka může odkazovat také na pole mimo pole:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
      "field": "tags.env",
      "equals": "prod"
    }
  },
  "equals": 0
}
Iterace Vybrané hodnoty where Výsledek vyhodnocení
0 tags.env =>"prod" true
2 tags.env =>"prod" true

Výrazy vnořeného počtu lze použít k použití podmínek u vnořených polí pole. Například následující podmínka zkontroluje, že objectArray[*] pole má přesně dva členy, které nestedArray[*] obsahují jeden nebo více členů:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
      "count": {
        "field": "Microsoft.Test/resourceType/objectArray[*].nestedArray[*]"
      },
      "greaterOrEquals": 1
    }
  },
  "equals": 2
}
Iterace Vybrané hodnoty Výsledek vyhodnocení vnořeného počtu
0 Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>1, 2 nestedArray[*] má 2 členy =>true
2 Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>3, 4 nestedArray[*] má 2 členy =>true

Vzhledem k tomu, že oba členy objectArray[*] mají podřízenou matici nestedArray[*] se dvěma členy, vrátí 2výraz vnějšího počtu .

Složitější příklad: Zkontrolujte, jestli objectArray[*] pole má přesně dva členy s libovolnými nestedArray[*] členy, kteří jsou rovni 2 nebo 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
}
Iterace Vybrané hodnoty Výsledek vyhodnocení vnořeného počtu
0 Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>1, 2 nestedArray[*] contains 2 =>true
2 Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>3, 4 nestedArray[*] contains 3 =>true

Vzhledem k tomu, že oba členy mají podřízenou maticinestedArray[*], která obsahuje jednu 2 nebo 3, vrátí výraz vnějšího objectArray[*] počtu 2.

Poznámka:

Výrazy počtu vnořených polí můžou odkazovat pouze na vnořené pole. Výraz count odkazující Microsoft.Test/resourceType/objectArray[*] například může mít vnořený počet, který cílí na vnořené pole Microsoft.Test/resourceType/objectArray[*].nestedArray[*], ale nemůže mít vnořený počet výrazů cílení Microsoft.Test/resourceType/stringArray[*].

Přístup k aktuálnímu členu pole pomocí funkcí šablony

Pokud používáte funkce šablony, použijte current() funkci pro přístup k hodnotě aktuálního člena pole nebo hodnot některé z jeho vlastností. Pokud chcete získat přístup k hodnotě aktuálního členu pole, předejte alias definovaný v count.field podřízených aliasech nebo některý z jeho podřízených aliasů jako argument funkce current() . Příklad:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
      "value": "[current('Microsoft.Test/resourceType/objectArray[*].property')]",
      "like": "value*"
    }
  },
  "equals": 2
}
Iterace current() vrácená hodnota where Výsledek vyhodnocení
0 Hodnota property v prvním členu objectArray[*]: value1 true
2 Hodnota property v prvním členu objectArray[*]: value2 true

Funkce pole uvnitř podmínek

Funkci field() lze také použít pro přístup k hodnotě aktuálního členu pole, pokud výraz count není uvnitř podmínky existence (field() funkce vždy odkazuje na prostředek vyhodnocený v podmínce if ). Chování field() při odkazování na vyhodnocené pole je založeno na následujících konceptech:

  • Aliasy pole se přeloží do kolekce hodnot vybraných ze všech členů pole.
  • field() funkce odkazující na aliasy pole vrátí matici s vybranými hodnotami.
  • Odkazování na alias počítaného pole uvnitř where podmínky vrátí kolekci s jednou hodnotou vybranou z člena pole, který se vyhodnocuje v aktuální iteraci.

Toto chování znamená, že když odkazujete na počítaný člen pole s field() funkcí uvnitř where podmínky, vrátí pole s jedním členem. I když toto chování nemusí být intuitivní, je konzistentní s myšlenkou, že aliasy pole vždy vrací kolekci vybraných vlastností. Tady je příklad:

{
  "count": {
    "field": "Microsoft.Test/resourceType/stringArray[*]",
    "where": {
      "field": "Microsoft.Test/resourceType/stringArray[*]",
      "equals": "[field('Microsoft.Test/resourceType/stringArray[*]')]"
    }
  },
  "equals": 0
}
Iterace Hodnoty výrazů where Výsledek vyhodnocení
0 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

Pokud tedy potřebujete získat přístup k hodnotě počítaného aliasu pole pomocí field() funkce, je to tak, že ji zabalíte pomocí first() funkce šablony:

{
  "count": {
    "field": "Microsoft.Test/resourceType/stringArray[*]",
    "where": {
      "field": "Microsoft.Test/resourceType/stringArray[*]",
      "equals": "[first(field('Microsoft.Test/resourceType/stringArray[*]'))]"
    }
  }
}
Iterace Hodnoty výrazů where Výsledek vyhodnocení
0 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

Užitečné příklady najdete v tématu Příklady počtu polí.

Úprava polí

Připojení a úprava vlastností prostředku během vytváření nebo aktualizace. Při práci s vlastnostmi pole závisí chování těchto efektů na tom, jestli se operace pokouší upravit [*] alias, nebo ne:

Poznámka:

Použití efektu modify s aliasy je aktuálně ve verzi Preview.

Alias Účinnost Výsledek
Microsoft.Storage/storageAccounts/networkAcls.ipRules append Azure Policy připojí celé pole zadané v podrobnostech o efektu, pokud chybí.
Microsoft.Storage/storageAccounts/networkAcls.ipRules modify s add operací Azure Policy připojí celé pole zadané v podrobnostech o efektu, pokud chybí.
Microsoft.Storage/storageAccounts/networkAcls.ipRules modify s addOrReplace operací Azure Policy připojí celé pole zadané v podrobnostech o efektu, pokud chybí nebo nahradí existující pole.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*] append Azure Policy připojí člena pole zadaného v podrobnostech o efektu.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*] modify s add operací Azure Policy připojí člena pole zadaného v podrobnostech o efektu.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*] modify s addOrReplace operací Azure Policy odebere všechny existující členy pole a připojí člena pole zadaného v podrobnostech o efektu.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].action append Azure Policy připojí hodnotu k vlastnosti každého člena action pole.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].action modify s add operací Azure Policy připojí hodnotu k vlastnosti každého člena action pole.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].action modify s addOrReplace operací Azure Policy připojí nebo nahradí existující action vlastnost každého člena pole.

Další informace najdete v příkladech připojení.

Další příklady aliasů

Doporučuje se použít výrazy počtu polí ke kontrole, jestli allOfčlenové anyOf pole v obsahu požadavku splňují podmínku. U některých jednoduchých podmínek je možné dosáhnout stejného výsledku použitím přístupového objektu pole s aliasem pole, jak je popsáno v odkazování na kolekci členů pole. Tento model může být užitečný v pravidlech zásad, která překračují limit povolených count výrazů. Tady jsou příklady běžných případů použití:

Ukázkové pravidlo zásad pro následující tabulku scénářů:

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

Pole ipRules je následující pro následující tabulku scénářů:

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

Pro každý z následujících příkladů podmínek nahraďte <field> ."field": "Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].value"

Následující výsledky jsou výsledkem kombinace podmínky a ukázkového pravidla zásad a pole předchozích existujících hodnot:

Podmínka Výsledek Scénář Vysvětlení
{<field>,"notEquals":"127.0.0.1"} Nic Žádná shoda Jeden prvek pole se vyhodnotí jako false (127.0.0.1 != 127.0.0.1) a druhý jako true (127.0.0.1 != 192.168.1.1), takže notEquals podmínka je nepravda a efekt se neaktivuje.
{<field>,"notEquals":"10.0.4.1"} Účinek zásad Žádná shoda Oba prvky pole se vyhodnotí jako true (10.0.4.1 != 127.0.0.1 and 10.0.4.1 != 192.168.1.1), takže notEquals podmínka je pravdivá a efekt se aktivuje.
"not":{<field>,"notEquals":"127.0.0.1" } Účinek zásad Jedna nebo více shod Jeden prvek pole se vyhodnotí jako false (127.0.0.1 != 127.0.0.1) a druhý jako true (127.0.0.1 != 192.168.1.1), takže notEquals podmínka je false. Logický operátor se vyhodnotí jako true (ne nepravda), takže se aktivuje efekt.
"not":{<field>,"notEquals":"10.0.4.1"} Nic Jedna nebo více shod Oba prvky pole se vyhodnotí jako true (10.0.4.1 != 127.0.0.1 and 10.0.4.1 != 192.168.1.1), takže notEquals podmínka je pravdivá. Logický operátor se vyhodnotí jako false (ne pravda), takže se efekt neaktivuje.
"not":{<field>,"Equals":"127.0.0.1"} Účinek zásad Ne všechny shody Jeden prvek pole se vyhodnotí jako true (127.0.0.1 == 127.0.0.1) a druhý jako false (127.0.0.1 == 192.168.1.1), takže Equals podmínka je false. Logický operátor se vyhodnotí jako true (ne nepravda), takže se aktivuje efekt.
"not":{<field>,"Equals":"10.0.4.1"} Účinek zásad Ne všechny shody Oba prvky pole se vyhodnotí jako false (10.0.4.1 == 127.0.0.1 and 10.0.4.1 == 192.168.1.1), takže Equals podmínka je nepravda. Logický operátor se vyhodnotí jako true (ne nepravda), takže se aktivuje efekt.
{<field>,"Equals":"127.0.0.1"} Nic Všechny shody Jeden prvek pole se vyhodnotí jako true (127.0.0.1 == 127.0.0.1) a druhý jako false (127.0.0.1 == 192.168.1.1), takže Equals podmínka je nepravda a efekt se neaktivuje.
{<field>,"Equals":"10.0.4.1"} Nic Všechny shody Oba prvky pole se vyhodnotí jako false (10.0.4.1 == 127.0.0.1 and 10.0.4.1 == 192.168.1.1), takže Equals podmínka je nepravda a efekt se neaktivuje.

Další kroky