Structure de définition Azure PolicyAzure Policy definition structure

Les définitions de stratégies de ressources sont utilisées par Azure Policy pour établir des conventions pour les ressources.Resource policy definitions are used by Azure Policy to establish conventions for resources. Chaque définition décrit la conformité des ressources et les mesures à prendre en cas de non-conformité.Each definition describes resource compliance and what effect to take when a resource is non-compliant. En définissant des conventions, vous pouvez contrôler les coûts et gérer plus facilement vos ressources.By defining conventions, you can control costs and more easily manage your resources. Par exemple, vous pouvez spécifier que seuls certains types de machines virtuelles sont autorisés.For example, you can specify that only certain types of virtual machines are allowed. Vous pouvez aussi exiger que toutes les ressources soient marquées.Or, you can require that all resources have a particular tag. Toutes les ressources enfants héritent des stratégies.Policies are inherited by all child resources. Une stratégie appliquée à un groupe de ressources s’applique à toutes les ressources appartenant à ce groupe de ressources.If a policy is applied to a resource group, it's applicable to all the resources in that resource group.

Le schéma de la définition de stratégie se trouve ici : https://schema.management.azure.com/schemas/2019-06-01/policyDefinition.jsonThe policy definition schema is found here: https://schema.management.azure.com/schemas/2019-06-01/policyDefinition.json

Vous devez utiliser JSON pour créer une définition de stratégie.You use JSON to create a policy definition. La définition de stratégie contient des éléments pour :The policy definition contains elements for:

  • modemode
  • parametersparameters
  • le nom d’affichagedisplay name
  • descriptiondescription
  • la règle de stratégiepolicy rule
    • évaluation logiquelogical evaluation
    • effeteffect

Par exemple, le code JSON suivant illustre une stratégie qui limite les emplacements où les ressources sont déployées :For example, the following JSON shows a policy that limits where resources are deployed:

{
    "properties": {
        "mode": "all",
        "parameters": {
            "allowedLocations": {
                "type": "array",
                "metadata": {
                    "description": "The list of locations that can be specified when deploying resources",
                    "strongType": "location",
                    "displayName": "Allowed locations"
                },
                "defaultValue": [ "westus2" ]
            }
        },
        "displayName": "Allowed locations",
        "description": "This policy enables you to restrict the locations your organization can specify when deploying resources.",
        "policyRule": {
            "if": {
                "not": {
                    "field": "location",
                    "in": "[parameters('allowedLocations')]"
                }
            },
            "then": {
                "effect": "deny"
            }
        }
    }
}

Tous les exemples Azure Policy se trouvent dans Exemples de stratégies.All Azure Policy samples are at Azure Policy samples.

ModeMode

Le Mode est configuré selon que la stratégie cible une propriété Azure Resource Manager ou une propriété de fournisseur de ressources.Mode is configured depending on if the policy is targeting an Azure Resource Manager property or a Resource Provider property.

Modes Resource ManagerResource Manager modes

Le mode détermine les types de ressources à évaluer pour une stratégie.The mode determines which resource types will be evaluated for a policy. Les modes pris en charge sont les suivants :The supported modes are:

  • all : évaluer les groupes de ressources et tous les types de ressourcesall: evaluate resource groups and all resource types
  • indexed : évaluer uniquement les types de ressources qui prennent en charge les balises et l’emplacementindexed: only evaluate resource types that support tags and location

Nous vous recommandons de définir mode sur all dans tous les cas.We recommend that you set mode to all in most cases. Toutes les définitions de stratégie créées via le portail utilisent le mode all.All policy definitions created through the portal use the all mode. Si vous utilisez PowerShell ou Azure CLI, vous pouvez spécifier le paramètre mode manuellement.If you use PowerShell or Azure CLI, you can specify the mode parameter manually. Si la définition de stratégie ne comporte pas de valeur mode, elle prend la valeur par défaut all dans Azure PowerShell et null dans Azure CLI.If the policy definition doesn't include a mode value, it defaults to all in Azure PowerShell and to null in Azure CLI. Le mode null a le même effet que indexed, à savoir assurer une compatibilité descendante.A null mode is the same as using indexed to support backwards compatibility.

Il est recommandé (quoique non obligatoire) d’utiliser indexed pour créer des stratégies qui appliquent des balises ou des emplacements,indexed should be used when creating policies that enforce tags or locations. car cela empêche les ressources qui ne prennent pas en charge les balises et les emplacements de s’afficher comme non conformes dans les résultats de conformité.While not required, it prevents resources that don't support tags and locations from showing up as non-compliant in the compliance results. Les groupes de ressources font figure d’exception.The exception is resource groups. Les stratégies qui appliquent des emplacements ou des balises à un groupe de ressources doivent définir mode sur all et cibler spécifiquement le type Microsoft.Resources/subscriptions/resourceGroups.Policies that enforce location or tags on a resource group should set mode to all and specifically target the Microsoft.Resources/subscriptions/resourceGroups type. Pour exemple, consultez Appliquer des balises au groupe de ressources.For an example, see Enforce resource group tags. Pour obtenir la liste des ressources qui prennent en charge les étiquettes, consultez Prise en charge des étiquettes pour les ressources Azure.For a list of resources that support tags, see Tag support for Azure resources.

