Partager via

Règle de stratégie de la structure de définition Azure Policy

  • Article

La règle de stratégie se compose de blocs if et then. Dans le bloc if, vous définissez une ou plusieurs conditions qui spécifient à quel moment la stratégie est appliquée. Vous pouvez appliquer des opérateurs logiques à ces conditions pour définir avec précision le scénario d’une stratégie.

Si vous souhaitez en savoir plus sur chaque effet, l’ordre d’évaluation, les propriétés et des exemples, veuillez consulter la rubrique Concepts de base de l’effet des définitions d’Azure Policy.

Dans le bloc then, vous définissez l’effet qui se produit lorsque les conditions if sont remplies.

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

Pour obtenir plus d’informations sur policyRule, accédez au schéma de définition de stratégie.

Opérateurs logiques

Les opérateurs logiques pris en charge sont les suivants :

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

La syntaxe not inverse le résultat de la condition. La syntaxe allOf (semblable à l’opération logique and) exige que toutes les conditions soient remplies. La syntaxe anyOf (semblable à l’opération logique or) exige qu’au moins une des conditions soit remplie.

Vous pouvez imbriquer des opérateurs logiques. L’exemple suivant illustre une opération not imbriquée dans une opération allOf.

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

Conditions

Une condition évalue si une valeur répond à certains critères. Les conditions prises en charge sont les suivantes :

  • "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"

Pour less, lessOrEquals, greater et greaterOrEquals, si le type de propriété ne correspond pas au type de condition, une erreur est levée. Les comparaisons de chaînes sont effectuées à l’aide de InvariantCultureIgnoreCase.

Avec les conditions like et notLike, vous fournissez un caractère générique (*) dans la valeur. La valeur ne doit pas en comporter plus d’un caractère générique.

