Szabályzatok létrehozása tömbtulajdonságokhoz az Azure-erőforrásokon

Az Azure Resource Manager tulajdonságai általában sztringekként és logikai értékekként vannak definiálva. Ha létezik egy-a-többhöz kapcsolat, az összetett tulajdonságok tömbökként lesznek definiálva. A Azure Policy tömböket többféleképpen használják:

Ez a cikk a Azure Policy által használt összes felhasználást ismerteti, és számos példadefiníciót tartalmaz.

Paramétertömbök

Paramétertömb definiálása

A paraméter tömbként való definiálása lehetővé teszi a szabályzat rugalmasságát, ha több értékre van szükség. Ez a szabályzatdefiníció lehetővé teszi az allowedLocations paraméter és az alapértelmezett értékek egyetlen helyét az eastus2-be:

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

Mivel a típussztring volt, a szabályzat hozzárendelésekor csak egy érték állítható be. Ha ez a szabályzat van hozzárendelve, a hatókörben lévő erőforrások csak egyetlen Azure-régióban engedélyezettek. A legtöbb szabályzatdefiníciónak engedélyeznie kell a jóváhagyott lehetőségek listáját, például az eastus2, eastus és westus2 engedélyezését.

Ha a szabályzatdefiníciót több beállítás engedélyezéséhez szeretné létrehozni, használja a tömbtípust. Ugyanez a szabályzat a következőképpen írható át:

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

    }
}

Megjegyzés

A szabályzatdefiníció mentése után a paraméter típustulajdonságát nem lehet módosítani.

Ez az új paraméterdefiníció egynél több értéket vesz igénybe a szabályzat-hozzárendelés során. Ha a tömbtulajdonság engedélyezve vanÉrtékek definiálva, a hozzárendelés során elérhető értékek tovább korlátozódnak az előre definiált választási lehetőségek listájára. Az allowedValues használata nem kötelező.

Értékek átadása paramétertömbbe a hozzárendelés során

Amikor a szabályzatot a Azure Portal keresztül rendeli hozzá, a tömbtípusú paraméter egyetlen szövegmezőként jelenik meg. A tipp azt mondja: "Use ; az értékek elkülönítéséhez. (pl. London; New York)". Ha az eastus2, eastus és westus2 engedélyezett helyértékét szeretné átadni a paraméternek, használja a következő sztringet:

eastus2;eastus;westus2

A paraméterérték formátuma eltérő az Azure CLI, a Azure PowerShell vagy a REST API használatakor. Az értékek egy JSON-sztringen keresztül lesznek átadva, amely a paraméter nevét is tartalmazza.

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

Ha ezt a sztringet minden SDK-val szeretné használni, használja a következő parancsokat:

Tömbök használata feltételek között

In és notIn

A in és notIn a feltételek csak tömbértékekkel működnek. Ellenőrzik egy érték meglétét egy tömbben. A tömb lehet egy literál JSON-tömb vagy egy tömbparaméterre mutató hivatkozás. Például:

{
      "field": "tags.environment",
      "in": [ "dev", "test" ]
}
{
      "field": "location",
      "notIn": "[parameters('allowedLocations')]"
}

Értékszám

Az értékszám kifejezés megszámolja, hogy hány tömbtag felel meg egy feltételnek. Lehetővé teszi, hogy ugyanazt a feltételt többször is kiértékelje, különböző értékeket használva az egyes iterációkban. Az alábbi feltétel például azt ellenőrzi, hogy az erőforrás neve megfelel-e egy mintatömbből származó mintának:

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

A kifejezés kiértékeléséhez Azure Policy háromszor értékeli ki a where feltételt, egyszer az egyes tagok [ "test*", "dev*", "prod*" ]esetében, megszámolva, hogy hányszor lett kiértékelve.true Minden iterációban az aktuális tömbtag értéke a által definiált count.nameindexnévvel pattern van párosítva. Ez az érték ezután egy speciális sablonfüggvény meghívásával hivatkozható a where feltételen belül: current('pattern').

