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

  • Článek

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

Tento článek se zabývá jednotlivými způsoby použití Azure Policy a poskytuje několik příkladů definic.

Pole parametrů

Definování pole parametrů

Definování parametru jako pole umožňuje flexibilitu zásad v případě, že je potřeba více než jedna hodnota. Tato definice zásady umožňuje libovolné jedno umístění pro parametr allowedLocations a výchozí hodnota eastus2:

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

Vzhledem k tomu, že typ byl řetězec, je možné při přiřazování zásady nastavit pouze jednu hodnotu. Pokud je tato zásada přiřazená, jsou prostředky v oboru povolené pouze v rámci jedné oblasti Azure. Většina definic zásad musí povolit seznam schválených možností, například povolení eastus2, eastus a westus2.

Pokud chcete vytvořit definici zásady umožňující více možností, použijte typpole. 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 není možné změnit vlastnost type parametru.

Tato nová definice parametru přijímá během přiřazení zásad více než jednu hodnotu. Když je vlastnost pole allowedValues definovaná, 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 Azure Portal se parametr pole typu zobrazí jako jedno textové pole. V nápovědě je uvedeno "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 při použití Azure CLI, Azure PowerShell nebo rozhraní REST API liší. 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

V a nein

Podmínky in a notIn fungují pouze s hodnotami pole. Kontrolují existenci hodnoty v poli. Pole může být literální 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 počítá, kolik členů pole splňuje podmínku. Poskytuje způsob, jak vyhodnotit stejnou podmínku vícekrát s použitím různých hodnot v každé iteraci. Následující podmínka například 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 vyhodnocuje podmínku where třikrát, jednou pro každý člen [ "test*", "dev*", "prod*" ]souboru , přičemž počítá, kolikrát byla vyhodnocena jako true. Při každé iteraci je hodnota aktuálního člena pole spárována s názvem indexu pattern definovaným v count.name. Na tuto hodnotu pak lze v podmínce where odkazovat voláním speciální funkce šablony: current('pattern').

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

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

Pokud chcete, aby výše uvedená podmínka byla obecnější, použijte odkaz na parametr místo literálového pole:

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

Pokud výraz pro počet hodnot není pod žádným jiným výrazem count , count.name je volitelný a current() funkci je možné 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. Následující podmínka například definuje hodnotu požadované 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ředků 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 zajistit, aby všechna pravidla brány firewall blokovala přístup z internetu). Pochopení různých způsobů, Azure Policy mohou odkazovat na vlastnosti prostředků, a jak se tyto odkazy chovají, když odkazují na vlastnosti pole, je klíčem k zápisu podmínek, které pokrývají tyto scénáře.

Odkazování na vlastnosti prostředku

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

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

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

  • Použijte field() funkci pro přístup k hodnotě vlastnosti. Příklad:

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

Podmínka pole má implicitní chování "all of". 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 jsou, se kterými pak mohou pracovat jiné funkce šablony.

Odkazování na pole pole

Vlastnosti prostředků pole jsou reprezentovány dvěma různými typy aliasů. Jeden "normální" alias a aliasy polí , 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 pole, není v podmínkách zásad užitečná. 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ář, kde je odkazování na vlastnost pole užitečné, je při kontrole, jestli existuje:

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

field() U funkce je vrácenou hodnotou pole z obsahu požadavku, které se pak dá použít s libovolnou podporovanou funkcí šablony, které přijímají argumenty pole. Například následující podmínka 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á obsahuje všechny členy .stringArray Jak už bylo zmíněno dříve, podmínka kontroluje, že všechny vybrané vlastnosti prostředku splňují podmínku, a proto platí následující podmínka pouze v případě, field že se všechny členy stringArray rovnají hodnotě.

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

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

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

Tato podmínka je pravdivá, pokud se hodnoty všech property vlastností v souboru objectArray rovnají hodnotě "value". Další příklady najdete v tématu Další příklady [*] aliasů.

Při použití field() funkce k odkazování na alias pole je vrácená hodnota pole se všemi vybranými hodnotami. 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é funkce šablony, které lze v tomto případě použít, jsou ty, které přijímají argumenty pole. Například je možné získat délku pole pomocí [length(field('Microsoft.Test/resourceType/objectArray[*].property'))]. Složitější scénáře, jako je použití funkce šablony na každý člen pole a porovnání s požadovanou hodnotou, jsou však možné pouze při použití výrazu count . Další informace najdete v tématu Výraz počtu 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 pro ukázkový obsah 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, 3, 4

Při použití funkce u field() ukázkového 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í spočítají, kolik členů pole splňuje podmínku, a porovnávají 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 count jednoduše 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 truestringArray 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í jako true , protože pole nestedArray obsahují čtyři členy pole:

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

Síla count je v podmínce where . Když je zadaný, Azure Policy vyčíslí členy pole a vyhodnotí je proti podmínce a spočítá, kolik členů matice bylo vyhodnoceno jako true. Konkrétně v každé iteraci where vyhodnocení podmínky Azure Policy vybere jeden člen pole i a vyhodnotí obsah prostředku proti podmínce where, jako by i byl jediným členem pole. Mít v každé iteraci k dispozici pouze jeden člen pole poskytuje způsob, jak použít složité podmínky pro každý jednotlivý člen pole.