Modes Fournisseur de ressources (préversion)Resource Provider modes (preview)

Les modes Fournisseur de ressources suivants sont actuellement pris en charge pendant la préversion :The following Resource Provider modes are currently supported during preview:

  • Microsoft.ContainerService.Data pour la gestion des règles d’admission de contrôleur sur Azure Kubernetes Service.Microsoft.ContainerService.Data for managing admission controller rules on Azure Kubernetes Service. Les stratégies utilisant ce mode Fournisseur de ressources doivent utiliser l’effet EnforceRegoPolicy.Policies using this Resource Provider mode must use the EnforceRegoPolicy effect.
  • Microsoft.Kubernetes.Data pour la gestion des clusters Kubernetes du moteur AKS auto-managés sur Azure.Microsoft.Kubernetes.Data for managing self-managed AKS Engine Kubernetes clusters on Azure. Les stratégies utilisant ce mode Fournisseur de ressources doivent utiliser l’effet EnforceOPAConstraint.Policies using this Resource Provider mode must use the EnforceOPAConstraint effect.
  • Microsoft.KeyVault.Data pour la gestion des coffres et des certificats dans Azure Key Vault.Microsoft.KeyVault.Data for managing vaults and certificates in Azure Key Vault.

Notes

Les modes Fournisseur de ressources prennent uniquement en charge les définitions de stratégie intégrées et ne prennent pas en charge les initiatives en préversion.Resource Provider modes only support built-in policy definitions and don't support initiatives while in preview.

ParamètresParameters

Les paramètres permettent de simplifier la gestion des stratégies en réduisant le nombre de définitions de stratégies.Parameters help simplify your policy management by reducing the number of policy definitions. Considérez les paramètres comme les champs d’un formulaire : name, address, city, state.Think of parameters like the fields on a form – name, address, city, state. Ces paramètres restent toujours les mêmes ; toutefois, leurs valeurs changent en fonction de la personne qui remplit le formulaire.These parameters always stay the same, however their values change based on the individual filling out the form. Les paramètres fonctionnent de manière identique durant la création de stratégies.Parameters work the same way when building policies. En incluant des paramètres dans une définition de stratégie, vous pouvez réutiliser cette stratégie pour différents scénarios avec des valeurs différentes.By including parameters in a policy definition, you can reuse that policy for different scenarios by using different values.

Notes

Des paramètres peuvent être ajoutés à une définition existante et attribuée.Parameters may be added to an existing and assigned definition. Le nouveau paramètre doit inclure la propriété defaultValue.The new parameter must include the defaultValue property. Cela empêche les affectations de stratégie ou d’initiative déjà existantes d’être indirectement invalidées.This prevents existing assignments of the policy or initiative from indirectly being made invalid.

Propriétés du paramètreParameter properties

Un paramètre possède les propriétés suivantes qui sont utilisées dans la définition de la stratégie :A parameter has the following properties that are used in the policy definition:

  • nom : Nom de votre paramètre.name: The name of your parameter. Utilisé par la fonction de déploiement parameters dans le cadre de la règle de stratégie.Used by the parameters deployment function within the policy rule. Pour plus d’informations, consultez Utilisation d’une valeur de paramètre.For more information, see using a parameter value.
  • type: Détermine si le paramètre est une chaîne, un tableau, un objet, booléen, entier, flottant, ou DateHeure.type: Determines if the parameter is a string, array, object, boolean, integer, float, or datetime.
  • metadata: Définit les sous-propriétés utilisées principalement par le portail Azure pour afficher des informations conviviales :metadata: Defines subproperties primarily used by the Azure portal to display user-friendly information:
    • description: Explication du rôle du paramètre.description: The explanation of what the parameter is used for. Utilisable pour fournir des exemples de valeurs acceptables.Can be used to provide examples of acceptable values.
    • displayName: Nom convivial du paramètre visible dans le portail.displayName: The friendly name shown in the portal for the parameter.
    • strongType: (Facultatif) Utilisé lors de l’affectation de la définition de stratégie via le portail.strongType: (Optional) Used when assigning the policy definition through the portal. Fournit une liste prenant en compte le contexte.Provides a context aware list. Pour plus d’informations, voir strongType.For more information, see strongType.
    • assignPermissions: (Facultatif) Définissez l’option sur True pour que le portail Azure crée des attributions de rôles lors de l’attribution de stratégie.assignPermissions: (Optional) Set as true to have Azure portal create role assignments during policy assignment. Cette propriété est utile si vous souhaitez attribuer des autorisations en dehors de l’étendue d’attribution.This property is useful in case you wish to assign permissions outside the assignment scope. Il existe une attribution de rôle par définition de rôle dans la stratégie (ou par définition de rôle dans toutes les stratégies dans l’initiative).There is one role assignment per role definition in the policy (or per role definition in all of the policies in the initiative). La valeur du paramètre doit être une ressource ou une étendue valide.The parameter value must be a valid resource or scope.
  • defaultValue: (Facultatif) Définit la valeur du paramètre dans une affectation si aucune valeur n’est fournie.defaultValue: (Optional) Sets the value of the parameter in an assignment if no value is given. Obligatoire lors de la mise à jour d’une définition de stratégie existante qui est affectée.Required when updating an existing policy definition that is assigned.
  • allowedValues: (Facultatif) Fournit le tableau des valeurs que le paramètre accepte pendant l’attribution.allowedValues: (Optional) Provides an array of values that the parameter accepts during assignment.

