Vytváření zásad pro vlastnosti pole u prostředků Azure

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:

• Typ parametru definice ,který poskytuje více možností
• Část pravidla zásad využívající podmínky v nebo neIn
• Část pravidla zásad, která počítá, kolik členů pole splňuje podmínku
• V doplňovací a modifikovací efekty aktualizují existující pole.

Tento článek se věnuje každému použití Azure Policy a obsahuje 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 jakékoli jedno umístění pro parametr allowedLocations a výchozí nastavení je 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ásady je možné nastavit pouze jednu hodnotu. Pokud je tato zásada přiřazená, jsou prostředky v oboru povoleny pouze v rámci jedné oblasti Azure. Většina definic zásad musí umožnovat seznam schválených možností, například povolení eastus2, eastus a westus2.

Pokud chcete vytvořit definici zásady, která povolí 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"
        ]

    }
}

Tato nová definice parametru přijímá během přiřazování zásad více než jednu hodnotu. Když je vlastnost pole allowedValues definovaná, hodnoty dostupné během přiřazení jsou dále omezené 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ě se uvádí , že se má použít ; k oddělení hodnot. (např. Londýn; New York)". Pokud chcete do 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 PowerShell nebo REST API. Hodnoty se předá 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:

• Azure CLI: Příkaz az policy assignment create s parametry parametrů
• Azure PowerShell: Rutina New-AzPolicyAssignment s parametrem PolicyParameter
• REST API: V operaci PUT create jako součást textu požadavku jako hodnoty vlastnosti properties.parameters

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

In a notIn

Podmínky in notIn a fungují jenom s hodnotami pole. Zkontrolují existenci hodnoty v poli. 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 počí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á nějaké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 třikrát vyhodnotí podmínku, jednou pro každého člena funkce , počítá, kolikrát byla where [ "test*", "dev*", "prod*" ] vyhodnocena na true . Při každé iteraci je hodnota aktuálního člena pole spárovaná s pattern názvem indexu definovaným parametrem count.name . Na tuto hodnotu je pak možné odkazovat uvnitř where podmínky voláním speciální funkce šablony: current('pattern') .

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

Pokud chcete, aby byla výše uvedená podmínka generická, použijte místo pole literálů odkaz na parametr:

{
    "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 count, je volitelný a funkce se může používat count.name bez current() argumentů:

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

Počet hodnot také podporuje pole komplexních objektů, což umožňuje složitější podmínky. Například následující podmínka definuje hodnotu požadované značky pro každý vzor názvů a kontroluje, 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 tématu příklady 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ředek. Některé scénáře vyžadují odkazování na celé pole (například kontrolu jeho délky). Jiné vyžadují použití podmínky na každého jednotlivého člena pole (například zajistěte, aby všechna pravidla brány firewall blokují přístup z internetu). Pochopení různých způsobů, Azure Policy mohou 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 se 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"
  }
  

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

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

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

Odkazování na pole pole

Vlastnosti prostředku pole jsou reprezentovány dvěma různými typy aliasů. Jeden běžný 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í 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ě , přijímá pouze řetězcové hodnoty, takže se při porovnávání pole equals s řetězcem moc nevyujímá. Hlavní scénář, ve kterém je odkazování na vlastnost pole užitečné, je při kontrole, jestli existuje:

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

U funkce je vrácenou hodnotou pole z obsahu požadavku, které se pak může použít s libovolnou z podporovaných funkcí šablony, které přijímají field() 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á 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 platí následující podmínka pouze v případě, že se všichni členové třídy rovnají hodnotě field stringArray .

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

Pokud pole obsahuje objekty, lze pomocí aliasu vybrat hodnotu konkrétní [*] vlastnosti z každého člena pole. Příklad:

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

Tato podmínka je pravdivá, pokud se hodnoty property všech vlastností objectArray v souboru rovnají "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 polem všech vybraných hodnot. Toto chování znamená, že běžný případ použití funkce, schopnost použít funkce šablony na hodnoty vlastností field() prostředku, je omezená. Jediné funkce šablony, které lze v tomto případě použít, jsou funkce, 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 u každého člena pole a jejich porovnání s požadovanou hodnotou, jsou však možné pouze při použití count výrazu . Další informace najdete v tématu Výraz počtu polí.

Shrnutí najdete v následujícím příkladu obsahu prostředku 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 obsah příkladu prostředku jsou výsledky následující:

Při použití field() funkce u obsahu příkladu prostředku jsou výsledky následující:

