Freigeben über

Richtlinienregel der Azure-Richtliniendefinitionsstruktur

  • Artikel

Die Richtlinienregel besteht aus if und then Blöcken. Im if-Block definieren Sie mindestens eine Bedingung, die angibt, wann die Richtlinie erzwungen wird. Auf diese Bedingungen können logische Operatoren angewendet werden, um das Szenario für eine Richtlinie präzise zu definieren.

Ausführliche Informationen zu den einzelnen Auswirkungen, der Reihenfolge der Auswertung, den Eigenschaften sowie Beispiele finden Sie unter Grundlagen: Auswirkungen von Azure Policy-Definitionen.

Im then-Block definieren Sie die Wirkung, die eintritt, wenn die if-Bedingungen erfüllt sind.

{
  "if": {
      <condition> | <logical operator>
  },
  "then": {
    "effect": "deny | audit | modify | denyAction | append | auditIfNotExists | deployIfNotExists | disabled"
  }
}

Für weitere Informationen zur Richtlinienregel, wechseln Sie zum Richtliniendefinitionsschema.

Logische Operatoren

Folgende logische Operatoren werden unterstützt:

  • "not": {condition or operator}
  • "allOf": [{condition or operator},{condition or operator}]
  • "anyOf": [{condition or operator},{condition or operator}]

Die not-Syntax kehrt das Ergebnis der Bedingung um. Die allOf-Syntax gleicht der logischen and-Operation und erfordert, dass alle Bedingungen erfüllt sind. Die anyOf-Syntax gleicht der logischen or-Operation und erfordert, dass mindestens eine Bedingung erfüllt ist.

Logische Operatoren können geschachtelt werden. Das folgende Beispiel zeigt eine geschachtelte not-Operation innerhalb einer allOf-Operation.

"if": {
  "allOf": [
    {
      "not": {
        "field": "tags",
        "containsKey": "application"
      }
    },
    {
      "field": "type",
      "equals": "Microsoft.Storage/storageAccounts"
    }
  ]
},

Bedingungen

Eine Bedingung überprüft, ob ein Wert bestimmte Kriterien erfüllt. Folgende Bedingungen werden unterstützt:

  • "equals": "stringValue"
  • "notEquals": "stringValue"
  • "like": "stringValue"
  • "notLike": "stringValue"
  • "match": "stringValue"
  • "matchInsensitively": "stringValue"
  • "notMatch": "stringValue"
  • "notMatchInsensitively": "stringValue"
  • "contains": "stringValue"
  • "notContains": "stringValue"
  • "in": ["stringValue1","stringValue2"]
  • "notIn": ["stringValue1","stringValue2"]
  • "containsKey": "keyName"
  • "notContainsKey": "keyName"
  • "less": "dateValue" | "less": "stringValue" | "less": intValue
  • "lessOrEquals": "dateValue" | "lessOrEquals": "stringValue" | "lessOrEquals": intValue
  • "greater": "dateValue" | "greater": "stringValue" | "greater": intValue
  • "greaterOrEquals": "dateValue" | "greaterOrEquals": "stringValue" | "greaterOrEquals": intValue
  • "exists": "bool"

Für less, lessOrEquals, greater und greaterOrEquals, wenn der Eigenschaftentyp nicht mit dem Bedingungstyp übereinstimmt, wird ein Fehler ausgelöst. Zeichenfolgenvergleiche werden mit InvariantCultureIgnoreCase durchgeführt.

Wenn Sie die Bedingungen like und notLike verwenden, geben Sie im Wert einen Platzhalter (*) an. Der Wert darf maximal einen Platzhalter enthalten.