Iteráció current('pattern') visszaadott érték
1 "test*"
2 "dev*"
3 "prod*"

A feltétel csak akkor igaz, ha az eredményszám nagyobb, mint 0.

Ha a fenti feltételt általánosabbá szeretné tenni, használjon paraméterhivatkozást literál tömb helyett:

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

Ha az értékszám kifejezés nincs más számlálókifejezés alatt, nem kötelező, count.name és a current() függvény argumentumok nélkül is használható:

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

Az értékszám összetett objektumok tömbjait is támogatja, így összetettebb feltételeket is lehetővé tesz. Az alábbi feltétel például meghatároz egy kívánt címkeértéket az egyes névmintákhoz, és ellenőrzi, hogy az erőforrás neve megegyezik-e a mintával, de nem rendelkezik-e a szükséges címkeértékekkel:

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

Hasznos példákért tekintse meg az értékszámra vonatkozó példákat.

Hivatkozás a tömberőforrás tulajdonságaira

Sok használati esethez tömbtulajdonságok használata szükséges a kiértékelt erőforrásban. Egyes esetekben egy teljes tömbre kell hivatkozni (például ellenőrizni kell a hosszát). Másoknak feltételt kell alkalmazniuk minden egyes tömbtagra (például győződjön meg arról, hogy az összes tűzfalszabály blokkolja az internetről való hozzáférést). A Azure Policy erőforrás-tulajdonságokra való hivatkozásának különböző módjainak megértése, és hogy ezek a hivatkozások hogyan viselkednek, amikor tömbtulajdonságokra hivatkoznak, az e forgatókönyveket lefedő feltételek írásának kulcsa.

Hivatkozás az erőforrás tulajdonságaira

Az erőforrás-tulajdonságokra Azure Policy aliasok használatával hivatkozhat. Az erőforrástulajdonságok értékeire kétféleképpen hivatkozhat a Azure Policy:

  • Mezőfeltétel használatával ellenőrizze, hogy az összes kijelölt erőforrástulajdonság megfelel-e egy feltételnek. Példa:

    {
      "field" : "Microsoft.Test/resourceType/property",
      "equals": "value"
    }
    
  • Egy tulajdonság értékének eléréséhez használja field() a függvényt. Példa:

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

A mezőfeltétel implicit "minden" viselkedéssel rendelkezik. Ha az alias értékgyűjteményt jelöl, ellenőrzi, hogy minden egyes érték megfelel-e a feltételnek. A field() függvény az alias as-is által képviselt értékeket adja vissza, amelyeket aztán más sablonfüggvények is kezelhetnek.

Hivatkozás tömbmezőkre

A tömberőforrás-tulajdonságokat két különböző típusú alias képviseli. Egy "normál" alias és a hozzá csatolt tömbaliasok[*]:

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

Hivatkozás a tömbre

Az első alias egyetlen értéket jelöl, a kérelem tartalmából származó tulajdonság értékét stringArray . Mivel a tulajdonság értéke tömb, a szabályzatfeltételek esetében nem hasznos. Például:

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

Ez a feltétel a teljes stringArray tömböt egyetlen sztringértékhez hasonlítja. A legtöbb feltétel, például equalsa , csak a sztringértékeket fogadja el, így a tömbök és a sztringek összehasonlítására nincs sok szükség. A tömbtulajdonságra való hivatkozás fő forgatókönyve az, ha ellenőrzi, hogy létezik-e:

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

A függvény esetében a field() visszaadott érték a kérelem tartalmából származó tömb, amely a tömbargumentumokat elfogadó támogatott sablonfüggvények bármelyikével használható. A következő feltétel például azt ellenőrzi, hogy a hossza stringArray nagyobb-e 0-nál:

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

Hivatkozás a tömbtagok gyűjteményére

