Erstellen von Richtlinien für Arrayeigenschaften für Azure-Ressourcen

Azure Resource Manager-Eigenschaften werden häufig als Zeichenfolgen und boolesche Werte definiert. Im Fall einer 1: n-Beziehung werden komplexe Eigenschaften stattdessen als Arrays definiert. In Azure Policy werden Arrays auf verschiedene Weise verwendet:

• Als Typ eines Definitionsparameters, um mehrere Optionen bereitzustellen
• Als Teil einer Richtlinienregel mit den Bedingungen inoder notIn
• Als Teil einer Richtlinienregel, die zählt, wie viele Arraymember eine Bedingung erfüllen
• Mit append und modify ist das Ergebnis die Aktualisierung eines vorhandenen Arrays.

Dieser Artikel befasst sich mit jedem dieser Verwendungsfälle in Azure Policy und enthält mehrere Beispieldefinitionen.

Parameterarrays

Definieren eines Parameterarrays

Durch das Definieren eines Parameters als Array kann die Richtlinie flexibel gestaltet werden, wenn mehrere Werte erforderlich sind. Diese Richtliniendefinition lässt einen beliebigen einzelnen Ort für den Parameter allowedLocations zu (der Standardwert ist eastus2):

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

Da type auf string festgelegt ist, kann beim Zuweisen der Richtlinie nur ein Wert festgelegt werden. Wenn diese Richtlinie zugewiesen ist, sind Ressourcen innerhalb des Bereichs nur in einer einzigen Azure-Region zulässig. Die meisten Richtliniendefinitionen müssen eine Liste genehmigter Optionen zulassen, z. B. eastus2, eastus und westus2.

Verwenden Sie zum Erstellen einer Richtliniendefinition, die mehrere Optionen zulässt, den type array. Diese Richtlinie kann wie folgt umgeschrieben werden:

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

Diese neue Parameterdefinition akzeptiert während der Richtlinienzuweisung mehrere Werte. Wenn die Arrayeigenschaft allowedValues definiert ist, werden die bei der Zuweisung verfügbaren Werte zusätzlich auf die vordefinierte Liste von Optionen beschränkt. Die Verwendung von allowedValues ist optional.

Übergeben von Werten an ein Parameterarray während der Zuweisung

Wenn Sie die Richtlinie über das Azure-Portal zuweisen, wird ein Parameter vom type array als ein einzelnes Textfeld angezeigt. Der Hinweis lautet Use ; to separate values. (e.g. London;New York). Verwenden Sie die folgende Zeichenfolge, um die zulässigen Werte eastus2, eastus und westus2 für den Ort an den Parameter zu übergeben:

eastus2;eastus;westus2

Das Format für den Parameterwert unterscheidet sich bei der Verwendung der Azure-Befehlszeilenschnittstelle (Azure CLI), von Azure PowerShell oder der REST-API. Die Werte werden in Form einer JSON-Zeichenfolge übergeben, die auch den Namen des Parameters enthält.

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

Die Befehle zur Verwendung dieser Zeichenfolge mit den einzelnen SDKs lauten wie folgt:

• Azure CLI: Befehl az policy assignment create mit dem Parameter params
• Azure PowerShell: Cmdlet New-AzPolicyAssignment mit dem Parameter PolicyParameter
• REST-API: Im Vorgang PUT create als Teil des Anforderungstexts als Wert der properties.parameters-Eigenschaft

Verwenden von Arrays in Bedingungen

„in“ und „notIn“

Die in- und notIn-Bedingungen funktionieren nur mit Arraywerten. Sie überprüfen, ob ein Wert in einem Array vorhanden ist. Das Array kann ein literales JSON-Array oder ein Verweis auf einen Arrayparameter sein. Beispiel:

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

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

Wertzählung