Výrazy počtu polí

Výrazy počtu polí spočítá, kolik členů pole splňuje podmínku, a porovná 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 vrátí délku count pole. S příkladem obsahu prostředku z předchozí části se následující výraz vyhodnotí jako count , protože má tři true stringArray členy:

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

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

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

Síla je count v where podmíně. Pokud je zadaný, Azure Policy vytvoří výčet členů pole a vyhodnotí je pro podmínku a spočítá, kolik členů pole se vyhodnotí jako true . Konkrétně v každé iteraci vyhodnocení podmínky Azure Policy vybere jeden člen pole * i _ a vyhodnotí obsah prostředku s podmínkou , jako kdyby * i je jediným členem where where array_. __ Pokud máte v každé iteraci k dispozici pouze jeden člen pole, můžete u každého člena pole použít složité podmínky.

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 třikrát vyhodnotí podmínku, jednou pro každého člena funkce , počítá, kolikrát byla count where stringArray vyhodnocena na true . Když podmínka odkazuje na členy pole, místo toho, aby vybrala všechny členy , vybere vždy jenom where Microsoft.Test/resourceType/stringArray[*] jednoho stringArray člena pole:

Vrátí count 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
}

Vrátí count 1 .

Skutečnost, že se výraz vyhodnocuje pro celý obsah požadavku (se změnami pouze u aktuálně výčtového člena pole), znamená, že podmínka může také odkazovat na pole where mimo where pole:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
      "field": "tags.env",
      "equals": "prod"
    }
  },
  "equals": 0
}

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

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
      "count": {
        "field": "Microsoft.Test/resourceType/objectArray[*].nestedArray[*]"
      },
      "greaterOrEquals": 1
    }
  },
  "equals": 2
}

Vzhledem k tomu, že oba členy mají objectArray[*] podřízené pole se dvěma nestedArray[*] členy, vnější výraz count vrátí 2 .

Složitější příklad: Zkontrolujte, že pole objectArray[*] má přesně dva členy s nestedArray[*] libovolnými členy rovnajícími se 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
}

Vzhledem k tomu, že oba členy mají podřízené pole, které obsahuje nebo objectArray[*] , vnější výraz count vrátí nestedArray[*] 2 3 2 .

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

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

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
        "value": "[current('Microsoft.Test/resourceType/objectArray[*].property')]",
        "like": "value*"
    }
  },
  "equals": 2
}

Funkce field uvnitř funkce where conditions

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

1. Aliasy polí se převedou do kolekce hodnot vybraných ze všech členů pole.
2. field() Funkce odkazující na aliasy polí vrací pole s vybranými hodnotami.
3. Odkazování na alias počítaných polí uvnitř podmínky vrátí kolekci s jednou hodnotou vybranou z člena pole, která je vyhodnocena where v aktuální iteraci.

Toto chování znamená, že při odkazování na počítaný člen pole s funkcí uvnitř podmínky vrátí pole field() where s jedním členem. I když toto chování nemusí být intuitivní, je konzistentní s myšlenkou, ž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
}

Proto pokud potřebujete získat přístup k hodnotě aliasu počítaných polí pomocí funkce, můžete to udělat tak, že ho zabalíte field() pomocí first() funkce šablony:

{
  "count": {
    "field": "Microsoft.Test/resourceType/stringArray[*]",
    "where": {
      "field": "Microsoft.Test/resourceType/stringArray[*]",
      "equals": "[first(field('Microsoft.Test/resourceType/stringArray[*]'))]"
    }
  }
}

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

Úpravy polí

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

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

Další příklady aliasů [*]

Pro kontrolu, zda všechny členy pole v obsahu žádosti splňují určitou podmínku, se doporučuje použít výrazy počtu polí . V některých jednoduchých podmínkách je však možné dosáhnout stejného výsledku pomocí přístupového objektu 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ů Count . Tady jsou příklady pro běžné případy použití:

Příklad pravidla zásad pro 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ý příklad podmínky Nahraďte parametr <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 stávajících hodnot výše:

Další kroky

• Přečtěte si příklady na Azure Policy Samples.
• Projděte si strukturu definic Azure Policy.
• Projděte si Vysvětlení efektů zásad.
• Zjistěte, jak programově vytvářet zásady.
• Přečtěte si, jak opravit prostředky, které nedodržují předpisy.
• Seznamte se s tím, co skupina pro správu organizuje vaše prostředky pomocí skupin pro správu Azure.