Geben Sie bei Verwendung der Bedingungen match und notMatch ein Hashtag (#) an, um eine Ziffer, ein Fragezeichen (?) für einen Buchstaben zuzuordnen, und einen Punkt (.), der mit einem beliebigen Zeichen übereinstimmt, und jedes andere Zeichen, das mit diesem tatsächlichen Zeichen übereinstimmt. Bei match und notMatch sind Groß-/Kleinschreibung zu beachten, alle anderen Bedingungen, bei denen eine stringValue beurteilt wird, wird die Groß-/Kleinschreibung nicht beachtet. Alternativen bei denen die Groß-/Kleinschreibung nicht beachtet wird sind in matchInsensitively und notMatchInsensitively verfügbar.

Felder

Bedingungen, die auswerten, ob die Werte von Eigenschaften in der Nutzlast der Ressourcenanforderung bestimmte Kriterien erfüllen, können mit einem field Ausdruck gebildet werden. Folgende Felder werden unterstützt:

  • name

  • fullName

    • Gibt den vollständigen Namen der Ressource zurück. Der vollständige Name einer Ressource setzt sich zusammen aus dem Namen der Ressource und den vorangestellten Namen übergeordneter Ressourcen, sofern vorhanden (Beispiel: myServer/myDatabase).

  • kind

  • type

  • location

    • Standortfelder werden normalisiert, um verschiedene Formate zu unterstützen. Beispielsweise werden East US 2 und eastus2 als gleich betrachtet.
    • Verwenden Sie global für Ressourcen, die speicherortagnostisch sind.

  • id

    • Gibt die Ressourcen-ID für die auszuwertende Ressource zurück.
    • Beispiel: /subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myRG/providers/Microsoft.KeyVault/vaults/myVault

  • identity.type

  • tags

  • tags['<tagName>']

    • Diese Klammersyntax unterstützt Tagnamen, die Satzzeichen wie Bindestriche, Punkte oder Leerzeichen enthalten.
    • Wobei tagName der Name des Tags ist, auf das die Bedingung geprüft wird.
    • Beispiele: tags['Acct.CostCenter'] wobei Acct.CostCenter der Name des Tags ist.

  • tags['''<tagName>''']

    • Diese Klammersyntax unterstützt Tagnamen, die Apostrophe enthalten, und verwendet doppelte Apostrophe als Escapezeichen.
    • Wobei tagName der Name des Tags ist, auf das die Bedingung geprüft wird.
    • Beispiel: tags['''My.Apostrophe.Tag'''] wobei 'My.Apostrophe.Tag' der Name des Tags ist.

    Hinweis

    tags.<tagName>, tags[tagName] und tags[tag.with.dots] werden weiterhin als Möglichkeiten zum Deklarieren eines Felds für Tags akzeptiert. Die oben aufgeführten Ausdrücke werden jedoch bevorzugt.

  • Eigenschaftenaliase – Eine Liste finden Sie unter Aliase.

    Hinweis

    Bei field Ausdrücken, die sich auf den Array-Alias [*] beziehen, wird jedes Element im Array einzeln ausgewertet, wobei die Elemente durch ein logisches and verknüpft werden. Weitere Informationen finden Sie unter Verweisen auf Arrayeigenschaften in Ressourcen.

Bedingungen, die field-Ausdrücke verwenden, können die veraltete Richtliniendefinitionssyntax "source": "action" ersetzen, die für Schreibvorgänge verwendet wurde. Beispielsweise wird Folgendes nicht mehr unterstützt:

{
  "source": "action",
  "like": "Microsoft.Network/publicIPAddresses/*"
}

Das gewünschte Verhalten kann jedoch mittels field-Logik realisiert werden:

{
  "field": "type",
  "equals": "Microsoft.Network/publicIPAddresses"
}

Verwenden von Tags mit Parametern

Ein Parameterwert kann an ein Tagfeld übergeben werden. Das Übergeben eines Parameters an ein Tagfeld erhöht die Flexibilität der Richtliniendefinition während der Richtlinienzuweisung.

Im folgenden Beispiel wird mit concat eine Tagfeldsuche nach dem Tag erstellt, das als Namen den Wert des tagName-Parameters aufweist. Wenn dieses Tag nicht vorhanden ist, wird die Auswirkung modify verwendet, um mithilfe der Nachschlagefunktion resourcegroup() das Tag mit dem Wert dieses benannten Tags hinzuzufügen, das für die übergeordnete Ressourcengruppe der überwachten Ressourcen festgelegt ist.

{
  "if": {
    "field": "[concat('tags[', parameters('tagName'), ']')]",
    "exists": "false"
  },
  "then": {
    "effect": "modify",
    "details": {
      "operations": [
        {
          "operation": "add",
          "field": "[concat('tags[', parameters('tagName'), ']')]",
          "value": "[resourcegroup().tags[parameters('tagName')]]"
        }
      ],
      "roleDefinitionIds": [
        "/providers/microsoft.authorization/roleDefinitions/4a9ae827-6dc8-4573-8ac7-8239d42aa03f"
      ]
    }
  }
}

Wert

Bedingungen, die auswerten, ob ein Wert bestimmte Kriterien erfüllt, können mit einem value Ausdruck gebildet werden. Werte können Literale, die Werte von Parametern oder die zurückgegebenen Werte beliebiger unterstützter Vorlagenfunktionen sein.

Warnung

Wenn eine Vorlagenfunktion einen Fehler ergibt, schlägt die Richtlinienauswertung fehl. Eine fehlerhafte Auswertung ist ein implizites deny. Weitere Informationen finden Sie unter Vermeiden von Vorlagenfehlern. Verwenden Sie als enforcementMode den Modus doNotEnforce, um Auswirkungen einer fehlerhaften Auswertung auf neue oder aktualisierte Ressourcen beim Testen und Überprüfen einer neuen Richtliniendefinition zu verhindern.

Beispiele von Werten

Dieses Beispiel einer Richtlinienregel verwendet value, um das Ergebnis der resourceGroup()-Funktion und der zurückgegebenen name-Eigenschaft mit der like-Bedingung *netrg zu vergleichen. Die Regel verweigert Ressourcen, die nicht Microsoft.Network/* type aufweisen, in sämtlichen Ressourcengruppen, deren Name mit *netrg endet.

{
  "if": {
    "allOf": [
      {
        "value": "[resourceGroup().name]",
        "like": "*netrg"
      },
      {
        "field": "type",
        "notLike": "Microsoft.Network/*"
      }
    ]
  },
  "then": {
    "effect": "deny"
  }
}

Diese Beispiel einer Richtlinienregel verwendet value, um zu überprüfen, ob das Ergebnis mehrerer geschachtelter Funktionen equals true ist. Die Regel verweigert alle Ressourcen, die nicht mindestens drei Tags haben.

{
  "mode": "indexed",
  "policyRule": {
    "if": {
      "value": "[less(length(field('tags')), 3)]",
      "equals": "true"
    },
    "then": {
      "effect": "deny"
    }
  }
}

Vermeiden von Vorlagenfehlern

Wenn Sie Vorlagenfunktionen als value verwenden, sind viele komplexe und verschachtelte Funktionen möglich. Wenn eine Vorlagenfunktion einen Fehler ergibt, schlägt die Richtlinienauswertung fehl. Eine fehlerhafte Auswertung ist ein implizites deny. Beispiel für einen value, bei dem in bestimmten Szenarios ein Fehler auftritt:

{
  "policyRule": {
    "if": {
      "value": "[substring(field('name'), 0, 3)]",
      "equals": "abc"
    },
    "then": {
      "effect": "audit"
    }
  }
}

Bei der oben als Beispiel verwendeten Richtlinienregel wird substring() zum Vergleichen der ersten drei Zeichen des name mit abc verwendet. Wenn der name kürzer als drei Zeichen ist, ergibt die substring()-Funktion einen Fehler. Dieser Fehler löst bei der Richtlinie den deny-Effekt aus.

Verwenden Sie stattdessen die if()-Funktion, um zu überprüfen, ob die ersten drei Zeichen des name gleich abc sind, ohne dass ein name, der kürzer als drei Zeichen ist, einen Fehler verursachen kann:

{
  "policyRule": {
    "if": {
      "value": "[if(greaterOrEquals(length(field('name')), 3), substring(field('name'), 0, 3), 'not starting with abc')]",
      "equals": "abc"
    },
    "then": {
      "effect": "audit"
    }
  }
}

Mit der überarbeiteten Richtlinienregel überprüft if() die Länge des name, bevor es versucht, einen substring() für einen Wert mit weniger als drei Zeichen abzurufen. Wenn der name zu kurz ist, wird der Wert, der „nicht mit abc beginnt“, zurückgegeben und mit abc verglichen. Eine Ressource mit einem Kurznamen, der nicht mit abc beginnt, erzeugt zwar immer noch einen Fehler bei der Richtlinienregel, verursacht aber bei der Auswertung keinen Fehler mehr.

Anzahl

Bedingungen, die zählen, wie viele Member eines Arrays bestimmte Kriterien erfüllen, können mithilfe eines count gebildet werden. Häufige Szenarien sind die Überprüfung, ob mindestens einer (at least one of), genau einer (exactly one of), alle (all of) oder keiner (none of) der Arraymember eine Bedingung erfüllt. count wertet jeden Arraymember für einen Bedingungsausdruck aus und fasst die Ergebnisse mit dem Wert true zusammen, die dann mit dem Ausdrucksoperator verglichen werden.

Feldzählung

Zählt, wie viele Member eines Arrays in der Anforderungsnutzlast einem Bedingungsausdruck entsprechen. Die Struktur von field count Ausdrücken ist:

{
  "count": {
    "field": "<[*] alias>",
    "where": {
      /* condition expression */
    }
  },
  "<condition>": "<compare the count of true condition expression array members to this value>"
}