Der Wertzählungsausdruck zählt, wie viele Arraymember eine Bedingung erfüllen. Er bietet eine Möglichkeit, dieselbe Bedingung mehrmals auszuwerten, wobei für jede Iterationen unterschiedliche Werte verwendet werden. Mit der folgenden Bedingung wird beispielsweise überprüft, ob der Ressourcenname mit einem beliebigen Muster aus einem Array von Mustern übereinstimmt:

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

Um den Ausdruck auszuwerten, wird die where-Bedingung in Azure Policy dreimal ausgewertet, einmal für jeden Member von [ "test*", "dev*", "prod*" ]. Dabei wird gezählt, wie viele Male sie als true ausgewertet wurde. Bei jeder Iterationen wird der Wert des aktuellen Arraymembers mit dem pattern-Indexnamen gekoppelt, der durch count.name definiert ist. Auf diesen Wert kann innerhalb der where-Bedingung verwiesen werden, indem eine besondere Vorlagenfunktion aufgerufen wird: current('pattern').

Die Bedingung ist nur dann TRUE, wenn die ermittelte Anzahl größer als 0 ist.

Verwenden Sie einen parameters-Verweis anstelle eines Literalarrays, um die obige Bedingung generischer zu gestalten:

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

Wenn sich der value count-Ausdruck nicht unter einem anderen count-Ausdruck befindet, ist count.name optional, und die current()-Funktion kann ohne Argumente verwendet werden:

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

Der value count-Ausdruck unterstützt auch Arrays komplexer Objekte, sodass komplexere Bedingungen möglich sind. Die folgende Bedingung definiert z. B. einen gewünschten Tagwert für jedes Namensmuster und überprüft, ob der Ressourcenname mit dem Muster übereinstimmt, jedoch nicht über den erforderlichen Tagwert verfügt:

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

Nützliche Beispiele finden Sie unter Beispiele für die Wertzählung.

Verweisen auf Arrayeigenschaften in Ressourcen

Bei vielen Anwendungsfällen werden die Arrayeigenschaften in der ausgewerteten Ressource benötigt. In einigen Szenarien muss auf ein gesamtes Array verwiesen werden (z. B. zur Überprüfung der Länge). In anderen Szenarien ist es erforderlich, dass eine Bedingung jeweils auf die einzelnen Arraymember angewandt wird (z. B. zum Sicherstellen, dass der Zugriff aus dem Internet durch alle Firewallregeln blockiert wird). Entscheidend zum Schreiben von Bedingungen für diese Szenarien ist die Kenntnis der verschiedenen Methoden, mit denen in Azure Policy auf Ressourceneigenschaften verwiesen werden kann, sowie des Verhaltens dieser Verweise beim Referenzieren von Arrayeigenschaften.

Verweisen auf Ressourceneigenschaften

Auf Ressourceneigenschaften kann in Azure Policy mithilfe von Aliasen verwiesen werden. Zwei Möglichkeiten stehen zur Verfügung, um auf die Werte einer Ressourceneigenschaft in Azure Policy zu verweisen:

• Verwenden Sie die field-Bedingung, um zu überprüfen, ob alle ausgewählten Ressourceneigenschaften eine Bedingung erfüllen. Beispiel:

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

• Verwenden Sie die field()-Funktion, um auf den Wert einer Eigenschaft zuzugreifen. Beispiel:

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

Die field-Bedingung weist ein implizites allOf-Verhalten auf. Wenn der Alias eine Sammlung von Werten darstellt, wird mit dieser Bedingung überprüft, ob alle einzelnen Werte die Bedingung erfüllen. Die field()-Funktion gibt die durch den Alias dargestellten Werte unverändert zurück, die dann über andere Vorlagenfunktionen bearbeitet werden können.

Verweisen auf Arrayfelder

Arrayeigenschaften in Ressourcen werden durch zwei unterschiedliche Typen von Aliasen dargestellt. Durch einen „normalen“ Alias und Arrayaliase, an die [*] angefügt ist:

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

Verweisen auf das Array

