Delen via

Beleidsregels maken voor matrixeigenschappen in Azure-resources

  • Artikel

Eigenschappen van Azure Resource Manager worden meestal gedefinieerd als tekenreeksen en booleaanse waarden. Wanneer er een een-op-veel-relatie bestaat, worden complexe eigenschappen in plaats daarvan gedefinieerd als matrices. In Azure Policy worden matrices op verschillende manieren gebruikt:

Dit artikel behandelt elk gebruik door Azure Policy en bevat verschillende voorbeelddefinities.

Parametermatrices

Een parametermatrix definiëren

Als u een parameter als matrix definieert, kan de beleidsflexiteit worden aangepast wanneer er meer dan één waarde nodig is. Deze beleidsdefinitie staat elke locatie toe voor de parameter allowedLocations en standaardwaarden naar eastus2:

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

Zoals het type tekenreeks was, kan slechts één waarde worden ingesteld bij het toewijzen van het beleid. Als dit beleid is toegewezen, zijn resources binnen het bereik alleen toegestaan binnen één Azure-regio. De meeste beleidsdefinities moeten een lijst met goedgekeurde opties toestaan, zoals eastus2, eastus en westus2.

Als u de beleidsdefinitie wilt maken om meerdere opties toe te staan, gebruikt u het matrixtype. Hetzelfde beleid kan als volgt worden herschreven:

"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 typeeigenschap voor een parameter niet meer worden gewijzigd.

Deze nieuwe parameterdefinitie neemt meer dan één waarde in beslag tijdens de beleidstoewijzing. Wanneer de matrixeigenschap AllowedValues is gedefinieerd, worden de waarden die beschikbaar zijn tijdens de toewijzing verder beperkt tot de vooraf gedefinieerde lijst met keuzes. Het gebruik van allowedValues is optioneel.

Waarden doorgeven aan een parametermatrix tijdens de toewijzing

Wanneer u het beleid toewijst via Azure Portal, wordt een parameter van het type matrix weergegeven als één tekstvak. De hint zegt : "Gebruik ; om waarden te scheiden. (bijvoorbeeld Londen; New York)". Gebruik de volgende tekenreeks om de toegestane locatiewaarden van eastus2, eastus en westus2 door te geven aan de parameter:

eastus2;eastus;westus2

De indeling voor de parameterwaarde verschilt wanneer u Azure CLI, Azure PowerShell of de REST API gebruikt. De waarden worden doorgegeven via een JSON-tekenreeks die ook de naam van de parameter bevat.

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

Als u deze tekenreeks voor elke SDK wilt gebruiken, gebruikt u de volgende opdrachten:

Matrices gebruiken in voorwaarden

In en notIn

De in voorwaarden notIn werken alleen met matrixwaarden. Ze controleren het bestaan van een waarde in een matrix. De matrix kan een letterlijke JSON-matrix of een verwijzing naar een matrixparameter zijn. Voorbeeld:

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

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

Aantal waarden

De expressie voor het aantal waarden telt hoeveel matrixleden voldoen aan een voorwaarde. Het biedt een manier om dezelfde voorwaarde meerdere keren te evalueren met behulp van verschillende waarden voor elke iteratie. Met de volgende voorwaarde wordt bijvoorbeeld gecontroleerd of de resourcenaam overeenkomt met een patroon uit een matrix met patronen:

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

Om de expressie te evalueren, evalueert Azure Policy de where voorwaarde drie keer, één keer voor elk lid van [ "test*", "dev*", "prod*" ], waarbij wordt geteld hoe vaak deze is geëvalueerd true. Bij elke iteratie wordt de waarde van het huidige matrixlid gekoppeld aan de pattern indexnaam die is gedefinieerd door count.name. Deze waarde kan vervolgens binnen de where voorwaarde worden verwezen door een speciale sjabloonfunctie aan te roepen: current('pattern').

Iteratie current('pattern') geretourneerde waarde
1 "test*"
2 "dev*"
3 "prod*"