A szintaxist [*] használó aliasok egy tömbtulajdonságból kiválasztott tulajdonságértékek gyűjteményét jelölik, amely különbözik a tömbtulajdonság kiválasztásától. Ebben az esetben Microsoft.Test/resourceType/stringArray[*]egy gyűjteményt ad vissza, amely a () összes tagját tartalmazta stringArray. Ahogy korábban említettük, a field feltétel ellenőrzi, hogy az összes kijelölt erőforrástulajdonság megfelel-e a feltételnek, ezért a következő feltétel csak akkor igaz, ha az összes tag stringArray értéke "érték".

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

Ha a tömb üres, a feltétel igaz értékre lesz értékelve, mert a tömb egyik tagja sem sérült. Ebben a forgatókönyvben javasoljuk, hogy inkább a darabszám kifejezést használja. Ha a tömb objektumokat tartalmaz, egy [*] alias használatával minden egyes tömbtagból kiválasztható egy adott tulajdonság értéke. Példa:

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

Ez a feltétel akkor igaz, ha az összes property tulajdonság objectArray értéke megegyezik a értékkel "value". További példákért lásd: További [*] alias-példák.

Ha a függvényt tömbaliasra field() hivatkozik, a visszaadott érték az összes kijelölt érték tömbje. Ez a viselkedés azt jelenti, hogy a függvény gyakori használati esete, a field() sablonfüggvények erőforrás-tulajdonságértékekre való alkalmazásának lehetősége korlátozott. Ebben az esetben csak azok a sablonfüggvények használhatók, amelyek tömbargumentumokat fogadnak el. A tömb hossza például lekérhető a következővel [length(field('Microsoft.Test/resourceType/objectArray[*].property'))]: . Összetettebb forgatókönyvek azonban, mint például a sablonfüggvény alkalmazása az egyes tömbtagokra, és a kívánt értékhez való összehasonlítása csak a count kifejezés használatakor lehetséges. További információ: Mezőszám kifejezés.

Összegzésként tekintse meg a következő példaerőforrás-tartalmat és a különböző aliasok által visszaadott kijelölt értékeket:

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

Ha a mezőfeltételt a példaerőforrás-tartalomban használja, az eredmények a következők:

Alias Kiválasztott értékek
Microsoft.Test/resourceType/missingArray null
Microsoft.Test/resourceType/missingArray[*] Üres értékgyűjtemény.
Microsoft.Test/resourceType/missingArray[*].property Üres értékgyűjtemény.
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

Ha a függvényt a field() példaerőforrás-tartalomban használja, az eredmények a következők:

Expression Visszaadott érték
[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]

Mezőszámkifejezések

A mezőszámkifejezések megszámolják, hogy hány tömbtag felel meg egy feltételnek, és hasonlítsa össze a számot egy célértékkel. Count intuitívabb és sokoldalúbb a tömbök feltételekhez viszonyított kiértékeléséhez field . A szintaxis a következő:

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

Feltétel nélkül wherecount használva egyszerűen egy tömb hosszát adja vissza. Az előző szakaszban szereplő példaerőforrás-tartalommal a következő count kifejezés lesz kiértékelve true , mivel stringArray három tagból áll:

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

Ez a viselkedés beágyazott tömbökkel is működik. A rendszer például a következő count kifejezést értékeli ki true , mivel a tömbökben négy tömbtag nestedArray található:

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

Az ereje count ebben a where feltételben van. Ha meg van adva, Azure Policy számba adja a tömbtagokat, és kiértékeli mindegyiket a feltétel alapján, megszámolva, hogy hány tömbtagot értékelt ki.true Pontosabban a where feltétel kiértékelésének minden iterációjában Azure Policy egyetlen tömbtagot választ ki, és kiértékeli az erőforrás tartalmát a where feltétel alapján, mintha én lennék a tömb egyetlen tagja. Ha minden iterációban csak egy tömbtag érhető el, összetett feltételeket alkalmazhat az egyes tömbtagokra.

Példa:

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