Příklad:

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

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

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

Vrátí count hodnotu 1.

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í
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

Vrátí count hodnotu 1.

Skutečnost, že where se výraz vyhodnotí proti celému obsahu požadavku (se změnami pouze u č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í
1 tags.env =>"prod" true
2 tags.env =>"prod" true

Výrazy vnořeného počtu se dají použít k použití podmínek na vnořená pole pole. Například následující podmínka zkontroluje, že objectArray[*] pole má přesně dva členy s nestedArray[*] tím, že obsahuje 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
1 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, objectArray[*] že oba členy mají podřízené pole nestedArray[*] se dvěma členy, vrátí výraz vnějšího počtu hodnotu 2.

Složitější příklad: Zkontrolujte, jestli objectArray[*] pole obsahuje přesně dva členy s libovolnými nestedArray[*] členy rovnými 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
1 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 objectArray[*] mají podřízenou matici nestedArray[*] , která obsahuje buď 2 nebo 3, vrátí výraz vnějšího počtu hodnotu 2.

Poznámka

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

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

Při použití funkcí šablony použijte current() funkci pro přístup k hodnotě aktuálního člena pole nebo k hodnotám některé z jeho vlastností. Pokud chcete získat přístup k hodnotě aktuálního člena pole, předejte funkci alias definovaný v count.field nebo některý z jeho podřízených aliasů jako argument 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í
1 Hodnota v property prvním členu :objectArray[*]value1 true
2 Hodnota v property prvním členu :objectArray[*]value2 true

Funkce pole uvnitř, kde podmínky

Funkci field() lze použít také pro přístup k hodnotě aktuálního člena 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 polí se překládají na kolekci hodnot vybraných ze všech členů pole.
  2. field() funkce odkazující na aliasy polí vrátí pole s vybranými hodnotami.
  3. Odkazování na počítaný alias pole uvnitř where podmínky vrátí kolekci s jednou hodnotou vybranou z člena pole, který je vyhodnocen v aktuální iteraci.

Toto chování znamená, že když odkazuje 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 představou, že aliasy polí 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í
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

Pokud je tedy potřeba získat přístup k hodnotě počítaného aliasu pole pomocí field() funkce, je možné ji first() zabalit pomocí 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í
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

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

Úprava polí

Při vytváření nebo aktualizaci se při přidávání a úpravách mění vlastnosti prostředku. 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 Účinek Výsledek
Microsoft.Storage/storageAccounts/networkAcls.ipRules append Azure Policy připojí celou matici zadanou v podrobnostech o efektu, pokud chybí.
Microsoft.Storage/storageAccounts/networkAcls.ipRules modify s add operací Azure Policy připojí celou matici zadanou 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í člen pole zadaný v podrobnostech o efektu.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*] modify s add operací Azure Policy připojí člen pole zadaný 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 action vlastnosti každého člena pole.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].action modify s add operací Azure Policy připojí hodnotu k action vlastnosti každého člena 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 "všichni" nebo "kterýkoli z" členové pole v obsahu požadavku splňují podmínku. U některých jednoduchých podmínek je však možné stejného výsledku dosáhnout použitím přistupujícího pole s aliasem pole, jak je popsáno v tématu 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í:

Příklad pravidla 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 pro následující tabulku scénářů následující:

"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 za <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 Scenario Vysvětlení
{<field>,"notEquals":"127.0.0.1"} Nothing Žádná shoda Jeden prvek matice se vyhodnotí jako false (127.0.0.1 != 127.0.0.1) a jeden jako true (127.0.0.1 != 192.168.1.1), takže podmínka notEquals je false a efekt se neaktivuje.
{<field>,"notEquals":"10.0.4.1"} Efekt 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" } Efekt zásad Jedna nebo více shod Jeden prvek pole se vyhodnotí jako false (127.0.0.1 != 127.0.0.1) a jeden jako true (127.0.0.1 != 192.168.1.1), takže podmínka notEquals je false. Logický operátor se vyhodnotí jako true (nefalse), takže se aktivuje efekt.
"not":{<field>,"notEquals":"10.0.4.1"} Nothing 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 notEqualsplatí. Logický operátor se vyhodnotí jako false (netrue), takže se efekt neaktivuje.
"not":{<field>,"Equals":"127.0.0.1"} Efekt zásad Ne všichni se shodují Jeden prvek matice 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 false. Logický operátor se vyhodnotí jako true (nefalse), takže se aktivuje efekt.
"not":{<field>,"Equals":"10.0.4.1"} Efekt zásad Ne všichni se shodují 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 je nepravdivá. Logický operátor se vyhodnotí jako true (nefalse), takže se aktivuje efekt.
{<field>,"Equals":"127.0.0.1"} Nothing Všechna shoda Jeden prvek matice 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 nepravdivá a efekt se neaktivuje.
{<field>,"Equals":"10.0.4.1"} Nothing Všechna shoda 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 a efekt se neaktivuje.

Další kroky