De voorwaarde is alleen waar als het aantal resulterende waarden groter is dan 0.

Als u de bovenstaande voorwaarde algemener wilt maken, gebruikt u parameterreferentie in plaats van een letterlijke matrix:

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

Wanneer de expressie voor het tellen van waarden niet onder een andere expressie voor aantallen valt, count.name is dit optioneel en kan de current() functie zonder argumenten worden gebruikt:

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

Het aantal waarden biedt ook ondersteuning voor matrices van complexe objecten, waardoor complexere voorwaarden mogelijk zijn. De volgende voorwaarde definieert bijvoorbeeld een gewenste tagwaarde voor elk naampatroon en controleert of de resourcenaam overeenkomt met het patroon, maar heeft niet de vereiste tagwaarde:

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

Zie voorbeelden van het aantal waarden voor nuttige voorbeelden.

Verwijzen naar eigenschappen van matrixresources

Voor veel gebruiksvoorbeelden is het werken met matrixeigenschappen in de geëvalueerde resource vereist. Voor sommige scenario's moet worden verwezen naar een hele matrix (bijvoorbeeld het controleren van de lengte). Andere vereisen het toepassen van een voorwaarde op elk afzonderlijk matrixlid (zorg er bijvoorbeeld voor dat alle firewallregels de toegang vanaf internet blokkeren). Informatie over de verschillende manieren waarop Azure Policy kan verwijzen naar resource-eigenschappen en hoe deze verwijzingen zich gedragen wanneer ze verwijzen naar matrixeigenschappen, is de sleutel voor het schrijven van voorwaarden die betrekking hebben op deze scenario's.

Verwijzen naar resource-eigenschappen

Resource-eigenschappen kunnen worden verwezen door Azure Policy met behulp van aliassen : er zijn twee manieren om te verwijzen naar de waarden van een resource-eigenschap in Azure Policy:

  • Gebruik veldvoorwaarde om te controleren of alle geselecteerde resource-eigenschappen voldoen aan een voorwaarde. Voorbeeld:

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

  • Gebruik field() de functie om toegang te krijgen tot de waarde van een eigenschap. Voorbeeld:

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

De veldvoorwaarde heeft een impliciet 'all'-gedrag. Als de alias een verzameling waarden vertegenwoordigt, wordt gecontroleerd of alle afzonderlijke waarden voldoen aan de voorwaarde. De field() functie retourneert de waarden die worden vertegenwoordigd door de alias als zodanig, die vervolgens kunnen worden bewerkt door andere sjabloonfuncties.

Naar matrixvelden verwijzen

Eigenschappen van matrixresources worden vertegenwoordigd door twee verschillende typen aliassen. Eén 'normale' alias en matrixaliassen die eraan zijn [*] gekoppeld:

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

Naar de matrix verwijzen

De eerste alias vertegenwoordigt één waarde, de waarde van de eigenschap van stringArray de aanvraaginhoud. Omdat de waarde van die eigenschap een matrix is, is deze niet nuttig in beleidsvoorwaarden. Voorbeeld:

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

Met deze voorwaarde wordt de hele stringArray matrix vergeleken met één tekenreekswaarde. De meeste voorwaarden, waaronder equals, accepteren alleen tekenreekswaarden, dus er is niet veel gebruik in het vergelijken van een matrix met een tekenreeks. Het belangrijkste scenario waarin naar de matrixeigenschap wordt verwezen, is handig bij het controleren of deze bestaat:

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

Met de field() functie is de geretourneerde waarde de matrix van de aanvraaginhoud, die vervolgens kan worden gebruikt met een van de ondersteunde sjabloonfuncties die matrixargumenten accepteren. Met de volgende voorwaarde wordt bijvoorbeeld gecontroleerd of de lengte groter stringArray is dan 0:

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

Verwijzen naar de verzameling matrixleden