A kifejezés kiértékeléséhez count Azure Policy háromszor értékeli ki a where feltételt, egyszer az egyes tagok stringArrayesetében, megszámolva, hogy hányszor lett kiértékelve a értékretrue. Ha a where feltétel a Microsoft.Test/resourceType/stringArray[*] tömbtagokra hivatkozik, ahelyett, hogy az összes tagot kijelöli stringArray, minden alkalommal csak egyetlen tömbtagot jelöl ki:

Iteráció Kijelölt Microsoft.Test/resourceType/stringArray[*] értékek where Kiértékelési eredmény
1 "a" true
2 "b" false
3 "c" false

A count visszaadott érték 1.

Íme egy összetettebb kifejezés:

{
  "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
}
Iteráció Kiválasztott értékek where Kiértékelési eredmény
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

A count visszaadott érték 1.

Az a tény, hogy a kifejezés kiértékelése where a teljes kérelemtartalommal történik (csak a számba vett tömbtag módosításaival) azt jelenti, hogy a where feltétel a tömbön kívüli mezőkre is hivatkozhat:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
      "field": "tags.env",
      "equals": "prod"
    }
  },
  "equals": 0
}
Iteráció Kiválasztott értékek where Kiértékelési eredmény
1 tags.env =>"prod" true
2 tags.env =>"prod" true

A beágyazott darabszámkifejezésekkel feltételeket alkalmazhat beágyazott tömbmezőkre. Az alábbi feltétel például ellenőrzi, hogy a objectArray[*] tömbnek pontosan két tagja van-e, amelyek egy vagy több tagot nestedArray[*] tartalmaznak:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
      "count": {
        "field": "Microsoft.Test/resourceType/objectArray[*].nestedArray[*]"
      },
      "greaterOrEquals": 1
    }
  },
  "equals": 2
}
Iteráció Kiválasztott értékek Beágyazott darabszám kiértékelési eredménye
1 Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>1, 2 nestedArray[*] 2 taggal rendelkezik =>true
2 Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>3, 4 nestedArray[*] 2 taggal rendelkezik =>true

Mivel mindkét tagnak objectArray[*] két tagból álló gyermektömbje nestedArray[*] van, a külső számkifejezés a következőt adja 2vissza: .

Összetettebb példa: ellenőrizze, hogy a objectArray[*] tömbnek pontosan két tagja nestedArray[*] van-e, és a tagok száma megegyezik vagy 23:

{
  "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
}
Iteráció Kiválasztott értékek Beágyazott darabszám kiértékelési eredménye
1 Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>1, 2 nestedArray[*] contains 2 =>true
2 Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>3, 4 nestedArray[*] contains 3 =>true

Mivel mindkét tag rendelkezik objectArray[*] olyan gyermektömbtelnestedArray[*], amely vagy 3a értéket tartalmazza2, a külső számláló kifejezés a következőt 2adja vissza: .

Megjegyzés

A beágyazott mezőszámkifejezések csak beágyazott tömbökre hivatkozhatnak. A beágyazott tömbre hivatkozó Microsoft.Test/resourceType/objectArray[*] darabszámkifejezés például tartalmazhat beágyazott darabszámot a beágyazott tömbbenMicrosoft.Test/resourceType/objectArray[*].nestedArray[*], de nem rendelkezhet beágyazott számkifejezéssel.Microsoft.Test/resourceType/stringArray[*]

Az aktuális tömbtag elérése sablonfüggvényekkel

Sablonfüggvények használata esetén a current() függvénnyel elérheti az aktuális tömbtag értékét vagy bármely tulajdonságának értékeit. Az aktuális tömbtag értékének eléréséhez adja át a függvénynek a függvényben definiált count.field aliast vagy annak bármely gyermekaliasát argumentumként current() . Például:

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

Iteráció current() visszaadott érték where Kiértékelési eredmény
1 A értéke property a következő első tagjában objectArray[*]: value1 true
2 A értéke property a következő első tagjában objectArray[*]: value2 true

A mezőfüggvény azon belül, ahol a feltételek