Die folgenden Eigenschaften werden bei field count verwendet:

  • count.field (erforderlich): Enthält den Pfad zum Array und muss ein Arrayalias sein.
  • count.where (optional): Der Bedingungsausdruck, der für jedes Array-Alias Array-Mitglied von count.field einzeln ausgewertet werden soll. Wenn diese Eigenschaft nicht angegeben wird, werden alle Arraymember mit dem Pfad „field“ als true ausgewertet. Innerhalb dieser Eigenschaft kann eine beliebige Bedingung verwendet werden. Es können logische Operatoren innerhalb dieser Eigenschaft verwendet werden, um komplexe Auswertungsanforderungen zu erstellen.
  • condition (erforderlich): Der Wert wird mit der Anzahl der Elemente verglichen, die den Bedingungsausdruck count.where erfüllen. Es sollte eine numerische Bedingung verwendet werden.

Weitere Informationen zur Arbeit mit Arrayeigenschaften in Azure Policy, einschließlich einer detaillierten Erklärung, wie der field count-Ausdruck ausgewertet wird, finden Sie unter Verweisen auf Arrayeigenschaften in Ressourcen.

Wertzählung

Zählt, wie viele Member eines Arrays eine Bedingung erfüllen. Das Array kann ein Literalarray oder ein Verweis auf den Arrayparameter sein. Die Struktur von value count Ausdrücken ist:

{
  "count": {
    "value": "<literal array | array parameter reference>",
    "name": "<index name>",
    "where": {
      /* condition expression */
    }
  },
  "<condition>": "<compare the count of true condition expression array members to this value>"
}

Die folgenden Eigenschaften werden bei value count verwendet:

  • count.value (erforderlich): Das zu bewertende Array.
  • count.name (erforderlich): Der Indexname, der aus Buchstaben des englischen Alphabets und Ziffern besteht. Definiert einen Namen für den Wert des Arraymembers, der in der aktuellen Iteration ausgewertet wird. Der Name wird verwendet, um auf den aktuellen Wert innerhalb der count.where-Bedingung zu verweisen. Optional, wenn sich der count Ausdruck nicht in einem untergeordneten Element eines anderen count Ausdrucks befindet. Wenn nicht angegeben, wird der Indexname implizit auf "default"festgelegt.
  • count.where (optional): Der Bedingungsausdruck, der individuell für jeden Arraymember von count.value ausgewertet wird. Wenn diese Eigenschaft nicht angegeben wird, werden alle Arraymember in TRUE ausgewertet. Innerhalb dieser Eigenschaft kann eine beliebige Bedingung verwendet werden. Es können logische Operatoren innerhalb dieser Eigenschaft verwendet werden, um komplexe Auswertungsanforderungen zu erstellen. Auf den Wert des aktuell aufgelisteten Arraymembers kann durch Aufrufen der aktuellen Funktion zugegriffen werden.
  • condition (erforderlich): Der Wert wird mit der Anzahl der Elemente verglichen, die den Bedingungsausdruck count.where erfüllen. Es sollte eine numerische Bedingung verwendet werden.