Aliassen die de [*] syntaxis gebruiken, vertegenwoordigen een verzameling eigenschapswaarden die zijn geselecteerd in een matrixeigenschap. Dit is anders dan het selecteren van de matrixeigenschap zelf. In het geval van Microsoft.Test/resourceType/stringArray[*], retourneert het een verzameling met alle leden van stringArray. Zoals eerder vermeld, controleert een field voorwaarde of alle geselecteerde resource-eigenschappen voldoen aan de voorwaarde. De volgende voorwaarde is dus alleen waar als alle leden stringArray gelijk zijn aan ''value'.

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

Als de matrix leeg is, resulteert de voorwaarde in waar omdat er geen lid van de matrix in strijd is. In dit scenario is het raadzaam om in plaats daarvan de expressie count te gebruiken. Als de matrix objecten bevat, kan een [*] alias worden gebruikt om de waarde van een specifieke eigenschap van elk matrixlid te selecteren. Voorbeeld:

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

Deze voorwaarde is waar als de waarden van alle property eigenschappen objectArray gelijk zijn aan "value". Zie Aanvullende [*] aliasvoorbeelden voor meer voorbeelden.

Wanneer u de field() functie gebruikt om te verwijzen naar een matrixalias, is de geretourneerde waarde een matrix van alle geselecteerde waarden. Dit gedrag betekent dat de algemene use case van de field() functie, de mogelijkheid om sjabloonfuncties toe te passen op resource-eigenschapswaarden, beperkt is. De enige sjabloonfuncties die in dit geval kunnen worden gebruikt, zijn de functies die matrixargumenten accepteren. Het is bijvoorbeeld mogelijk om de lengte van de matrix op te halen met [length(field('Microsoft.Test/resourceType/objectArray[*].property'))]. Complexere scenario's, zoals het toepassen van een sjabloonfunctie op elk matrixlid en het vergelijken met een gewenste waarde, zijn echter alleen mogelijk wanneer u de count expressie gebruikt. Zie de expressie Veldaantal voor meer informatie.

Als u een samenvatting wilt maken, raadpleegt u de volgende voorbeeldresource-inhoud en de geselecteerde waarden die worden geretourneerd door verschillende aliassen:

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

Wanneer u de veldvoorwaarde voor de voorbeeldresource-inhoud gebruikt, zijn de resultaten als volgt:

Alias Geselecteerde waarden
Microsoft.Test/resourceType/missingArray null
Microsoft.Test/resourceType/missingArray[*] Een lege verzameling waarden.
Microsoft.Test/resourceType/missingArray[*].property Een lege verzameling waarden.
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, , , 234

Wanneer u de field() functie op de voorbeeldresource-inhoud gebruikt, zijn de resultaten als volgt:

Expression Geretourneerde waarde
[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]

Expressies voor het aantal velden

Expressies voor het tellen van velden tellen hoeveel matrixleden voldoen aan een voorwaarde en vergelijk het aantal met een doelwaarde. Count is intuïtiever en veelzijdiger voor het evalueren van matrices in vergelijking met field voorwaarden. De syntaxis is:

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

Als u zonder voorwaarde where wordt gebruikt, count retourneert u gewoon de lengte van een matrix. Met de voorbeeldresource-inhoud uit de vorige sectie wordt de volgende count expressie geëvalueerd op true basis van stringArray drie leden:

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

Dit gedrag werkt ook met geneste matrices. De volgende count expressie wordt bijvoorbeeld geëvalueerd omdat true er vier matrixleden in de nestedArray matrices zijn:

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

De kracht van count is in de where toestand. Wanneer deze is opgegeven, inventariseert Azure Policy de matrixleden en evalueert ze elk op basis van de voorwaarde, met het tellen van het aantal matrixleden dat is truegeëvalueerd. In elke iteratie van de where voorwaardeevaluatie selecteert Azure Policy een enkel matrixlid i en evalueert de resource-inhoud op basis van de where voorwaarde alsof ik het enige lid van de matrix is. Als er slechts één matrixlid beschikbaar is in elke iteratie, kunt u complexe voorwaarden toepassen op elk afzonderlijk matrixlid.