A field() függvény az aktuális tömbtag értékének elérésére is használható, feltéve, hogy a számkifejezés nem egy létezési feltételen belül van (field() a függvény mindig az if feltételben kiértékelt erőforrásra hivatkozik). A kiértékelt tömbre való hivatkozás viselkedése field() a következő fogalmakon alapul:

  1. A tömbaliasok az összes tömbtagból kiválasztott értékek gyűjteményére vannak feloldva.
  2. field() a tömbaliasokra hivatkozó függvények a kijelölt értékekkel rendelkező tömböt adnak vissza.
  3. A feltételen belüli where megszámlált tömbaliasra való hivatkozás egy gyűjteményt ad vissza az aktuális iterációban kiértékelt tömbtagból kiválasztott egyetlen értékkel.

Ez a viselkedés azt jelenti, hogy ha a megszámlált tömbtagra hivatkozik a feltételen belül where egy field() függvénnyel, akkor egyetlen taggal rendelkező tömböt ad vissza. Előfordulhat, hogy ez a viselkedés nem intuitív, de összhangban van azzal a gondolattal, hogy a tömbaliasok mindig a kiválasztott tulajdonságok gyűjteményét adnak vissza. Bemutatunk egy példát:

{
  "count": {
    "field": "Microsoft.Test/resourceType/stringArray[*]",
    "where": {
      "field": "Microsoft.Test/resourceType/stringArray[*]",
      "equals": "[field('Microsoft.Test/resourceType/stringArray[*]')]"
    }
  },
  "equals": 0
}
Iteráció Kifejezésértékek where Kiértékelési eredmény
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

Ezért ha hozzá kell férni a megszámlált tömbalias értékéhez egy field() függvénnyel, ennek módja az, hogy egy first() sablonfüggvénnyel burkoljuk:

{
  "count": {
    "field": "Microsoft.Test/resourceType/stringArray[*]",
    "where": {
      "field": "Microsoft.Test/resourceType/stringArray[*]",
      "equals": "[first(field('Microsoft.Test/resourceType/stringArray[*]'))]"
    }
  }
}
Iteráció Kifejezésértékek where Kiértékelési eredmény
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

Hasznos példákért tekintse meg a Mezőszám példákat.

Tömbök módosítása

Az erőforrás tulajdonságainak hozzáfűzése és módosítása létrehozás vagy frissítés során. Tömbtulajdonságok használatakor ezeknek az effektusoknak a viselkedése attól függ, hogy a művelet megpróbálja-e módosítani a (z) [*] aliast, vagy sem:

Megjegyzés

modify Az effektus aliasokkal való használata jelenleg előzetes verzióban érhető el.

Alias Hatás Eredmény
Microsoft.Storage/storageAccounts/networkAcls.ipRules append Azure Policy hozzáfűzi az effektus részleteiben megadott teljes tömböt, ha hiányzik.
Microsoft.Storage/storageAccounts/networkAcls.ipRules modifyművelettel add Azure Policy hozzáfűzi az effektus részleteiben megadott teljes tömböt, ha hiányzik.
Microsoft.Storage/storageAccounts/networkAcls.ipRules modifyművelettel addOrReplace Azure Policy hozzáfűzi az effektus részleteiben megadott teljes tömböt, ha hiányzik vagy lecseréli a meglévő tömböt.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*] append Azure Policy hozzáfűzi az effektus részleteiben megadott tömbtagot.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*] modifyművelettel add Azure Policy hozzáfűzi az effektus részleteiben megadott tömbtagot.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*] modifyművelettel addOrReplace Azure Policy eltávolítja az összes meglévő tömbtagot, és hozzáfűzi az effektus részleteiben megadott tömbtagot.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].action append Azure Policy minden tömbtag tulajdonságához action hozzáfűz egy értéket.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].action modifyművelettel add Azure Policy minden tömbtag tulajdonságához action hozzáfűz egy értéket.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].action modifyművelettel addOrReplace Azure Policy hozzáfűzi vagy lecseréli az egyes tömbtagok meglévő action tulajdonságát.

