Auteursbeleid voor arrayeigenschappen op Azure-resourcesAuthor policies for array properties on Azure resources

Azure Resource Manager-eigenschappen worden vaak gedefinieerd als tekenreeksen en booleaans.Azure Resource Manager properties are commonly defined as strings and booleans. Wanneer er een één-op-één relatie bestaat, worden complexe eigenschappen in plaats daarvan gedefinieerd als arrays.When a one-to-many relationship exists, complex properties are instead defined as arrays. In Azure Policy worden arrays op verschillende manieren gebruikt:In Azure Policy, arrays are used in several different ways:

  • Het type van een definitieparameterom meerdere opties te biedenThe type of a definition parameter, to provide multiple options
  • Onderdeel van een beleidsregel met de voorwaarden in of nietInPart of a policy rule using the conditions in or notIn
  • Onderdeel van een beleidsregel die [ * ] de alias evalueert om te evalueren:Part of a policy rule that evaluates the [*] alias to evaluate:
    • Scenario's zoals Geen, Anyof AllesScenarios such as None, Any, or All
    • Complexe scenario's met tellingComplex scenarios with count
  • In het toevoegeffect vervangen of toevoegen aan een bestaande arrayIn the append effect to replace or add to an existing array

Dit artikel behandelt elk gebruik door Azure Policy en bevat verschillende voorbeelddefinities.This article covers each use by Azure Policy and provides several example definitions.

ParameterarraysParameter arrays

Een parameterarray definiërenDefine a parameter array

Als u een parameter als een array definieert, u de beleidsflexibiliteit behouden wanneer er meer dan één waarde nodig is.Defining a parameter as an array allows the policy flexibility when more than one value is needed. Met deze beleidsdefinitie u elke locatie voor de parameter toegestaanlocaties en standaardwaarden naar eastus2:This policy definition allows any single location for the parameter allowedLocations and defaults to eastus2:

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

Als tekst _tekenreeks_was, kan slechts één waarde worden ingesteld bij het toewijzen van het beleid.As type was string, only one value can be set when assigning the policy. Als dit beleid is toegewezen, zijn resources in het bereik alleen toegestaan binnen één Azure-gebied.If this policy is assigned, resources in scope are only allowed within a single Azure region. De meeste beleidsdefinities moeten een lijst van goedgekeurde opties mogelijk maken, zoals het toestaan van eastus2, _eastus_en westus2.Most policies definitions need to allow for a list of approved options, such as allowing eastus2, eastus, and westus2.

Als u de beleidsdefinitie wilt maken om meerdere opties toe te staan, gebruikt u het arraytype type.To create the policy definition to allow multiple options, use the array type. Hetzelfde beleid kan als volgt worden herschreven:The same policy can be rewritten as follows:

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

    }
}

Notitie

Zodra een beleidsdefinitie is opgeslagen, kan de eigenschap type op een parameter niet worden gewijzigd.Once a policy definition is saved, the type property on a parameter can't be changed.

Deze nieuwe parameterdefinitie heeft meer dan één waarde tijdens beleidstoewijzing.This new parameter definition takes more than one value during policy assignment. Met de arrayeigenschap toegestaanWaarden gedefinieerd, zijn de waarden die beschikbaar zijn tijdens de toewijzing verder beperkt tot de vooraf gedefinieerde lijst met keuzes.With the array property allowedValues defined, the values available during assignment are further limited to the predefined list of choices. Gebruik van toegestane Waarden is optioneel.Use of allowedValues is optional.

Waarden doorgeven aan een parameterarray tijdens toewijzingPass values to a parameter array during assignment

Wanneer u het beleid via de Azure-portal toestelt, wordt een parameter van de typearray array weergegeven als één tekstvak.When assigning the policy through the Azure portal, a parameter of type array is displayed as a single textbox. De hint zegt: "Gebruik ; om waarden te scheiden.The hint says "Use ; to separate values. (bijv. Londen; New York)".(e.g. London;New York)". Als u de toegestane locatiewaarden van eastus2, _eastus_en westus2 wilt doorgeven aan de parameter, gebruikt u de volgende tekenreeks:To pass the allowed location values of eastus2, eastus, and westus2 to the parameter, use the following string:

eastus2;eastus;westus2

De indeling voor de parameterwaarde is anders wanneer u Azure CLI, Azure PowerShell of de REST-API gebruikt.The format for the parameter value is different when using Azure CLI, Azure PowerShell, or the REST API. De waarden worden doorgegeven via een JSON-tekenreeks die ook de naam van de parameter bevat.The values are passed through a JSON string that also includes the name of the parameter.

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