Der erste Alias stellt einen einzelnen Wert dar: den Wert der stringArray-Eigenschaft aus dem Anforderungsinhalt. Da es sich bei dem Wert dieser Eigenschaft um ein Array handelt, ist er in Richtlinienbedingungen nicht nützlich. Beispiel:

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

Diese Bedingung vergleicht das gesamte stringArray-Array mit einem einzelnen Zeichenfolgenwert. Die meisten Bedingungen (einschließlich equals) unterstützen nur Zeichenfolgenwerte, sodass der Vergleich eines Arrays mit einer Zeichenfolge wenig sinnvoll ist. Das Hauptszenario, in dem der Verweis auf die Arrayeigenschaft sinnvoll ist, stellt die Überprüfung ihres Vorhandenseins dar:

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

Bei der field()-Funktion ist der zurückgegebene Wert das Array aus dem Anforderungsinhalt, das dann mit allen unterstützten Vorlagenfunktionen verwendet werden kann, die Arrayargumente unterstützen. Mit der folgenden Bedingung wird beispielsweise überprüft, ob die Länge von stringArray größer als 0 (null) ist:

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

Verweisen auf die Sammlung der Arraymember

Aliase mit der [*]-Syntax stellen eine Sammlung von Eigenschaftswerten dar, die aus einer Arrayeigenschaft ausgewählt wurden. Dies unterscheidet sich von der Auswahl der Arrayeigenschaft selbst. Microsoft.Test/resourceType/stringArray[*] gibt beispielsweise eine Sammlung zurück, die alle Member von stringArray enthält. Wie zuvor erwähnt, überprüft eine field-Bedingung, ob alle ausgewählten Ressourceneigenschaften die Bedingung erfüllen. Daher ist die folgende Bedingung nur „true“, wenn alle Member von stringArray gleich "value" sind.

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

Wenn das Array leer ist, wird die Bedingung als „true“ ausgewertet, da kein Member des Arrays einen Verstoß darstellt. In diesem Szenario wird empfohlen, stattdessen den count-Ausdruck zu verwenden. Wenn das Array Objekte enthält, kann ein [*]-Alias verwendet werden, um den Wert einer bestimmten Eigenschaft aus jedem Arraymember auszuwählen. Beispiel:

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

Diese Bedingung ist TRUE, wenn die Werte aller property-Eigenschaften in objectArray gleich "value" sind. Weitere Beispiele finden Sie unter Weitere Aliasbeispiele.

Wenn Sie die field()-Funktion verwenden, um auf einen Arrayalias zu verweisen, ist der zurückgegebene Wert ein Array aller ausgewählten Werte. Durch dieses Verhalten wird der gängige Anwendungsfall der field()-Funktion, d. h. die Fähigkeit zum Anwenden von Vorlagenfunktionen auf Ressourceneigenschaftswerte, eingeschränkt. In diesem Fall können nur Vorlagenfunktionen verwendet werden, die Arrayargumente unterstützen. Beispielsweise ist es möglich, mit [length(field('Microsoft.Test/resourceType/objectArray[*].property'))] die Länge des Arrays abzurufen. Komplexere Szenarien wie das Anwenden einer Vorlagenfunktion auf die einzelnen Arraymember und das Vergleichen mit einem gewünschten Wert sind jedoch nur bei Verwendung des count-Ausdrucks möglich. Weitere Informationen finden Sie unter Feldzählungsausdrücke.

Zur Zusammenfassung folgt ein Beispiel für einen Ressourceninhalt und die von verschiedenen Aliasen zurückgegebenen ausgewählten Werte:

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

Wenn Sie die field-Bedingung für den Beispielressourceninhalt verwenden, sehen die Ergebnisse wie folgt aus:

Wenn Sie die field()-Funktion für den Beispielressourceninhalt verwenden, sehen die Ergebnisse wie folgt aus:

Feldzählungsausdrücke