Die current-Funktion

Die current()-Funktion ist nur innerhalb der count.where-Bedingung verfügbar. Er gibt den Wert des Arraymembers zurück, das zurzeit von der Auswertung des count Ausdrucks aufgezählt wird.

Wertzählung: Syntax

  • current(<index name defined in count.name>). Beispiel: current('arrayMember').
  • current(). Nur zulässig, wenn der value count Ausdruck kein untergeordnetes Element eines anderen count Ausdrucks ist. Gibt den gleichen Wert wie oben zurück.

Wenn der vom Aufruf zurückgegebene Wert ein Objekt ist, werden Eigenschaftenaccessoren unterstützt. Beispiel: current('objectArrayMember').property.

Feldzählung: Syntax

  • current(<the array alias defined in count.field>). Beispiel: current('Microsoft.Test/resource/enumeratedArray[*]').
  • current(). Nur zulässig, wenn der field count Ausdruck kein untergeordnetes Element eines anderen count Ausdrucks ist. Gibt den gleichen Wert wie oben zurück.
  • current(<alias of a property of the array member>). Beispiel: current('Microsoft.Test/resource/enumeratedArray[*].property').

Beispiele für Feldzählung

Beispiel 1: Überprüfen, ob ein Array leer ist

{
  "count": {
    "field": "Microsoft.Network/networkSecurityGroups/securityRules[*]"
  },
  "equals": 0
}

Beispiel 2: Überprüfen, ob nur ein Arraymember dem Bedingungsausdruck entspricht

{
  "count": {
    "field": "Microsoft.Network/networkSecurityGroups/securityRules[*]",
    "where": {
      "field": "Microsoft.Network/networkSecurityGroups/securityRules[*].description",
      "equals": "My unique description"
    }
  },
  "equals": 1
}

Beispiel 3: Überprüfen, ob mindestens ein Arraymember dem Bedingungsausdruck entspricht

{
  "count": {
    "field": "Microsoft.Network/networkSecurityGroups/securityRules[*]",
    "where": {
      "field": "Microsoft.Network/networkSecurityGroups/securityRules[*].description",
      "equals": "My common description"
    }
  },
  "greaterOrEquals": 1
}

Beispiel 4: Überprüfen, ob alle Objektarraymember dem Bedingungsausdruck entsprechen

{
  "count": {
    "field": "Microsoft.Network/networkSecurityGroups/securityRules[*]",
    "where": {
      "field": "Microsoft.Network/networkSecurityGroups/securityRules[*].description",
      "equals": "description"
    }
  },
  "equals": "[length(field('Microsoft.Network/networkSecurityGroups/securityRules[*]'))]"
}

Beispiel 5: Überprüfen, ob mindestens ein Arraymember mehreren Eigenschaften im Bedingungsausdruck entspricht

{
  "count": {
    "field": "Microsoft.Network/networkSecurityGroups/securityRules[*]",
    "where": {
      "allOf": [
        {
          "field": "Microsoft.Network/networkSecurityGroups/securityRules[*].direction",
          "equals": "Inbound"
        },
        {
          "field": "Microsoft.Network/networkSecurityGroups/securityRules[*].access",
          "equals": "Allow"
        },
        {
          "field": "Microsoft.Network/networkSecurityGroups/securityRules[*].destinationPortRange",
          "equals": "3389"
        }
      ]
    }
  },
  "greater": 0
}

Beispiel 6: Verwenden Sie die current()-Funktion innerhalb der where-Bedingungen, um auf den Wert des aktuell aufgezählten Arraymembers in einer Vorlagenfunktion zuzugreifen. Diese Bedingung überprüft, ob ein virtuelles Netzwerk ein Adresspräfix enthält, das sich nicht im CIDR-Bereich „10.0.0.0/24“ befindet.

{
  "count": {
    "field": "Microsoft.Network/virtualNetworks/addressSpace.addressPrefixes[*]",
    "where": {
      "value": "[ipRangeContains('10.0.0.0/24', current('Microsoft.Network/virtualNetworks/addressSpace.addressPrefixes[*]'))]",
      "equals": false
    }
  },
  "greater": 0
}