Par exemple, vous pouvez définir une définition de stratégie qui limite les emplacements sur lesquels les ressources peuvent être déployées.As an example, you could define a policy definition to limit the locations where resources can be deployed. Le paramètre allowedLocations pourrait s’appliquer à cette définition de stratégie.A parameter for that policy definition could be allowedLocations. Ce paramètre serait utilisé par chaque affectation de la définition de la stratégie pour limiter les valeurs acceptées.This parameter would be used by each assignment of the policy definition to limit the accepted values. L’utilisation de strongType permet d’améliorer l’expérience lors de l’affectation via le portail :The use of strongType provides an enhanced experience when completing the assignment through the portal:

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

Utiliser une valeur de paramètreUsing a parameter value

Dans la règle de stratégie, vous référencez des paramètres avec la syntaxe de fonction parameters suivante :In the policy rule, you reference parameters with the following parameters function syntax:

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

Cet exemple fait référence au paramètre allowedLocations autorisé qui a été démontré dans les propriétés du paramètre.This sample references the allowedLocations parameter that was demonstrated in parameter properties.

strongTypestrongType

Dans la propriété metadata, vous pouvez utiliser strongType pour fournir une liste à choix multiple des options dans le portail Azure.Within the metadata property, you can use strongType to provide a multi-select list of options within the Azure portal. Les valeurs autorisées pour strongType incluent actuellement :Allowed values for strongType currently include:

  • location
  • resourceTypes
  • storageSkus
  • vmSKUs
  • existingResourceGroups
  • omsWorkspace
  • Microsoft.EventHub/Namespaces/EventHubs
  • Microsoft.EventHub/Namespaces/EventHubs/AuthorizationRules
  • Microsoft.EventHub/Namespaces/AuthorizationRules
  • Microsoft.RecoveryServices/vaults
  • Microsoft.RecoveryServices/vaults/backupPolicies

Emplacement de la définitionDefinition location

Lors de la création d’une initiative ou d’une stratégie, il est important de spécifier l’emplacement de la définition,While creating an initiative or policy, it's necessary to specify the definition location. qui doit être un groupe d’administration ou un abonnement.The definition location must be a management group or a subscription. L’emplacement détermine l’étendue à laquelle l’initiative ou la stratégie peut être affectée.This location determines the scope to which the initiative or policy can be assigned. Les ressources doivent être des membres directs ou des enfants dans la hiérarchie de l’emplacement de la définition à cibler pour l’affectation.Resources must be direct members of or children within the hierarchy of the definition location to target for assignment.

Si l’emplacement de la définition est l’un ou l’autre élément suivant :If the definition location is a:

  • Abonnement : seules les ressources au sein de cet abonnement peuvent être assignées à la stratégie.Subscription - Only resources within that subscription can be assigned the policy.
  • Groupe d’administration : seules les ressources au sein des groupes d’administration enfants et des abonnements enfants peuvent être assignées à la stratégie.Management group - Only resources within child management groups and child subscriptions can be assigned the policy. Si vous voulez appliquer la définition de stratégie à plusieurs abonnements, l’emplacement doit correspondre à un groupe d’administration comportant ces abonnements.If you plan to apply the policy definition to several subscriptions, the location must be a management group that contains those subscriptions.

Nom d’affichage et descriptionDisplay name and description

displayName et description permettent de distinguer la définition de stratégie et de préciser son contexte d’utilisation.You use displayName and description to identify the policy definition and provide context for when it's used. displayName a une longueur maximale de 128 caractères et description a une longueur maximale de 512 caractères.displayName has a maximum length of 128 characters and description a maximum length of 512 characters.

Règle de stratégiePolicy rule

La règle de stratégie se compose de blocs if et then.The policy rule consists of If and Then blocks. Dans le bloc if, vous définissez une ou plusieurs conditions qui spécifient à quel moment la stratégie est mise en œuvre.In the If block, you define one or more conditions that specify when the policy is enforced. Vous pouvez appliquer des opérateurs logiques à ces conditions pour définir avec précision le scénario d’une stratégie.You can apply logical operators to these conditions to precisely define the scenario for a policy.