Feldzählungsausdrücke zählen, wie viele Arraymember eine Bedingung erfüllen, und vergleichen die Anzahl mit einem Zielwert. Count ist im Vergleich zu field Bedingungen intuitiver und vielseitiger anwendbar für das Auswerten von Arrays. Die Syntax ist:

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

Bei Verwendung ohne eine where-Bedingung gibt count lediglich die Länge eines Arrays zurück. Mit dem Beispielressourceninhalt aus dem vorherigen Abschnitt wird der folgende count-Ausdruck als true ausgewertet, da stringArray drei Member hat:

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

Dieses Verhalten gilt auch bei geschachtelten Arrays. Beispielsweise wird der folgende count-Ausdruck als true ausgewertet, weil in den nestedArray-Arrays vier Arraymember enthalten sind:

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

Die eigentliche Stärke von count zeigt sich in der where-Bedingung. Wenn count angegeben ist, listet Azure Policy die Arraymember auf und wertet sie anhand der Bedingung aus. Dabei wird gezählt, wie viele Arraymember als true ausgewertet werden. Azure Policy wählt dazu in jeder Iteration der Auswertung der where-Bedingung einen einzelnen Arraymember i aus und wertet den Ressourceninhalt anhand der where-Bedingung aus, als ob i der einzige Member des Arrays wäre. Die Tatsache, dass in jeder Iteration nur ein Arraymember zur Verfügung steht, bietet die Möglichkeit, komplexe Bedingungen auf jeden einzelnen Arraymember anzuwenden.

Beispiel:

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

Um den count-Ausdruck auszuwerten, wird die where-Bedingung in Azure Policy dreimal ausgewertet, einmal für jeden Member von stringArray. Dabei wird gezählt, wie viele Male sie als true ausgewertet wurde. Wenn die where-Bedingung auf die Microsoft.Test/resourceType/stringArray[*]-Arraymember verweist, anstatt alle Member von stringArray auszuwählen, wird jeweils nur ein einzelner Arraymember ausgewählt:

Der count-Ausdruck gibt 1 zurück.

Hier ein komplexerer Ausdruck:

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

Der count-Ausdruck gibt 1 zurück.

Aufgrund der Tatsache, dass der where-Ausdruck für den gesamten Anforderungsinhalt ausgewertet wird (mit Änderungen nur am aktuell ausgewerteten Arraymember), kann die where-Bedingung auch auf Felder außerhalb des Arrays verweisen:

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

Mit geschachtelten Zählungsausdrücken können Bedingungen auf geschachtelte Arrayfelder angewendet werden. Mit der folgenden Bedingung wird beispielsweise überprüft, ob das objectArray[*]-Array über genau zwei Member mit dem nestedArray[*]-Array verfügt, das mindestens einen Member enthält:

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

Da beide Member von objectArray[*] ein untergeordnetes Array nestedArray[*] mit zwei Membern enthalten, gibt der äußere Zählungsausdruck 2 zurück.

Komplexeres Beispiel: Überprüfen Sie, ob das objectArray[*]-Array genau zwei Member mit nestedArray[*] mit beliebigen Membern enthält, die gleich 2 oder 3 sind:

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

Da beide Member von objectArray[*] ein untergeordnetes Array nestedArray[*] aufweisen, das entweder 2 oder enthält 3, gibt der äußere Zählungsausdruck 2 zurück.

Zugreifen auf den aktuellen Arraymember mit Vorlagenfunktionen

Wenn Sie Vorlagenfunktionen verwenden, verwenden Sie die current()-Funktion, um auf den Wert des aktuellen Arraymembers oder die Werte seiner Eigenschaften zuzugreifen. Um auf den Wert des aktuellen Arraymembers zuzugreifen, übergeben Sie den Alias, der in count.field oder einem seiner untergeordneten Aliase definiert ist, als Argument an die current()-Funktion. Beispiel:

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