Voorbeeld:

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

Om de count expressie te evalueren, evalueert Azure Policy de where voorwaarde drie keer, één keer voor elk lid van stringArray, waarbij wordt geteld hoe vaak deze is geëvalueerd true. Wanneer de where voorwaarde verwijst naar de Microsoft.Test/resourceType/stringArray[*] matrixleden, in plaats van alle leden te stringArrayselecteren, wordt er slechts één matrixlid geselecteerd wanneer:

Iteratie Geselecteerde Microsoft.Test/resourceType/stringArray[*] waarden where Evaluatieresultaat
1 "a" true
2 "b" false
3 "c" false

De count retourneert 1.

Hier volgt een complexere expressie:

{
  "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
}
Iteratie Geselecteerde waarden where Evaluatieresultaat
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

De count retourneert 1.

Het feit dat de where expressie wordt geëvalueerd op basis van de volledige aanvraaginhoud (met alleen wijzigingen in het matrixlid dat momenteel wordt geïnventariseerd) betekent dat de where voorwaarde ook kan verwijzen naar velden buiten de matrix:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
      "field": "tags.env",
      "equals": "prod"
    }
  },
  "equals": 0
}
Iteratie Geselecteerde waarden where Evaluatieresultaat
1 tags.env =>"prod" true
2 tags.env =>"prod" true

Geneste tellingexpressies kunnen worden gebruikt om voorwaarden toe te passen op geneste matrixvelden. Met de volgende voorwaarde wordt bijvoorbeeld gecontroleerd of de objectArray[*] matrix precies twee leden bevat die nestedArray[*] een of meer leden bevatten:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
      "count": {
        "field": "Microsoft.Test/resourceType/objectArray[*].nestedArray[*]"
      },
      "greaterOrEquals": 1
    }
  },
  "equals": 2
}
Iteratie Geselecteerde waarden Evaluatieresultaat van geneste telling
1 Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>1, 2 nestedArray[*] heeft 2 leden =>true
2 Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>3, 4 nestedArray[*] heeft 2 leden =>true

Omdat beide leden objectArray[*] een onderliggende matrix nestedArray[*] met twee leden hebben, retourneert de buitenste tellingsexpressie 2.

Complexer voorbeeld: controleer of de objectArray[*] matrix precies twee leden heeft met nestedArray[*] alle leden die gelijk zijn aan 2 of 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
}
Iteratie Geselecteerde waarden Evaluatieresultaat van geneste telling
1 Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>1, 2 nestedArray[*] bevat 2 =>true
2 Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>3, 4 nestedArray[*] bevat 3 =>true

Omdat beide leden een objectArray[*] onderliggende matrix nestedArray[*] hebben die een of 2 3beide bevat, retourneert de buitenste tellingsexpressie 2.

Notitie

Geneste expressies voor het aantal velden kunnen alleen verwijzen naar geneste matrices. De expressie voor het aantal waarnaar wordt verwezen Microsoft.Test/resourceType/objectArray[*] , kan bijvoorbeeld een geneste telling hebben die is gericht op de geneste matrix Microsoft.Test/resourceType/objectArray[*].nestedArray[*], maar er kan geen geneste tellingsexpressie zijn gericht Microsoft.Test/resourceType/stringArray[*].

Toegang tot huidig matrixlid met sjabloonfuncties

Wanneer u sjabloonfuncties gebruikt, gebruikt u de current() functie om toegang te krijgen tot de waarde van het huidige matrixlid of de waarden van een van de eigenschappen. Als u toegang wilt krijgen tot de waarde van het huidige matrixlid, geeft u de alias door die is gedefinieerd in count.field of een van de onderliggende aliassen als argument voor de current() functie. Voorbeeld:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
        "value": "[current('Microsoft.Test/resourceType/objectArray[*].property')]",
        "like": "value*"
    }
  },
  "equals": 2
}
Iteratie current() geretourneerde waarde where Evaluatieresultaat
1 De waarde van property in het eerste lid van objectArray[*]: value1 true
2 De waarde van property in het eerste lid van objectArray[*]: value2 true