Beispiel 7: Verwenden Sie die field()-Funktion innerhalb der where-Bedingungen, um auf den Wert des aktuell aufgezählten Arraymembers zuzugreifen. Diese Bedingung überprüft, ob ein virtuelles Netzwerk ein Adresspräfix enthält, das sich nicht im CIDR-Bereich „10.0.0.0/24“ befindet.

{
  "count": {
    "field": "Microsoft.Network/virtualNetworks/addressSpace.addressPrefixes[*]",
    "where": {
      "value": "[ipRangeContains('10.0.0.0/24', first(field(('Microsoft.Network/virtualNetworks/addressSpace.addressPrefixes[*]')))]",
      "equals": false
    }
  },
  "greater": 0
}

Beispiele für Wertzählung

Beispiel 1: Überprüfen, ob der Ressourcenname mit einem der angegebenen Namensmuster übereinstimmt.

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

Beispiel 2: Überprüfen, ob der Ressourcenname mit einem der angegebenen Namensmuster übereinstimmt. Die current()-Funktion gibt keinen Indexnamen an. Das Ergebnis ist dasselbe wie im vorherigen Beispiel.

{
  "count": {
    "value": [
      "prefix1_*",
      "prefix2_*"
    ],
    "where": {
      "field": "name",
      "like": "[current()]"
    }
  },
  "greater": 0
}

Beispiel 3: Überprüfen, ob der Ressourcenname mit einem der durch einen Arrayparameter angegebenen Namensmuster übereinstimmt.

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

Beispiel 4: Überprüfen, ob ein Adresspräfix des virtuellen Netzwerks in der Liste der genehmigten Präfixe nicht aufgeführt wird.

{
  "count": {
    "field": "Microsoft.Network/virtualNetworks/addressSpace.addressPrefixes[*]",
    "where": {
      "count": {
        "value": "[parameters('approvedPrefixes')]",
        "name": "approvedPrefix",
        "where": {
          "value": "[ipRangeContains(current('approvedPrefix'), current('Microsoft.Network/virtualNetworks/addressSpace.addressPrefixes[*]'))]",
          "equals": true
        },
      },
      "equals": 0
    }
  },
  "greater": 0
}

Beispiel 5: Überprüfen, ob alle reservierten NSG-Regeln in einer Netzwerksicherheitsgruppe definiert sind. Die Eigenschaften der reservierten NSG-Regeln werden in einem Arrayparameter definiert, der Objekte enthält.

Parameterwert:

[
  {
    "priority": 101,
    "access": "deny",
    "direction": "inbound",
    "destinationPortRange": 22
  },
  {
    "priority": 102,
    "access": "deny",
    "direction": "inbound",
    "destinationPortRange": 3389
  }
]

Richtlinie:

{
  "count": {
    "value": "[parameters('reservedNsgRules')]",
    "name": "reservedNsgRule",
    "where": {
      "count": {
        "field": "Microsoft.Network/networkSecurityGroups/securityRules[*]",
        "where": {
          "allOf": [
            {
              "field": "Microsoft.Network/networkSecurityGroups/securityRules[*].priority",
              "equals": "[current('reservedNsgRule').priority]"
            },
            {
              "field": "Microsoft.Network/networkSecurityGroups/securityRules[*].access",
              "equals": "[current('reservedNsgRule').access]"
            },
            {
              "field": "Microsoft.Network/networkSecurityGroups/securityRules[*].direction",
              "equals": "[current('reservedNsgRule').direction]"
            },
            {
              "field": "Microsoft.Network/networkSecurityGroups/securityRules[*].destinationPortRange",
              "equals": "[current('reservedNsgRule').destinationPortRange]"
            }
          ]
        }
      },
      "equals": 1
    }
  },
  "equals": "[length(parameters('reservedNsgRules'))]"
}

Richtlinienfunktionen

Funktionen können verwendet werden, um zusätzliche Logik in eine Richtlinienregel einzubauen. Sie werden innerhalb der Richtlinienregel einer Richtliniendefinition und innerhalb von Parameterwerten aufgelöst, die Richtliniendefinitionen in einer Initiative zugewiesen sind.