Als u deze tekenreeks bij elke SDK wilt gebruiken, gebruikt u de volgende opdrachten:To use this string with each SDK, use the following commands:

  • Azure CLI: opdracht az-beleidstoewijzing maken met parameterparamsAzure CLI: Command az policy assignment create with parameter params
  • Azure PowerShell: Cmdlet New-AzPolicyAssignment with parameter PolicyParameter Azure PowerShell: Cmdlet New-AzPolicyAssignment with parameter PolicyParameter Azure PowerShell: Cmdlet New-AzPolicyAssignment with parameter PolicyParameter Azure PowerAzure PowerShell: Cmdlet New-AzPolicyAssignment with parameter PolicyParameter
  • REST-API: in de bewerking PUT maken als onderdeel van de hoofdtekst van aanvraag als de waarde van de eigenschap properties.parametersREST API: In the PUT create operation as part of the Request Body as the value of the properties.parameters property

Beleidsregels en arraysPolicy rules and arrays

MatrixvoorwaardenArray conditions

De beleidsregelvoorwaarden waarmee een arraytype parameter kan in worden notIngebruikt, is beperkt tot en . arrayThe policy rule conditions that an array type of parameter may be used with is limited to in and notIn. Neem de volgende beleidsdefinitie met voorwaarde equals als voorbeeld:Take the following policy definition with condition equals as an example:

{
  "policyRule": {
    "if": {
      "not": {
        "field": "location",
        "equals": "[parameters('allowedLocations')]"
      }
    },
    "then": {
      "effect": "audit"
    }
  },
  "parameters": {
    "allowedLocations": {
      "type": "Array",
      "metadata": {
        "description": "The list of allowed locations for resources.",
        "displayName": "Allowed locations",
        "strongType": "location"
      }
    }
  }
}

Als u probeert deze beleidsdefinitie via de Azure-portal te maken, wordt dit foutbericht als volgt weergegeven:Attempting to create this policy definition through the Azure portal leads to an error such as this error message:

  • "Het beleid {GUID}' kan niet worden geparaiseerd vanwege validatiefouten."The policy '{GUID}' could not be parameterized because of validation errors. Controleer of beleidsparameters correct zijn gedefinieerd.Please check if policy parameters are properly defined. De binnenste uitzondering 'Evaluatieresultaat van taaluitdrukking '[parameters('toegestaneLocaties')]' is type 'Array', het verwachte type is 'String'.'."The inner exception 'Evaluation result of language expression '[parameters('allowedLocations')]' is type 'Array', expected type is 'String'.'."

Het type verwachte type equals voorwaarde is tekenreeks.The expected type of condition equals is string. Aangezien allowedLocations wordt gedefinieerd als typearray, evalueert de beleidsengine de taalexpressie en gooit de fout. typeSince allowedLocations is defined as type array, the policy engine evaluates the language expression and throws the error. Met in de notIn en de voorwaarde verwacht de beleidsengine de typearray array in de taalexpressie.With the in and notIn condition, the policy engine expects the type array in the language expression. Als u dit foutbericht wilt oplossen, wijzigt u equals een van beide in of notIn.To resolve this error message, change equals to either in or notIn.

De [*] alias evaluerenEvaluating the [*] alias