De veldfunctie binnen waar voorwaarden

De field() functie kan ook worden gebruikt om toegang te krijgen tot de waarde van het huidige matrixlid, zolang de count-expressie zich niet in een bestaansvoorwaarde bevindt (field() functie verwijst altijd naar de resource die in de if-voorwaarde wordt geëvalueerd). Het gedrag van field() het verwijzen naar de geëvalueerde matrix is gebaseerd op de volgende concepten:

  1. Matrixaliassen worden omgezet in een verzameling waarden die zijn geselecteerd van alle matrixleden.
  2. field() functies die verwijzen naar matrixaliassen retourneren een matrix met de geselecteerde waarden.
  3. Als u verwijst naar de getelde matrixalias in de where voorwaarde, wordt een verzameling geretourneerd met één waarde die is geselecteerd in het matrixlid dat wordt geëvalueerd in de huidige iteratie.

Dit gedrag betekent dat wanneer wordt verwezen naar het getelde matrixlid met een field() functie binnen de where voorwaarde, een matrix met één lid wordt geretourneerd. Hoewel dit gedrag mogelijk niet intuïtief is, is het consistent met het idee dat matrixaliassen altijd een verzameling geselecteerde eigenschappen retourneren. Hier volgt een voorbeeld:

{
  "count": {
    "field": "Microsoft.Test/resourceType/stringArray[*]",
    "where": {
      "field": "Microsoft.Test/resourceType/stringArray[*]",
      "equals": "[field('Microsoft.Test/resourceType/stringArray[*]')]"
    }
  },
  "equals": 0
}
Iteratie Expressiewaarden where Evaluatieresultaat
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

Als er dus toegang nodig is tot de waarde van de getelde matrixalias met een field() functie, kunt u dit doen door deze te verpakken met een first() sjabloonfunctie:

{
  "count": {
    "field": "Microsoft.Test/resourceType/stringArray[*]",
    "where": {
      "field": "Microsoft.Test/resourceType/stringArray[*]",
      "equals": "[first(field('Microsoft.Test/resourceType/stringArray[*]'))]"
    }
  }
}
Iteratie Expressiewaarden where Evaluatieresultaat
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

Zie Voorbeelden van het aantal velden voor nuttige voorbeelden.

Matrices wijzigen

De eigenschappen voor toevoegen en wijzigen van wijzigingen in een resource tijdens het maken of bijwerken . Wanneer u met matrixeigenschappen werkt, is het gedrag van deze effecten afhankelijk van of de bewerking de alias [*] probeert te wijzigen of niet:

Notitie

Het gebruik van het modify effect met aliassen is momenteel beschikbaar als preview-versie.

Alias Effect Resultaat
Microsoft.Storage/storageAccounts/networkAcls.ipRules append Azure Policy voegt de volledige matrix toe die is opgegeven in de details van het effect als deze ontbreekt.
Microsoft.Storage/storageAccounts/networkAcls.ipRules modify met add bewerking Azure Policy voegt de volledige matrix toe die is opgegeven in de details van het effect als deze ontbreekt.
Microsoft.Storage/storageAccounts/networkAcls.ipRules modify met addOrReplace bewerking Azure Policy voegt de volledige matrix toe die is opgegeven in de effectdetails als de bestaande matrix ontbreekt of vervangt.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*] append Azure Policy voegt het matrixlid toe dat is opgegeven in de effectdetails.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*] modify met add bewerking Azure Policy voegt het matrixlid toe dat is opgegeven in de effectdetails.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*] modify met addOrReplace bewerking Azure Policy verwijdert alle bestaande matrixleden en voegt het matrixlid toe dat is opgegeven in de details van het effect.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].action append Azure Policy voegt een waarde toe aan de action eigenschap van elk matrixlid.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].action modify met add bewerking Azure Policy voegt een waarde toe aan de action eigenschap van elk matrixlid.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].action modify met addOrReplace bewerking Azure Policy voegt de bestaande action eigenschap van elk matrixlid toe of vervangt deze.