Dans le bloc then, vous définissez l’effet qui se produit lorsque les conditions de si sont remplies.In the Then block, you define the effect that happens when the If conditions are fulfilled.

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

Opérateurs logiquesLogical operators

Les opérateurs logiques pris en charge sont les suivants :Supported logical operators are:

  • "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.The not syntax inverts the result of the condition. La syntaxe allOf (semblable à l’opération logique And) nécessite que toutes les conditions soient remplies.The allOf syntax (similar to the logical And operation) requires all conditions to be true. La syntaxe anyOf (semblable à l’opération logique Of) nécessite qu’au moins une des conditions soit remplie.The anyOf syntax (similar to the logical Or operation) requires one or more conditions to be true.

Vous pouvez imbriquer des opérateurs logiques.You can nest logical operators. L’exemple suivant illustre une opération not imbriquée dans une opération allOf.The following example shows a not operation that is nested within an allOf operation.

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

ConditionsConditions

Une condition évalue si un champ ou un accesseur de valeur répond à certains critères.A condition evaluates whether a field or the value accessor meets certain criteria. Les conditions prises en charge sont les suivantes :The supported conditions are:

  • "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": "value"
  • "lessOrEquals": "value"
  • "greater": "value"
  • "greaterOrEquals": "value"
  • "exists": "bool"

Avec les conditions like et notLike, un caractère générique * est indiqué dans la valeur.When using the like and notLike conditions, you provide a wildcard * in the value. Celle-ci ne doit pas en comporter plus d’un (*).The value shouldn't have more than one wildcard *.

Si vous utilisez les conditions match et notMatch, entrez # pour trouver un chiffre, ? pour une lettre, . pour un caractère et tout autre caractère pour représenter ce caractère réel.When using the match and notMatch conditions, provide # to match a digit, ? for a letter, . to match any character, and any other character to match that actual character. Les conditions match et notMatch sont sensibles à la casse.match and notMatch are case-sensitive. Des alternatives non sensibles à la casse sont disponibles dans matchInsensitively et notMatchInsensitively.Case-insensitive alternatives are available in matchInsensitively and notMatchInsensitively. Pour obtenir des exemples, voir Autoriser plusieurs modèles de noms.For examples, see Allow several name patterns.

ChampsFields

Les conditions sont formées à partir de champs.Conditions are formed by using fields. Un champ correspond à des propriétés de la charge utile de la demande de ressource et décrit l’état de la ressource.A field matches properties in the resource request payload and describes the state of the resource.