Alle Resource Manager-Vorlagenfunktionen stehen innerhalb einer Richtlinienregel zur Verfügung, mit Ausnahme der folgenden Funktionen und benutzerdefinierten Funktionen:

  • copyIndex()
  • dateTimeAdd()
  • dateTimeFromEpoch
  • dateTimeToEpoch
  • deployment()
  • environment()
  • extensionResourceId()
  • lambda()Weitere Informationen finden Sie unter lambda
  • listAccountSas()
  • listKeys()
  • listSecrets()
  • list*
  • managementGroup()
  • newGuid()
  • pickZones()
  • providers()
  • reference()
  • resourceId()
  • subscriptionResourceId()
  • tenantResourceId()
  • tenant()
  • variables()

Hinweis

Diese Funktionen sind weiterhin innerhalb des Teils details.deployment.properties.template der Vorlagenbereitstellung in der Definition der Richtlinie deployIfNotExists verfügbar.

Die folgende Funktion steht zur Verwendung in einer Richtlinienregel zur Verfügung, unterscheidet sich jedoch von der Verwendung in einer Azure Resource Manager-Vorlage (ARM-Vorlage):

  • utcNow(): Im Gegensatz zu einer ARM-Vorlage kann diese Eigenschaft auch außerhalb von defaultValue verwendet werden.
    • Gibt eine Zeichenfolge zurück, die auf das aktuelle Datum und die aktuelle Uhrzeit im Universal ISO 8601-DateTime-Format (yyyy-MM-ddTHH:mm:ss.fffffffZ) festgelegt ist.

Die folgenden Funktionen sind nur in Richtlinienregeln verfügbar:

  • addDays(dateTime, numberOfDaysToAdd)

    • dateTime: [Erforderlich] string – Zeichenfolge im Universal ISO 8601 DateTime-Format 'yyyy-MM-ddTHH:mm:ss.FFFFFFFZ'
    • numberOfDaysToAdd: [Erforderlich] ganze Zahl – Anzahl der hinzuzufügenden Tage

  • field(fieldName)

    • fieldName [erforderlich]: Zeichenfolge – Name des abzurufenden Felds
    • Gibt den Wert dieses Felds aus der Ressource zurück, die von der If-Bedingung ausgewertet wird
    • field wird in erster Linie mit auditIfNotExists und deployIfNotExists verwendet, um zu bewertende Felder auf der Ressource zu verweisen. Ein Beispiel hierfür finden Sie im Beispiel für DeployIfNotExists.

  • requestContext().apiVersion

    • Gibt die API-Version der Anforderung zurück, die die Richtlinienauswertung ausgelöst hat (z. B. 2021-09-01). Dieser Wert ist die API-Version, die in der PUT/PATCH-Anforderung für Auswertungen bei der Erstellung/Aktualisierung von Ressourcen verwendet wurde. Bei der Kompatibilitätsauswertung vorhandener Ressourcen wird immer die neueste API-Version verwendet.

  • policy()

    • Gibt die folgenden Informationen zur derzeit ausgewerteten Richtlinie zurück. Auf Eigenschaften kann über das zurückgegebene Objekt zugegriffen werden (Beispiel: [policy().assignmentId]).

      {
  "assignmentId": "/subscriptions/11111111-1111-1111-1111-111111111111/providers/Microsoft.Authorization/policyAssignments/myAssignment",
  "definitionId": "/providers/Microsoft.Authorization/policyDefinitions/34c877ad-507e-4c82-993e-3452a6e0ad3c",
  "setDefinitionId": "/providers/Microsoft.Authorization/policySetDefinitions/42a694ed-f65e-42b2-aa9e-8052e9740a92",
  "definitionReferenceId": "StorageAccountNetworkACLs"
}

  • ipRangeContains(range, targetRange)

    • range: [Erforderlich] Zeichenfolge: Zeichenfolge, die einen Bereich von IP-Adressen angibt, um zu überprüfen, ob targetRange darin enthalten ist.
    • targetRange: [Erforderlich] Zeichenfolge: Zeichenfolge, die einen Bereich von IP-Adressen angibt, um zu überprüfen, ob sie in range enthalten sind.
    • Gibt einen booleschen Wert zurück, der angibt, ob der IP-Adressbereich range den IP-Adressbereich targetRange enthält. Leere Bereiche oder Kombinationen verschiedener IP-Familien sind nicht zulässig und führen zu einem Bewertungsfehler.

    Unterstützte Formate:

    • Einzelne IP-Adresse (Beispiele: 10.0.0.0, 2001:0DB8::3:FFFE)
    • CIDR-Bereich (Beispiele: 10.0.0.0/24, 2001:0DB8::/110)
    • Durch Start- und End-IP-Adressen definierter Bereich (Beispiele: 192.168.0.1-192.168.0.9, 2001:0DB8::-2001:0DB8::3:FFFF)

  • current(indexName)