Die Feldfunktion in where-Bedingungen

Die field()-Funktion kann auch verwendet werden, um auf den Wert des aktuellen Arraymembers zuzugreifen, sofern sich der count-Ausdruck nicht innerhalb einer Existenzbedingung befindet (die field()-Funktion verweist immer auf die Ressource, die in der if-Bedingung ausgewertet wird). Das Verhalten von field() beim Verweisen auf das ausgewertete Array basiert auf den folgenden Konzepten:

• Arrayaliase werden in einer Sammlung von Werten aufgelöst, die aus allen Arraymembern ausgewählt werden.
• field()-Funktionen, die auf Arrayaliase verweisen, geben ein Array mit den ausgewählten Werten zurück.
• Durch Verweisen auf den gezählten Arrayalias innerhalb der where-Bedingung wird eine Sammlung mit einem einzelnen Wert zurückgegeben, der aus dem Arraymember ausgewählt wird, der in der aktuellen Iteration ausgewertet wird.

Durch dieses Verhalten wird beim Verweisen auf den gezählten Arraymember mit einer field()-Funktion innerhalb der where-Bedingung ein Array mit einem einzelnen Member zurückgegeben. Obwohl dieses Verhalten vielleicht nicht intuitiv ist, entspricht es dem Grundgedanken, dass Arrayaliase immer eine Sammlung von ausgewählten Eigenschaften zurückgeben. Ein Beispiel:

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

Wenn also mit einer field()-Funktion auf den Wert des gezählten Arrayalias zugegriffen werden muss, ist der Wert mit einer first()-Vorlagenfunktion zu umschließen:

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

Nützliche Beispiele finden Sie unter Beispiele für Feldzählungen.

Ändern von Arrays

append und modify ändern Eigenschaften von Ressourcen bei deren Erstellung oder einem Update. Wenn Sie mit Arrayeigenschaften arbeiten, hängt das Verhalten dieser Auswirkungen davon ab, ob der Vorgang versucht, den [*]-Alias zu ändern oder nicht:

Weitere Informationen finden Sie unter Beispiele für „append“.

Weitere Aliasbeispiele

Es wird empfohlen, die Feldzählungsausdrücke zu verwenden, um zu überprüfen, ob alle (allOf) oder mindestens eines (anyOf) der Member eines Arrays im Anforderungsinhalt eine Bedingung erfüllen. Bei einigen einfachen Bedingungen ist es möglich, das gleiche Ergebnis zu erzielen, indem wie unter Verweisen auf die Sammlung der Arraymember beschrieben ein Feldaccessor mit einem Arrayalias verwendet wird. Dieses Muster kann in Richtlinienregeln nützlich sein, die den Grenzwert der zulässigen Anzahl von count-Ausdrücken überschreiten. Im Folgenden finden Sie Beispiele für häufige Anwendungsfälle:

Die Beispielrichtlinienregel für die folgende Szenariotabelle sieht wie folgt aus:

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

Das ipRules-Array für die folgende Szenariotabelle sieht wie folgt aus:

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

Ersetzen Sie für jedes der folgenden Bedingungsbeispiele <field> durch "field": "Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].value".

Die Kombination der Bedingung, der Beispielrichtlinienregel und des Arrays der obigen vorhandenen Werte führt zu den folgenden Ergebnissen:

Nächste Schritte

• Sehen Sie sich die Beispiele unter Azure Policy-Beispiele an.
• Lesen Sie die Informationen unter Struktur von Azure Policy-Definitionen.
• Lesen Sie Grundlegendes zu Richtlinienauswirkungen.
• Informieren Sie sich über das programmgesteuerte Erstellen von Richtlinien.
• Erfahren Sie, wie Sie nicht konforme Ressourcen korrigieren können.
• Weitere Informationen zu Verwaltungsgruppen finden Sie unter Organisieren Ihrer Ressourcen mit Azure-Verwaltungsgruppen.