Si vous utilisez les conditions match et notMatch, fournissez un mot-dièse (#) à mettre en correspondance avec un chiffre, un point d’interrogation (?) pour une lettre et un point (.) pour un caractère et tout autre caractère pour représenter ce caractère réel. Bien que match et notMatch soient sensibles à la casse, toutes les autres conditions qui évaluent une stringValue ne sont pas sensibles à la casse. Des variantes non sensibles à la casse sont disponibles dans notMatchInsensitively et matchInsensitively.

Champs

Conditions vérifiant si les valeurs des propriétés dans la charge utile de la demande de ressource qui répondent à certains critères peuvent être formées en utilisant une expression field. Les champs suivants sont pris en charge :

  • name

  • fullName

    • Retourne le nom complet de la ressource, Le nom complet d’une ressource correspond à un nom de ressource précédé du nom de toutes les ressources parentes (par exemple, myServer/myDatabase).

  • kind

  • type

  • location

    • Les champs d’emplacement sont normalisés pour prendre en charge différents formats. Par exemple, East US 2 est considéré comme égal à eastus2.
    • Utilisez global pour les ressources indépendantes de l’emplacement.

  • id

    • Retourne l’ID de la ressource qui est évaluée.
    • Exemple : /subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myRG/providers/Microsoft.KeyVault/vaults/myVault

  • identity.type

  • tags

  • tags['<tagName>']

    • Cette syntaxe en crochet prend en charge les noms de balise contenant des signes de ponctuation tels qu’un trait d’union, un point ou un espace.
    • Où tagName est le nom de l’étiquette pour laquelle vérifier la condition.
    • Exemples : tags['Acct.CostCenter'] où Acct.CostCenter est le nom de l’étiquette.

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

    • Cette syntaxe en crochet prend en charge les noms de balise contenant des apostrophes en appliquant une séquence d’échappement entre apostrophes doubles.
    • Où tagName est le nom de l’étiquette pour laquelle vérifier la condition.
    • Exemple : tags['''My.Apostrophe.Tag'''] où 'My.Apostrophe.Tag' est le nom de l’étiquette.

    Remarque

    tags.<tagName>, tags[tagName] et tags[tag.with.dots] sont toujours des manières acceptables de déclarer un champ de balises. Toutefois, les expressions préférées sont celles répertoriées ci-dessus.

  • alias de propriété : pour en obtenir la liste, consultez Alias.

    Remarque

    Dans des expressions field faisant référence à un alias de groupe [*], chaque élément du groupe est évalué individuellement avec un and logique entre les éléments. Pour plus d’informations, consultez Références aux propriétés des ressources de tableau.

Les conditions qui utilisent des expressions field peuvent remplacer la syntaxe de définition de stratégie héritée "source": "action", utilisée pour fonctionner pour les opérations d’écriture. Par exemple, cela n’est plus pris en charge :

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

Toutefois, le comportement souhaité peut être obtenu à l’aide de field logique :

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

Utiliser des balises avec des paramètres

Une valeur de paramètre peut être passée à un champ de balise. Le passage d’un paramètre à un champ de balise augmente la flexibilité de la définition de stratégie lors de l’attribution de stratégie.

Dans l’exemple suivant, concat est utilisé pour créer une recherche dans le champ de balises pour la balise nommée avec la valeur du paramètre tagName. Si cette balise n’existe pas, l’effet modify est utilisé pour ajouter la balise en tirant parti de la valeur de la même balise nommée définie sur le groupe de ressources parent des ressources auditées en utilisant la fonction de recherche resourcegroup().

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

Valeur

Les conditions qui déterminent si une valeur répond à certains critères peuvent être formées en tirant parti d’une expression value. Les valeurs peuvent être des littéraux, des valeurs de paramètres ou des valeurs retournées par n’importe quelle fonction de modèle prise en charge.

Avertissement

Si le résultat d’une fonction de modèle est une erreur, la stratégie d’évaluation échoue. Une évaluation ayant échoué correspond à un deny implicite. Pour plus d’informations, consultez Éviter les défaillances des modèles. Utilisez enforcementMode de doNotEnforce pour empêcher l’impact d’une évaluation qui a échoué sur des ressources nouvelles ou mises à jour lors du test et de la validation d’une nouvelle définition de stratégie.

Exemples de valeur

Cet exemple de règle de stratégie utilise value pour comparer le résultat de la fonction resourceGroup() et la propriété name renvoyée à une condition like de *netrg. La règle refuse toute ressource qui n’est pas du type Microsoft.Network/* dans tout groupe de ressources dont le nom se termine par *netrg.

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

Cet exemple de règle de stratégie utilise value pour vérifier si le résultat de plusieurs fonctions imbriquées equals true. La règle refuse toute ressource qui n’a pas au moins trois balises.

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

Éviter les défaillances des modèles

L’utilisation de fonctions de modèle dans value autorise de nombreuses fonctions imbriquées complexes. Si le résultat d’une fonction de modèle est une erreur, la stratégie d’évaluation échoue. Une évaluation ayant échoué correspond à un deny implicite. Voici un exemple d’une value qui échoue dans certains scénarios :

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

L’exemple de règle de stratégie ci-dessus utilise substring() pour comparer les trois premiers caractères du name à abc. Si le name a moins de trois caractères, la fonction substring() entraîne une erreur. Cette erreur entraîne un effet deny par la stratégie.

Au lieu de cela, utilisez la fonction if() pour vérifier si les trois premiers caractères du name sont égaux à abc pour éviter qu’un name contenant moins de trois caractères entraîne une erreur :

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

Avec la règle de stratégie révisée, if() vérifie la longueur du name avant d’essayer d’obtenir une substring() sur une valeur avec moins de trois caractères. Si le name est trop court, la valeur « ne commence pas par abc » est retournée à la place et comparée à abc. Une ressource avec un nom court qui ne commence pas par abc fait toujours échouer la règle de stratégie, mais ne provoque plus d’erreur lors de l’évaluation.

Count

Les conditions qui dénombrent le nombre de membres d’un groupe qui répondent à certains critères peuvent être formées à l’aide d’une expression count. Des scénarios courants vérifient si « au moins un des », « un et un seul des », « tous les » ou « aucun des » membres du groupe remplissent la condition. Le count évalue chaque membre du groupe pour une expression de condition et additionne les résultats true, puis compare à l’opérateur d’expression.

Field count

Dénombre le nombre de membres d’un groupe dans la charge utile de la demande qui satisfont à une expression de condition. La structure des expressions field count est :

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

Les propriétés suivantes sont utilisées avec field count :

  • count.field (obligatoire) : contient le chemin au groupe et doit être un alias de groupe.
  • count.where (facultatif) : expression de condition pour évaluer individuellement chaque membre du groupe alias de groupe de count.field. Si cette propriété n’est pas fournie, tous les membres du tableau avec le chemin « field » sont évalués à true. Toute condition peut être utilisée à l’intérieur de cette propriété. Il est possible d’utiliser des opérateurs logiques à l’intérieur de cette propriété pour créer des exigences d’évaluation complexes.
  • condition (obligatoire) : la valeur est comparée au nombre d’éléments qui ont satisfait l’expression de condition count.where. Une condition numérique doit être utilisée.

Pour obtenir plus d’informations sur l’utilisation des propriétés de groupe dans Azure Policy, notamment une explication détaillée de l’évaluation de l’expression field count, consultez Référencement des propriétés de ressources de tableau.

Value count

Dénombre le nombre de membres d’un groupe qui satisfont à une condition. Le groupe peut être un groupe littéral ou une référence à un paramètre de groupe. La structure des expressions value count est :

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

Les propriétés suivantes sont utilisées avec value count :

  • count.value (obligatoire) : groupe à évaluer.
  • count.name (obligatoire) :nom d’index, composé de lettres anglaises et de chiffres. Définit un nom pour la valeur du membre de groupe évalué dans l’itération actuelle. Le nom est utilisé pour référencer la valeur actuelle à l’intérieur de la condition count.where. Facultatif lorsque l’expression count n’est pas un enfant d’une autre expression count. Quand il n’est pas fourni, le nom d’index est implicitement défini sur "default".
  • count.where (facultatif) : expression de condition pour évaluer individuellement chaque membre du groupe de count.value. Si cette propriété n’est pas fournie, tous les membres du groupe sont évalués à true. Toute condition peut être utilisée à l’intérieur de cette propriété. Il est possible d’utiliser des opérateurs logiques à l’intérieur de cette propriété pour créer des exigences d’évaluation complexes. La valeur du membre de groupe actuellement énuméré est accessible en appelant la fonction current.
  • condition (obligatoire) : la valeur est comparée au nombre d’éléments qui ont satisfait l’expression de condition count.where. Une condition numérique doit être utilisée.

Fonction current

La fonction current() n’est disponible qu’à l’intérieur de la condition count.where. Elle retourne la valeur du membre du groupe qui est actuellement énumérée par l’évaluation de l’expression count.

Utilisation de value count

  • current(<index name defined in count.name>). Par exemple : current('arrayMember').
  • current(). Autorisé uniquement lorsque l’expression value count n’est pas un enfant d’une autre expression count. Retourne la même valeur que ci-dessus.

Si la valeur retournée par l’appel est un objet, les accesseurs de propriété sont pris en charge. Par exemple : current('objectArrayMember').property.

Field count usage

  • current(<the array alias defined in count.field>). Par exemple : current('Microsoft.Test/resource/enumeratedArray[*]').
  • current(). Autorisé uniquement lorsque l’expression field count n’est pas un enfant d’une autre expression count. Retourne la même valeur que ci-dessus.
  • current(<alias of a property of the array member>). Par exemple : current('Microsoft.Test/resource/enumeratedArray[*].property').

Exemples d’expression field count

Exemple 1 : Vérifier si un tableau est vide

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

Exemple 2 : Rechercher un seul membre du tableau qui satisfait l’expression de condition

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

Exemple 3 : Rechercher au moins un membre du tableau qui satisfait l’expression de condition

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

Exemple 4 : Vérifier que tous les membres du tableau d’objets satisfont l’expression de condition

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

Exemple 5 : Vérifier qu’au moins un membre du tableau correspond à plusieurs propriétés dans l’expression de condition

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

Exemple 6 : Utilisez la fonction current() à l’intérieur des conditions where pour accéder à la valeur du membre du groupe actuellement énuméré dans un modèle de fonction. Cette condition vérifie si un réseau virtuel contient un préfixe d’adresse qui ne figure pas dans la plage CIDR 10.0.0.0/24.

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

Exemple 7 : utiliser la fonction field() à l’intérieur des conditions where pour accéder à la valeur du membre du groupe actuellement énuméré. Cette condition vérifie si un réseau virtuel contient un préfixe d’adresse qui ne figure pas dans la plage CIDR 10.0.0.0/24.

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

Exemples d’expressions value count

Exemple 1 : vérifier si le nom de ressource correspond à l’un des modèles de nom donné.

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

Exemple 2 : vérifier si le nom de ressource correspond à l’un des modèles de nom donné. La fonction current() ne spécifie pas de nom d’index. Le résultat est le même que celui de l’exemple précédent.

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

Exemple 3 : Vérifie si le nom de ressource correspond à l’un des modèles de nom fournis par un paramètre de groupe.

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

Exemple 4 : vérifier si l’un des préfixes d’adresse de réseau virtuel ne figure pas dans la liste des préfixes approuvés.

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

Exemple 5 : vérifier que toutes les règles de groupe de sécurité réseau réservées sont définies dans un groupe de sécurité réseau. Les propriétés des règles de groupe de sécurité réseau réservées sont définies dans un paramètre de groupe contenant des objets.

Valeur du paramètre :

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

Stratégie :

{
  "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'))]"
}

Fonctions de stratégie

Les fonctions peuvent être utilisées pour introduire une logique supplémentaire dans une règle de stratégie. Elles sont résolues dans la règle de stratégie d’une définition de stratégie et au sein des valeurs de paramètre affectées aux définitions de stratégie dans une initiative.

Toutes les fonctions de modèle Resource Manager peuvent être utilisées dans une règle de stratégie, à l’exception des fonctions et fonctions définies par l’utilisateur suivantes :

  • copyIndex()
  • dateTimeAdd()
  • dateTimeFromEpoch
  • dateTimeToEpoch
  • deployment()
  • environment()
  • extensionResourceId()
  • lambda() Pour obtenir plus d’informations, accéder à lambda
  • listAccountSas()
  • listKeys()
  • listSecrets()
  • list*
  • managementGroup()
  • newGuid()
  • pickZones()
  • providers()
  • reference()
  • resourceId()
  • subscriptionResourceId()
  • tenantResourceId()
  • tenant()
  • variables()

Remarque

Ces fonctions sont toujours disponibles dans la partie details.deployment.properties.template du déploiement de modèle dans une définition de stratégie deployIfNotExists.

La fonction suivante est utilisable dans une règle de stratégie, mais diffère de l’utilisation dans un modèle Resource Manager :

  • utcNow() : contrairement à un modèle Resource Manager, cette propriété peut être utilisée en dehors de defaultValue.
    • Retourne une chaîne qui est définie sur la date et l’heure actuelles au format de date/heure universel ISO 8601 yyyy-MM-ddTHH:mm:ss.fffffffZ.

Les fonctions suivantes sont disponibles uniquement dans les règles de stratégie :

  • addDays(dateTime, numberOfDaysToAdd)

    • dateTime : [obligatoire] chaîne – Chaîne au format DateHeure universel ISO 8601 « yyyy-MM-ddTHH:mm:ss.FFFFFFFZ »
    • numberOfDaysToAdd : [obligatoire] entier – Nombre de jours à ajouter

  • field(fieldName)

    • fieldName : [Obligatoire] chaîne – Nom du champ à récupérer
    • Retourne la valeur de ce champ à partir de la ressource en cours d’évaluation par la condition If.
    • field est principalement utilisé avec auditIfNotExists et deployIfNotExists pour faire référence aux champs actuellement évalués de la ressource. Vous pouvez en voir une illustration dans l’exemple DeployIfNotExists.

  • requestContext().apiVersion

    • Retourne la version d’API de la requête qui a déclenché l’évaluation de la stratégie (par exemple : 2021-09-01). Cette valeur est la version d’API qui a été utilisée dans la requête PUT/PATCH pour les évaluations relatives à la création/mise à jour de ressources. La dernière version de l’API est toujours utilisée lors de l’évaluation de la conformité sur des ressources existantes.

  • policy()

    • Retourne les informations suivantes sur la stratégie en cours d’évaluation. Les propriétés sont accessibles à partir de l’objet retourné (exemple : [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 : [obligatoire] chaîne – Chaîne spécifiant une plage d’adresses IP dans laquelle il convient de vérifier la présence de la plage targetRange.
    • targetRange : [obligatoire] chaîne – Chaîne spécifiant une plage d’adresses IP à valider comme incluses dans la plage.
    • Renvoie une valeur booléenne indiquant si la plage d’adresses IP range contient la plage d’adresses IP targetRange. Les plages vides ou la combinaison entre familles d’adresses IP ne sont pas autorisées et entraînent l’échec de l’évaluation.

    Formats pris en charge :

    • Adresse IP unique (exemples : 10.0.0.0, 2001:0DB8::3:FFFE)
    • Plage CIDR (exemples : 10.0.0.0/24, 2001:0DB8::/110)
    • Plage définie par les adresses IP de début et de fin (exemples : 192.168.0.1-192.168.0.9, 2001:0DB8::-2001:0DB8::3:FFFF)

  • current(indexName)

Exemple de fonction de stratégie

Cet exemple de règle de stratégie utilise la fonction de ressource resourceGroup pour obtenir la propriété name, combinée au groupe concat et à la fonction d’objet, pour créer une condition like selon laquelle le nom de ressource commence par le nom du groupe de ressources.

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

Limites de la règle de stratégie

Limites appliquées lors de la création

Les limites de la structure des règles de stratégie sont appliquées lors de la création ou de l’attribution d’une stratégie. Les tentatives de création ou d’attribution de définitions de stratégie qui dépassent ces limites échouent.

Limite Valeur Informations supplémentaires
Expressions de condition dans la condition if 4096
Expressions de condition dans le bloc then 128 S’applique à existenceCondition de auditIfNotExists et aux stratégies deployIfNotExists
Fonctions de stratégie par règle de stratégie 2 048
Nombre de paramètres de la fonction de stratégie 128 Exemple : [function('parameter1', 'parameter2', ...)]
Profondeur des fonctions de stratégie imbriquée 64 Exemple : [function(nested1(nested2(...)))]
Longueur de chaîne d’expression des fonctions de stratégie 81920 Exemple : longueur de "[function(....)]"
Expressions Field count par groupe 5
Expressions Value count par règle de stratégie 10
Nombre d’itérations d’expression Value count 100 Pour les expressions Value count imbriquées, cela inclut également le nombre d’itérations de l’expression parente

Limites appliquées pendant l’évaluation

Limites de la taille des objets traités par les fonctions de stratégie lors de l’évaluation de la stratégie. Ces limites ne peuvent pas toujours être appliquées pendant la création, car elles dépendent du contenu évalué. Par exemple :

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

La longueur de la chaîne créée par la fonction concat() dépend de la valeur des propriétés de la ressource évaluée.

Limite Valeur Exemple
Longueur de la chaîne retournée par une fonction 131 072 [concat(field('longString1'), field('longString2'))]
Profondeur d’objets complexes fournie en tant que paramètre envoyé vers ou retourné par une fonction 128 [union(field('largeObject1'), field('largeObject2'))]
Nombre de nœuds d’objets complexes fourni en tant que paramètre envoyé vers ou retourné par une fonction 32 768 [concat(field('largeArray1'), field('largeArray2'))]

Avertissement

La stratégie qui dépasse les limites ci-dessus pendant l’évaluation devient une stratégie de deny et peut bloquer les demandes entrantes. Lors de l’écriture de stratégies avec des fonctions complexes, gardez ces limites à l’esprit et testez vos stratégies sur des ressources qui risquent de les dépasser.

Étapes suivantes