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 v
  • Čá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í nastavení eastus2:

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

Jako typ byl řetězec, při přiřazování zásad je možné nastavit pouze 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.

Pokud chcete vytvořit definici zásady, která umožňuje více možností, použijte typ pole. 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í definice zásady nelze vlastnost typu parametru změnit.

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

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

Při přiřazování zásad prostřednictvím webu Azure Portal se jako jedno textové pole zobrazí parametr pole typu. Nápověda říká "Použít ; k oddělení hodnot. (např. Londýn; 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 byla výše uvedená podmínka obecnější, použijte místo literálového pole odkaz na parametry:

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

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

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

Počet hodnot také podporuje 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í "veškeré" 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. V případě Microsoft.Test/resourceType/stringArray[*]vrátí kolekci, která má všechny členy stringArray. Jak už jsme zmínili dříve, podmínka kontroluje, že všechny vybrané vlastnosti prostředku splňují podmínku, a proto je splněna následující podmínka pouze v případě, field že se všichni členové stringArray jsou rovni hodnotě "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 se doporučuje 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 dalších příkladech 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 ]
      }
    ]
  }
}

Při použití podmínky pole u ukázkového obsahu zdroje jsou výsledky 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

Při použití field() funkce v ukázkovém obsahu prostředku jsou výsledky 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 zadání azure Policy vyčíslí členy pole a vyhodnocuje jednotlivé členy s podmínkou a počítá, kolik členů pole se vyhodnotilo true. Konkrétně v každé iteraci where vyhodnocení podmínky Azure Policy vybere jeden člen pole i a vyhodnotí obsah prostředku proti where podmínce, jako by i je 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 pouze jeden člen pole pokaždé:

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:

  1. Aliasy pole se přeloží do kolekce hodnot vybraných ze všech členů pole.
  2. field() funkce odkazující na aliasy pole vrátí matici s vybranými hodnotami.
  3. 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čujeme použít výrazy počtu polí ke kontrole, jestli všechny členy pole v obsahu požadavku splňují podmínku, jestli všechny členy pole nebo jakýkoli z těchto členů. U některých jednoduchých podmínek je však 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 výrazů počtu . Tady jsou příklady běžných případů použití:

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

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

Pole ipRules je v následující tabulce scénáře:

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

Pro každý níže uvedený příklad podmínky 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 existujících hodnot výše:

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 pravda (127.0.0.1 != 192.168.1.1), takže podmínka notEquals 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 a 10.0.4.1 != 192.168.1.1), takže podmínka notEquals je pravdivá a účinek 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 pravda (127.0.0.1 != 192.168.1.1), takže podmínka notEquals je nepravda. 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 a 10.0.4.1 != 192.168.1.1), takže podmínka notEquals 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.0.1 == 127.0.0.1) a druhý jako false (127.0.0.1 == 192.168.1.1), takže podmínka Equals je nepravda. 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 matice se vyhodnotí jako false (10.0.4.1 == 127.0.0.1 a 10.0.4.1 == 192.168.1.1), takže podmínka Rovná se je false. 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 jeden jako nepravda (127.0.0.1 == 192.168.1.1), takže podmínka Rovná se 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 a 10.0.4.1 == 192.168.1.1), takže podmínka Rovná se nepravda a efekt se neaktivuje.

Další kroky