Les champs suivants sont pris en charge :The following fields are supported:

  • name
  • fullName
    • Retourne le nom complet de la ressource,Returns the full name of the resource. soit le nom de la ressource précédé du nom de toutes les ressources parentes (par exemple, « monServeur/maBaseDeDonnées »).The full name of a resource is the resource name prepended by any parent resource names (for example "myServer/myDatabase").
  • kind
  • type
  • location
  • 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.This bracket syntax supports tag names that have punctuation such as a hyphen, period, or space.
    • <tagName> est le nom de l’étiquette pour laquelle vérifier la condition.Where <tagName> is the name of the tag to validate the condition for.
    • Exemples : tags['Acct.CostCenter']Acct.CostCenter est le nom de l’étiquette.Examples: tags['Acct.CostCenter'] where Acct.CostCenter is the name of the tag.
  • 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.This bracket syntax supports tag names that have apostrophes in it by escaping with double apostrophes.
    • '<tagName>' est le nom de l’étiquette pour laquelle vérifier la condition.Where '<tagName>' is the name of the tag to validate the condition for.
    • Exemple : tags['''My.Apostrophe.Tag''']'My.Apostrophe.Tag est le nom de la balise.Example: tags['''My.Apostrophe.Tag'''] where 'My.Apostrophe.Tag' is the name of the tag.
  • alias de propriété : pour en obtenir la liste, consultez Alias.property aliases - for a list, see Aliases.

Notes

tags.<tagName>, tags[tagName] et tags[tag.with.dots] sont toujours des manières acceptables de déclarer un champ de balises.tags.<tagName>, tags[tagName], and tags[tag.with.dots] are still acceptable ways of declaring a tags field. Toutefois, les expressions préférées sont celles répertoriées ci-dessus.However, the preferred expressions are those listed above.

Utiliser des balises avec des paramètresUse tags with parameters

Une valeur de paramètre peut être passée à un champ de balise.A parameter value can be passed to a tag field. 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.Passing a parameter to a tag field increases the flexibility of the policy definition during policy assignment.

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.In the following example, concat is used to create a tags field lookup for the tag named the value of the tagName parameter. Si cette balise n’existe pas, l’effet Modifier est utilisé pour ajouter la balise à l’aide de la valeur de la même balise nommée définie sur le groupe de ressources parent des ressources auditées à l’aide de la fonction de recherche resourcegroup().If that tag doesn't exist, the modify effect is used to add the tag using the value of the same named tag set on the audited resources parent resource group by using the resourcegroup() lookup function.

{
    "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/b24988ac-6180-42a0-ab88-20f7382dd24c"
            ]
        }
    }
}

ValeurValue

Les conditions peuvent également être formées à l’aide de valeur.Conditions can also be formed using value. valeur vérifie les conditions selon les paramètres, les fonctions de modèle supportées ou des littéraux.value checks conditions against parameters, supported template functions, or literals. valeur est associée à n’importe quelle condition prise en charge.value is paired with any supported condition.

Avertissement

Si le résultat d’une fonction de modèle est une erreur, la stratégie d’évaluation échoue.If the result of a template function is an error, policy evaluation fails. Une évaluation ayant échoué correspond à un refus implicite.A failed evaluation is an implicit deny. Pour plus d’informations, consultez Éviter les défaillances des modèles.For more information, see avoiding template failures.

Exemples de valeurValue examples

Cet exemple de règle de stratégie utilise valeur pour comparer le résultat de la fonction resourceGroup() et la propriété nom renvoyée à une condition like de *netrg.This policy rule example uses value to compare the result of the resourceGroup() function and the returned name property to a like condition of *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.The rule denies any resource not of the Microsoft.Network/* type in any resource group whose name ends in *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 est égal à true.This policy rule example uses value to check if the result of multiple nested functions equals true. La règle refuse toute ressource qui n’a pas au moins trois balises.The rule denies any resource that doesn't have at least three tags.

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

Éviter les défaillances des modèlesAvoiding template failures

L’utilisation de fonctions de modèle dans value (valeur) autorise de nombreuses fonctions imbriquées complexes.The use of template functions in value allows for many complex nested functions. Si le résultat d’une fonction de modèle est une erreur, la stratégie d’évaluation échoue.If the result of a template function is an error, policy evaluation fails. Une évaluation ayant échoué correspond à un refus implicite.A failed evaluation is an implicit deny. Voici un exemple d’une valeur qui échoue dans certains scénarios :An example of a value that fails in certain scenarios:

{
    "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 nom avec abc.The example policy rule above uses substring() to compare the first three characters of name to abc. Si le nom a moins de 3 caractères, la fonction substring() génère une erreur.If name is shorter than three characters, the substring() function results in an error. Cette erreur fait que la stratégie produit un effet deny (refuser) .This error causes the policy to become a deny effect.

Au lieu de cela, utilisez la fonction if() pour vérifier si les 3 premiers caractères du nom sont égaux à abc pour éviter qu’un nom contenant moins de  3caractères entraîne une erreur :Instead, use the if() function to check if the first three characters of name equal abc without allowing a name shorter than three characters to cause an error:

{
    "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 nom avant d’essayer d’obtenir une substring() sur une valeur avec moins de 3 caractères.With the revised policy rule, if() checks the length of name before trying to get a substring() on a value with fewer than three characters. Si le nom est trop court, la valeur « ne commence pas par abc » est retournée à la place et comparée à abc.If name is too short, the value "not starting with abc" is returned instead and compared to 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.A resource with a short name that doesn't begin with abc still fails the policy rule, but no longer causes an error during evaluation.

CountCount

Les conditions qui comptent le nombre de membres d’un tableau dans la charge utile de la ressource satisfaisant une expression de condition peuvent être formées à l’aide d’une expression count.Conditions that count how many members of an array in the resource payload satisfy a condition expression can be formed using count expression. Les scénarios courants vérifient si « au moins un des », « un seul des », « tous les » ou « aucun des » membres du tableau remplissent la condition.Common scenarios are checking whether 'at least one of', 'exactly one of', 'all of', or 'none of' the array members satisfy the condition. count évalue chaque membre du tableau pour une expression de condition et additionne les résultats true, ce qui est ensuite comparé à l’opérateur d’expression.count evaluates each array member for a condition expression and sums the true results, which is then compared to the expression operator.

La structure de l’expression count est :The structure of the count expression is:

{
    "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 count :The following properties are used with count:

  • count.field (obligatoire) : contient le chemin du tableau et doit être un alias de tableau.count.field (required): Contains the path to the array and must be an array alias. Si le tableau est manquant, l’expression est évaluée à false sans tenir compte de l’expression de condition.If the array is missing, the expression is evaluated to false without considering the condition expression.
  • count.where (facultatif) : l’expression de condition pour évaluer individuellement chaque membre du tableau alias [*] de count.field.count.where (optional): The condition expression to individually evaluate each [*] alias array member of count.field. Si cette propriété n’est pas fournie, tous les membres du tableau avec le chemin « field » sont évalués à true.If this property is not provided, all array members with the path of 'field' are evaluated to true. Toute condition peut être utilisée à l’intérieur de cette propriété.Any condition can be used inside this property. Il est possible d’utiliser des opérateurs logiques à l’intérieur de cette propriété pour créer des exigences d’évaluation complexes.Logical operators can be used inside this property to create complex evaluation requirements.
  • <condition> (obligatoire) : la valeur est comparée au nombre d’éléments qui ont satisfait l’expression de condition count.where.<condition> (required): The value is compared to the number of items that met the count.where condition expression. Une condition numérique doit être utilisée.A numeric condition should be used.

Exemples de comptageCount examples

Exemple 1 : Vérifier si un tableau est videExample 1: Check if an array is empty

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

Exemple 2 : Rechercher un seul membre du tableau qui satisfait l’expression de conditionExample 2: Check for only one array member to meet the condition expression

{
    "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 conditionExample 3: Check for at least one array member to meet the condition expression

{
    "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 conditionExample 4: Check that all object array members meet the condition expression

{
    "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 que tous les membres du tableau de chaînes satisfont l’expression de conditionExample 5: Check that all string array members meet the condition expression

{
    "count": {
        "field": "Microsoft.Sql/servers/securityAlertPolicies/emailAddresses[*]",
        "where": {
            "field": "Microsoft.Sql/servers/securityAlertPolicies/emailAddresses[*]",
            "like": "*@contoso.com"
        }
    },
    "equals": "[length(field('Microsoft.Sql/servers/securityAlertPolicies/emailAddresses[*]'))]"
}

Exemple 6 : Utiliser field à l’intérieur de value pour vérifier que tous les membres du tableau satisfont l’expression de conditionExample 6: Use field inside value to check that all array members meet the condition expression

{
    "count": {
        "field": "Microsoft.Sql/servers/securityAlertPolicies/emailAddresses[*]",
        "where": {
            "value": "[last(split(first(field('Microsoft.Sql/servers/securityAlertPolicies/emailAddresses[*]')), '@'))]",
            "equals": "contoso.com"
        }
    },
    "equals": "[length(field('Microsoft.Sql/servers/securityAlertPolicies/emailAddresses[*]'))]"
}

Exemple 7 : Vérifier qu’au moins un membre du tableau correspond à plusieurs propriétés dans l’expression de conditionExample 7: Check that at least one array member matches multiple properties in the condition expression

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

RésultatEffect

Azure Policy prend en charge les types d’effet suivants :Azure Policy supports the following types of effect:

  • append : ajoute l’ensemble de champs défini à la requête.Append: adds the defined set of fields to the request
  • audit : génère un événement d’avertissement dans le journal d’activité, mais ne fait pas échouer la requête.Audit: generates a warning event in activity log but doesn't fail the request
  • AuditIfNotExists : génère un événement d’avertissement dans le journal d’activité si une ressource connexe n’existe pasAuditIfNotExists: generates a warning event in activity log if a related resource doesn't exist
  • deny : génère un événement dans le journal d’activité et fait échouer la requête.Deny: generates an event in the activity log and fails the request
  • DeployIfNotExists : déploie une ressource connexe si elle n’existe pas déjàDeployIfNotExists: deploys a related resource if it doesn't already exist
  • disabled : n’évalue pas la conformité des ressources à la règle de stratégie.Disabled: doesn't evaluate resources for compliance to the policy rule
  • EnforceOPAConstraint (préversion) : configure le contrôleur des admissions de l’agent de stratégie ouverte avec Gatekeeper V3 pour les clusters Kubernetes auto-managés sur Azure (préversion)EnforceOPAConstraint (preview): configures the Open Policy Agent admissions controller with Gatekeeper v3 for self-managed Kubernetes clusters on Azure (preview)
  • EnforceRegoPolicy (préversion) : configure le contrôleur des admissions de l’agent de stratégie ouverte avec Gatekeeper v2 dans Azure Kubernetes ServiceEnforceRegoPolicy (preview): configures the Open Policy Agent admissions controller with Gatekeeper v2 in Azure Kubernetes Service
  • Modify : ajoute, met à jour ou supprime les étiquettes définies dans une ressourceModify: adds, updates, or removes the defined tags from a resource

Pour plus d’informations sur chaque effet, l’ordre d’évaluation, les propriétés et des exemples, consultez Présentation des effets Azure Policy.For complete details on each effect, order of evaluation, properties, and examples, see Understanding Azure Policy Effects.

Fonctions de stratégiePolicy functions

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 :All Resource Manager template functions are available to use within a policy rule, except the following functions and user-defined functions:

  • copyIndex()copyIndex()
  • deployment()deployment()
  • list*list*
  • newGuid()newGuid()
  • pickZones()pickZones()
  • providers()providers()
  • reference()reference()
  • resourceId()resourceId()
  • variables()variables()

Les fonctions suivantes sont disponibles pour utilisation dans une règle de stratégie, mais diffèrent de l’utilisation dans un modèle Azure Resource Manager :The following functions are available to use in a policy rule, but differ from use in an Azure Resource Manager template:

  • addDays(dateTime, numberOfDaysToAdd)addDays(dateTime, numberOfDaysToAdd)
    • dateTime : [obligatoire] chaîne - chaîne au format date/heure universel ISO 8601 « yyyy-MM-ddTHH:mm:ss.fffffffZ »dateTime: [Required] string - String in the Universal ISO 8601 DateTime format 'yyyy-MM-ddTHH:mm:ss.fffffffZ'
    • numberOfDaysToAdd : [obligatoire] nombre entier - nombre de jours à ajouternumberOfDaysToAdd: [Required] integer - Number of days to add
  • utcNow() : contrairement à un modèle Resource Manager, cela peut être utilisé en dehors de defaultValue.utcNow() - Unlike a Resource Manager template, this can be used outside 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 »Returns a string that is set to the current date and time in Universal ISO 8601 DateTime format 'yyyy-MM-ddTHH:mm:ss.fffffffZ'

De plus, la fonction field est disponible pour les règles de stratégie.Additionally, the field function is available to policy rules. field est principalement utilisé avec AuditIfNotExists et DeployIfNotExists pour faire référence aux champs actuellement évalués de la ressource.field is primarily used with AuditIfNotExists and DeployIfNotExists to reference fields on the resource that are being evaluated. Vous pouvez en voir une illustration dans l’exemple DeployIfNotExists.An example of this use can be seen in the DeployIfNotExists example.

Exemple de fonction de stratégiePolicy function example

Cet exemple de règle de stratégie utilise la fonction de ressource resourceGroup pour obtenir la propriété name, combinée au tableau 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.This policy rule example uses the resourceGroup resource function to get the name property, combined with the concat array and object function to build a like condition that enforces the resource name to start with the resource group name.

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

AliasAliases

Les alias de propriété permettent d’accéder aux propriétés spécifiques d’un type de ressource.You use property aliases to access specific properties for a resource type. Les alias permettent de restreindre les valeurs ou les conditions autorisées pour la propriété d’une ressource.Aliases enable you to restrict what values or conditions are allowed for a property on a resource. Chaque alias correspond aux chemins des différentes versions d’API d’un type de ressource donné.Each alias maps to paths in different API versions for a given resource type. Lors de l’évaluation de la stratégie, le moteur de stratégie obtient le chemin de la propriété de cette version de l’API.During policy evaluation, the policy engine gets the property path for that API version.

La liste des alias augmente toujours.The list of aliases is always growing. Pour trouver les alias actuellement pris en charge par Azure Policy, utilisez l’une des méthodes suivantes :To find what aliases are currently supported by Azure Policy, use one of the following methods:

  • Extension Azure Policy pour Visual Studio Code (recommandée)Azure Policy extension for Visual Studio Code (recommended)

    Utilisez l’extension Azure Policy pour Visual Studio Code afin d’afficher et de découvrir les alias des propriétés de ressources.Use the Azure Policy extension for Visual Studio Code to view and discover aliases for resource properties.

    Extension Azure Policy pour Visual Studio Code

  • Azure Resource GraphAzure Resource Graph

    Utilisez l’opérateur project pour afficher l’alias d’une ressource.Use the project operator to display the alias of a resource.

    Resources
    | where type=~'microsoft.storage/storageaccounts'
    | limit 1
    | project aliases
    
    az graph query -q "Resources | where type=~'microsoft.storage/storageaccounts' | limit 1 | project aliases"
    
    Search-AzGraph -Query "Resources | where type=~'microsoft.storage/storageaccounts' | limit 1 | project aliases"
    
  • Azure PowerShellAzure PowerShell

    # Login first with Connect-AzAccount if not using Cloud Shell
    
    # Use Get-AzPolicyAlias to list available providers
    Get-AzPolicyAlias -ListAvailable
    
    # Use Get-AzPolicyAlias to list aliases for a Namespace (such as Azure Compute -- Microsoft.Compute)
    (Get-AzPolicyAlias -NamespaceMatch 'compute').Aliases
    
  • Azure CLIAzure CLI

    # Login first with az login if not using Cloud Shell
    
    # List namespaces
    az provider list --query [*].namespace
    
    # Get Azure Policy aliases for a specific Namespace (such as Azure Compute -- Microsoft.Compute)
    az provider show --namespace Microsoft.Compute --expand "resourceTypes/aliases" --query "resourceTypes[].aliases[].name"
    
  • API REST/ARMClientREST API / ARMClient

    GET https://management.azure.com/providers/?api-version=2017-08-01&$expand=resourceTypes/aliases
    

Comprendre l’alias [*]Understanding the [*] alias

Plusieurs des alias disponibles ont une version qui s’affiche sous la forme d’un nom « normal » et une autre avec [*] qui lui est attaché.Several of the aliases that are available have a version that appears as a 'normal' name and another that has [*] attached to it. Par exemple :For example:

  • Microsoft.Storage/storageAccounts/networkAcls.ipRules
  • Microsoft.Storage/storageAccounts/networkAcls.ipRules[*]

L’alias « normal » représente le champ sous la forme d’une valeur unique.The 'normal' alias represents the field as a single value. Ce champ est réservé aux scénarios de comparaison de correspondance exacte, lorsque l’ensemble de valeurs entier doit être exactement tel que défini, ni plus ni moins.This field is for exact match comparison scenarios when the entire set of values must be exactly as defined, no more and no less.

L’alias [*] permet de comparer la valeur de chaque élément du tableau et des propriétés spécifiques de chaque élément.The [*] alias makes it possible to compare against the value of each element in the array and specific properties of each element. Cette approche permet de comparer les propriétés d’élément pour les scénarios « if none of », «if any of » ou « if all of ».This approach makes it possible to compare element properties for 'if none of', 'if any of', or 'if all of' scenarios. Pour obtenir des scénarios plus complexes, utilisez l’expression de condition count.For more complex scenarios, use the count condition expression. Avec ipRules[*] , il s’agit, par exemple, de valider que chaque action est définie sur Deny (Refuser), sans se préoccuper de savoir combien de règles existent ou quelle est la valeur d’adresse IP.Using ipRules[*], an example would be validating that every action is Deny, but not worrying about how many rules exist or what the IP value is. Cet exemple de règle vérifie toutes les correspondances de ipRules[*].value avec 10.0.4.1 et applique effectType uniquement s’il ne trouve pas au moins une correspondance :This sample rule checks for any matches of ipRules[*].value to 10.0.4.1 and applies the effectType only if it doesn't find at least one match:

"policyRule": {
    "if": {
        "allOf": [
            {
                "field": "Microsoft.Storage/storageAccounts/networkAcls.ipRules",
                "exists": "true"
            },
            {
                "field": "Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].value",
                "notEquals": "10.0.4.1"
            }
        ]
    },
    "then": {
        "effect": "[parameters('effectType')]"
    }
}

Pour plus d’informations, consultez l’évaluation de l’alias [*].For more information, see evaluating the [*] alias.

InitiativesInitiatives

Les initiatives vous permettent de regrouper en un seul élément plusieurs définitions de stratégies associées pour simplifier les affectations et la gestion.Initiatives enable you to group several related policy definitions to simplify assignments and management because you work with a group as a single item. Par exemple, vous pouvez regrouper des définitions de stratégies de balisage associées en une même initiative.For example, you can group related tagging policy definitions into a single initiative. Au lieu d’attribuer chaque stratégie individuellement, vous appliquez l’initiative.Rather than assigning each policy individually, you apply the initiative.

L’exemple suivant montre comment créer une initiative pour gérer deux balises : costCenter et productName.The following example illustrates how to create an initiative for handling two tags: costCenter and productName. Il utilise deux stratégies intégrées pour appliquer la valeur de balise par défaut.It uses two built-in policies to apply the default tag value.

{
    "properties": {
        "displayName": "Billing Tags Policy",
        "policyType": "Custom",
        "description": "Specify cost Center tag and product name tag",
        "parameters": {
            "costCenterValue": {
                "type": "String",
                "metadata": {
                    "description": "required value for Cost Center tag"
                }
            },
            "productNameValue": {
                "type": "String",
                "metadata": {
                    "description": "required value for product Name tag"
                }
            }
        },
        "policyDefinitions": [{
                "policyDefinitionId": "/providers/Microsoft.Authorization/policyDefinitions/1e30110a-5ceb-460c-a204-c1c3969c6d62",
                "parameters": {
                    "tagName": {
                        "value": "costCenter"
                    },
                    "tagValue": {
                        "value": "[parameters('costCenterValue')]"
                    }
                }
            },
            {
                "policyDefinitionId": "/providers/Microsoft.Authorization/policyDefinitions/2a0e14a6-b0a6-4fab-991a-187a4f81c498",
                "parameters": {
                    "tagName": {
                        "value": "costCenter"
                    },
                    "tagValue": {
                        "value": "[parameters('costCenterValue')]"
                    }
                }
            },
            {
                "policyDefinitionId": "/providers/Microsoft.Authorization/policyDefinitions/1e30110a-5ceb-460c-a204-c1c3969c6d62",
                "parameters": {
                    "tagName": {
                        "value": "productName"
                    },
                    "tagValue": {
                        "value": "[parameters('productNameValue')]"
                    }
                }
            },
            {
                "policyDefinitionId": "/providers/Microsoft.Authorization/policyDefinitions/2a0e14a6-b0a6-4fab-991a-187a4f81c498",
                "parameters": {
                    "tagName": {
                        "value": "productName"
                    },
                    "tagValue": {
                        "value": "[parameters('productNameValue')]"
                    }
                }
            }
        ]
    },
    "id": "/subscriptions/<subscription-id>/providers/Microsoft.Authorization/policySetDefinitions/billingTagsPolicy",
    "type": "Microsoft.Authorization/policySetDefinitions",
    "name": "billingTagsPolicy"
}

Étapes suivantesNext steps