További információkért tekintse meg a hozzáfűzési példákat.

További [*] alias-példák

Javasoljuk, hogy a mezőszámkifejezések használatával ellenőrizze, hogy a kérelem tartalmában lévő tömb "összes" vagy "bármelyik" tagja megfelel-e egy feltételnek. Néhány egyszerű feltétel esetén azonban ugyanezt az eredményt egy tömbalias mezőkiegészítő használatával is el lehet érni, a Tömbtagok gyűjteményre való hivatkozás című szakaszban leírtak szerint. Ez a minta olyan szabályzatszabályokban lehet hasznos, amelyek túllépik az engedélyezett darabszám-kifejezések korlátját. Íme néhány példa a gyakori használati esetekre:

Az alábbi példaszabályzat az alábbi forgatókönyvtáblához:

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

Az ipRules tömb a következő az alábbi forgatókönyvtáblához:

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

Az alábbi feltételek mindegyik példájánál cserélje le a elemet <field> a következőre "field": "Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].value": .

A következő eredmények a feltétel és a fenti példaszabály és a meglévő értékek tömbjének kombinációjából adódnak:

Feltétel Eredmény Eset Magyarázat
{<field>,"notEquals":"127.0.0.1"} Semmit Nincs egyezés Egy tömbelem hamis (127.0.0.1 != 127.0.0.1) és egy igaz (127.0.0.1 != 192.168.1.1) értéket ad vissza, így a notEquals feltétel hamis , és a hatás nem aktiválódik.
{<field>,"notEquals":"10.0.4.1"} Szabályzat hatása Nincs egyezés Mindkét tömbelem kiértékelése igaz (10.0.4.1 != 127.0.0.1 és 10.0.4.1 != 192.168.1.1), így a notEquals feltétel igaz , és a hatás aktiválódik.
"not":{<field>,"notEquals":"127.0.0.1" } Szabályzat hatása Egy vagy több egyezés Egy tömbelem hamis (127.0.0.1 != 127.0.0.1) és egy igaz (127.0.0.1 != 192.168.1.1) értéket ad vissza, így a notEquals feltétel hamis. A logikai operátor igaz (nemhamis) értéket ad vissza, így a hatás aktiválódik.
"not":{<field>,"notEquals":"10.0.4.1"} Semmit Egy vagy több egyezés Mindkét tömbelem kiértékelése igaz (10.0.4.1 != 127.0.0.1 és 10.0.4.1 != 192.168.1.1), így a notEquals feltétel igaz. A logikai operátor hamis (nemigaz) értéket ad vissza, így a hatás nem aktiválódik.
"not":{<field>,"Equals":"127.0.0.1"} Szabályzat hatása Nem minden egyezés Az egyik tömbelem igaz (127.0.0.1 == 127.0.0.1) és egy hamis (127.0.0.1 == 192.168.1.1), így az Egyenlő feltétel hamis. A logikai operátor igaz (nemhamis) értéket ad vissza, így a hatás aktiválódik.
"not":{<field>,"Equals":"10.0.4.1"} Szabályzat hatása Nem minden egyezés Mindkét tömbelem kiértékelése hamis (10.0.4.1 == 127.0.0.1 és 10.0.4.1 == 192.168.1.1), így az Egyenlő feltétel hamis. A logikai operátor igaz (nemhamis) értéket ad vissza, így a hatás aktiválódik.
{<field>,"Equals":"127.0.0.1"} Semmit Minden egyezés Egy tömbelem igaz (127.0.0.1 == 127.0.0.1) és egy hamis (127.0.0.1 == 192.168.1.1) értéket ad vissza, így az Egyenlő feltétel hamis , és az eredmény nem aktiválódik.
{<field>,"Equals":"10.0.4.1"} Semmit Minden egyezés Mindkét tömbelem kiértékelése hamis (10.0.4.1 == 127.0.0.1 és 10.0.4.1 == 192.168.1.1), így az Egyenlőség feltétel hamis , és az hatás nem aktiválódik.

Következő lépések