Beispiel für Richtlinienfunktion

Dieses Richtlinienregelbeispiel verwendet die Ressourcenfunktion resourceGroup, um die Eigenschaft name zu erhalten, kombiniert mit dem Array concat und der Objektfunktion, um eine like-Bedingung zu erstellen, die für den Ressourcennamen erzwingt, mit dem Ressourcengruppennamen zu beginnen.

{
  "if": {
    "not": {
      "field": "name",
      "like": "[concat(resourceGroup().name,'*')]"
    }
  },
  "then": {
    "effect": "deny"
  }
}

Richtlinienregellimits

Während der Erstellung erzwungene Grenzwerte

Grenzwerte für die Struktur von Richtlinienregeln werden während der Erstellung oder Zuweisung einer Richtlinie erzwungen. Versuche, Richtliniendefinitionen zu erstellen oder zuzuweisen, die diese Grenzwerte überschreiten, schlagen fehl.

Begrenzung Wert Zusätzliche Details
Bedingungsausdrücke in der if-Bedingung 4096
Bedingungsausdrücke im then-Block 128 Gilt für existenceCondition von auditIfNotExists und deployIfNotExists-Richtlinien
Richtlinienfunktionen pro Richtlinienregel 2048
Anzahl der Parameter der Richtlinienfunktion 128 Beispiel: [function('parameter1', 'parameter2', ...)]
Tiefe geschachtelter Richtlinienfunktionen 64 Beispiel: [function(nested1(nested2(...)))]
Länge der Ausdruckszeichenfolge für Richtlinienfunktionen 81920 Beispiel: Die Länge von "[function(....)]"
Field count Ausdrücke pro Array 5
Value count Ausdrücke pro Richtlinienregel 10
Value count Anzahl der Ausdrucksiterationen 100 Für geschachtelte Value count-Ausdrücke umfasst dies auch die Iterationsanzahl des übergeordneten Ausdrucks

Während der Auswertung erzwungene Grenzwerte

Begrenzt die Größe von Objekten, die während der Richtlinienauswertung von Richtlinienfunktionen verarbeitet werden. Diese Grenzwerte können nicht immer während der Erstellung erzwungen werden, da sie vom ausgewerteten Inhalt abhängen. Beispiel:

{
  "field": "name",
  "equals": "[concat(field('stringPropertyA'), field('stringPropertyB'))]"
}

Die Länge der von der concat()-Funktion erstellten Zeichenfolge hängt vom Wert der Eigenschaften in der ausgewerteten Ressource ab.

Begrenzung Wert Beispiel
Länge der von einer Funktion zurückgegebenen Zeichenfolge 131072 [concat(field('longString1'), field('longString2'))]
Tiefe komplexer Objekte, die als Parameter für eine Funktion bereitgestellt oder von dieser zurückgegeben werden 128 [union(field('largeObject1'), field('largeObject2'))]
Knotenanzahl komplexer Objekte, die als Parameter für eine Funktion bereitgestellt oder von dieser zurückgegeben werden 32768 [concat(field('largeArray1'), field('largeArray2'))]

Warnung

Richtlinien, die die oben genannten Grenzwerte während der Auswertung überschreiten, werden effektiv zu einer deny-Richtlinie und können eingehende Anforderungen blockieren. Beachten Sie beim Schreiben von Richtlinien mit komplexen Funktionen diese Grenzwerte, und testen Sie Ihre Richtlinien mit Ressourcen, die diese möglicherweise überschreiten.

Nächste Schritte