Zie de toevoegvoorbeelden voor meer informatie.

Aanvullende [*] aliasvoorbeelden

Het is raadzaam om de expressies voor het aantal velden te gebruiken om te controleren of 'alle' of 'alle' leden van een matrix in de aanvraaginhoud voldoen aan een voorwaarde. Voor sommige eenvoudige voorwaarden is het echter mogelijk om hetzelfde resultaat te bereiken met behulp van een veldtoegangsman met een matrixalias, zoals beschreven in Verwijzen naar de verzameling matrixleden. Dit patroon kan handig zijn in beleidsregels die de limiet van toegestane tellingsexpressies overschrijden. Hier volgen voorbeelden voor veelvoorkomende gebruiksvoorbeelden:

De voorbeeldbeleidsregel voor de onderstaande scenariotabel:

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

De matrix ipRules is als volgt voor de onderstaande scenariotabel:

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

Vervang voor elk voorbeeld van een voorwaarde hieronder door <field> "field": "Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].value".

De volgende resultaten zijn het resultaat van de combinatie van de voorwaarde en de voorbeeldbeleidsregel en de matrix van bestaande waarden hierboven:

Conditie Resultaat Scenario Uitleg
{<field>,"notEquals":"127.0.0.1"} Niets Geen overeenkomst Eén matrixelement evalueert als onwaar (127.0.0.1 != 127.0.0.1) en één als waar (127.0.0.1 != 192.168.1.1), zodat de voorwaarde notEquals onwaar is en het effect niet wordt geactiveerd.
{<field>,"notEquals":"10.0.4.1"} Beleidseffect Geen overeenkomst 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.
"not":{<field>,"notEquals":"127.0.0.1" } Beleidseffect Een of meer overeenkomsten Eén matrixelement evalueert als onwaar (127.0.0.1 != 127.0.0.1) en één als waar (127.0.0.1 != 192.168.1.1), zodat de voorwaarde notEquals onwaar is. De logische operator evalueert als waar (niet onwaar), dus het effect wordt geactiveerd.
"not":{<field>,"notEquals":"10.0.4.1"} Niets Een of meer overeenkomsten 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. De logische operator evalueert als onwaar (niet waar), dus het effect wordt niet geactiveerd.
"not":{<field>,"Equals":"127.0.0.1"} Beleidseffect Niet alle overeenkomsten Eén matrixelement resulteert in waar (127.0.0.1 == 127.0.0.1) en één als onwaar (127.0.0.1 == 192.168.1.1), zodat de voorwaarde Gelijk aan onwaar is. De logische operator evalueert als waar (niet onwaar), dus het effect wordt geactiveerd.
"not":{<field>,"Equals":"10.0.4.1"} Beleidseffect Niet alle overeenkomsten Beide matrixelementen worden als onwaar geëvalueerd (10.0.4.1 == 127.0.0.1 en 10.0.4.1 == 192.168.1.1), zodat de voorwaarde Gelijk aan onwaar is. De logische operator evalueert als waar (niet onwaar), dus het effect wordt geactiveerd.
{<field>,"Equals":"127.0.0.1"} Niets Alle overeenkomsten Eén matrixelement resulteert in waar (127.0.0.1 == 127.0.0.1) en één als onwaar (127.0.0.1 == 192.168.1.1), zodat de voorwaarde Gelijk aan onwaar is en het effect niet wordt geactiveerd.
{<field>,"Equals":"10.0.4.1"} Niets Alle overeenkomsten Beide matrixelementen worden als onwaar geëvalueerd (10.0.4.1 == 127.0.0.1 en 10.0.4.1 == 192.168.1.1), zodat de voorwaarde Gelijk aan onwaar is en het effect niet wordt geactiveerd.

Volgende stappen