Aliassen ** [ * ** die aan hun naam zijn gekoppeld, geven aan dat het type een _array_is.Aliases that have [*] attached to their name indicate the type is an array. In plaats van de waarde van ** [ * ** de gehele array te evalueren, is het mogelijk om elk element van de array afzonderlijk te evalueren, met logisch EN tussen hen.Instead of evaluating the value of the entire array, [*] makes it possible to evaluate each element of the array individually, with logical AND between them. Er zijn drie standaardscenario's die dit per artikel evaluatie is nuttig in: Geen, Any, of Alle elementen overeenkomen.There are three standard scenarios this per item evaluation is useful in: None, Any, or All elements match. Gebruik voor complexe scenario's het aantal.For complex scenarios, use count.

De beleidsengine activeert het effect in dan alleen wanneer de als-regel als waar wordt geëvalueerd.The policy engine triggers the effect in then only when the if rule evaluates as true. Dit feit is belangrijk om te ** [ * ** begrijpen in de context van de manier waarop elk afzonderlijk element van de array evalueert.This fact is important to understand in context of the way [*] evaluates each individual element of the array.

De voorbeeldbeleidsregel voor de onderstaande scenariotabel:The example policy rule for the scenario table below:

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

De ipRules-array is als volgt voor de onderstaande scenariotabel:The ipRules array is as follows for the scenario table below:

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

Voor elke voorwaarde hieronder, vervangen <field> door "field": "Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].value".For each condition example below, replace <field> with "field": "Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].value".

De volgende resultaten zijn het resultaat van de combinatie van de voorwaarde en de voorbeeldbeleidsregel en array van bestaande waarden hierboven:The following outcomes are the result of the combination of the condition and the example policy rule and array of existing values above:

VoorwaardeCondition ResultaatOutcome ScenarioScenario UitlegExplanation
{<field>,"notEquals":"127.0.0.1"} NietsNothing NoneNone match Eén arrayelement evalueert als vals (127.0.0.1 != 127.0.0.1) en één als waar (127.0.0.1 != 192.168.1.1), dus de voorwaarde notEquals is vals en het effect wordt niet geactiveerd.One array element evaluates as false (127.0.0.1 != 127.0.0.1) and one as true (127.0.0.1 != 192.168.1.1), so the notEquals condition is false and the effect isn't triggered.
{<field>,"notEquals":"10.0.4.1"} BeleidseffectPolicy effect NoneNone match Beide matrixelementen evalueren als waar (10.0.4.1 != 127.0.0.1 en 10.0.4.1 != 192.168.1.1), zodat de voorwaarde notEquals waar is en het effect wordt geactiveerd.Both array elements evaluate as true (10.0.4.1 != 127.0.0.1 and 10.0.4.1 != 192.168.1.1), so the notEquals condition is true and the effect is triggered.
"not":{<field>,"notEquals":"127.0.0.1" } BeleidseffectPolicy effect Een of meer overeenkomstOne or more match Eén arrayelement evalueert als vals (127.0.0.1 != 127.0.0.1) en één als waar (127.0.0.1 != 192.168.1.1), dus de voorwaarde notEquals is vals.One array element evaluates as false (127.0.0.1 != 127.0.0.1) and one as true (127.0.0.1 != 192.168.1.1), so the notEquals condition is false. De logische operator evalueert als waar (niet vals), dus het effect wordt geactiveerd.The logical operator evaluates as true (not false), so the effect is triggered.
"not":{<field>,"notEquals":"10.0.4.1"} NietsNothing Een of meer overeenkomstOne or more match Beide matrixelementen evalueren als waar (10.0.4.1 != 127.0.0.1 en 10.0.4.1 != 192.168.1.1), dus de voorwaarde notEquals is waar.Both array elements evaluate as true (10.0.4.1 != 127.0.0.1 and 10.0.4.1 != 192.168.1.1), so the notEquals condition is true. De logische operator evalueert als false (niet waar), dus het effect wordt niet geactiveerd.The logical operator evaluates as false (not true), so the effect isn't triggered.
"not":{<field>,"Equals":"127.0.0.1"} BeleidseffectPolicy effect Niet alle overeenkomenNot all match Eén arrayelement evalueert als waar (127.0.0.1 == 127.0.0.1) en één als vals (127.0.0.1 == 192.168.1.1), dus de voorwaarde Gelijken is vals.One array element evaluates as true (127.0.0.1 == 127.0.0.1) and one as false (127.0.0.1 == 192.168.1.1), so the Equals condition is false. De logische operator evalueert als waar (niet vals), dus het effect wordt geactiveerd.The logical operator evaluates as true (not false), so the effect is triggered.
"not":{<field>,"Equals":"10.0.4.1"} BeleidseffectPolicy effect Niet alle overeenkomenNot all match Beide matrixelementen evalueren als false (10.0.4.1 == 127.0.0.1 en 10.0.4.1 == 192.168.1.1).1), dus de voorwaarde Gelijken is vals.Both array elements evaluate as false (10.0.4.1 == 127.0.0.1 and 10.0.4.1 == 192.168.1.1), so the Equals condition is false. De logische operator evalueert als waar (niet vals), dus het effect wordt geactiveerd.The logical operator evaluates as true (not false), so the effect is triggered.
{<field>,"Equals":"127.0.0.1"} NietsNothing Alle overeenkomenAll match Eén arrayelement evalueert als waar (127.0.0.1 == 127.0.0.1) en één als vals (127.0.0.1 == 192.168.1.1), zodat de voorwaarde Gelijken vals is en het effect niet wordt geactiveerd.One array element evaluates as true (127.0.0.1 == 127.0.0.1) and one as false (127.0.0.1 == 192.168.1.1), so the Equals condition is false and the effect isn't triggered.
{<field>,"Equals":"10.0.4.1"} NietsNothing Alle overeenkomenAll match Beide matrixelementen evalueren als false (10.0.4.1 == 127.0.0.1 en 10.0.4.1 == 192.168.1.1.1), dus de voorwaarde Gelijken is vals en het effect wordt niet geactiveerd.Both array elements evaluate as false (10.0.4.1 == 127.0.0.1 and 10.0.4.1 == 192.168.1.1), so the Equals condition is false and the effect isn't triggered.

Het toeteappende effect en de arraysThe append effect and arrays

Het toesteleffect gedraagt zich anders, afhankelijk van of ** [ * ** het veld details een alias is of niet.The append effect behaves differently depending on if the details.field is a [*] alias or not.

  • Wanneer u ** [ * ** geen alias hebt, vervangt de toevoegen de hele array door de eigenschap valueWhen not a [*] alias, append replaces the entire array with the value property
  • Wanneer ** [ * ** een alias de waardeeigenschap toevoegt aan de bestaande array of de nieuwe array maaktWhen a [*] alias, append adds the value property to the existing array or creates the new array

Zie de voorbeelden voor het toevoegen van voorbeeldenvoor meer informatie.For more information, see the append examples.

Volgende stappenNext steps