Structure de définition Azure PolicyAzure Policy definition structure

Une définition de stratégie de ressource utilisée par Azure Policy vous permet d’établir des conventions pour les ressources de votre organisation en décrivant quand la stratégie est appliquée et la mesure à prendre.Resource policy definition used by Azure Policy enables you to establish conventions for resources in your organization by describing when the policy is enforced and what effect to take. 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. Ainsi, si une stratégie est appliquée à un groupe de ressources, elle est applicable à toutes les ressources appartenant à ce groupe de ressources.So, if a policy is applied to a resource group, it is applicable to all the resources in that resource group.

Le schéma utilisé par Azure Policy se trouve ici : https://schema.management.azure.com/schemas/2016-12-01/policyDefinition.jsonThe schema used by Azure Policy can be found here: https://schema.management.azure.com/schemas/2016-12-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:

  • le 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"
                }
            }
        },
        "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"
            }
        }
    }
}

Pour découvrir tous les exemples de modèles Azure Policy, consultez Modèles pour Azure Policy.All Azure Policy template samples are at Templates for Azure Policy.

ModeMode

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 contient pas de valeur mode, sa valeur par défaut est all dans Azure PowerShell et null dans Azure CLI, ce qui équivaut à indexed, à des fins de compatibilité descendante.If the policy definition does not contain a mode value it defaults to all in Azure PowerShell and to null in Azure CLI, which is equivalent to indexed, for backwards compatibility.

indexed doit être utilisé lors de la création de stratégies qui appliqueront des balises ou des emplacements.indexed should be used when creating policies that will enforce tags or locations. Cela n’est pas nécessaire, mais empêche les ressources qui ne prennent pas en charge les balises et les emplacements de s’afficher comme des résultats non conformes dans les résultats de conformité.This isn't required but it will prevent resources that don't support tags and locations from showing up as non-compliant in the compliance results. La seule exception est les groupes de ressources.The one exception to this is resource groups. Les stratégies qui tentent d’appliquer des emplacements ou des balises à un groupe de ressources doivent définir mode sur all et cibler spécifiquement le type Microsoft.Resources/subscriptions/resourceGroup.Policies that are attempting to enforce location or tags on a resource group should set mode to all and specifically target the Microsoft.Resources/subscriptions/resourceGroup type. Pour exemple, consultez Appliquer des balises au groupe de ressources.For an example, see Enforce resource group tags.

parametersParameters

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.

Par exemple, vous pouvez définir une stratégie pour une propriété de ressource afin de limiter les emplacements sur lesquels les ressources peuvent être déployées.For example, you could define a policy for a resource property to limit the locations where resources can be deployed. Dans ce cas, vous déclarez les paramètres suivants quand vous créez votre stratégie :In this case, you would declare the following parameters when you create your policy:

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

Le type d’un paramètre peut être une chaîne ou un tableau.The type of a parameter can be either string or array. La propriété de métadonnées est utilisée pour des outils comme le portail Azure pour afficher des informations conviviales.The metadata property is used for tools like the Azure portal to display user-friendly information.

Dans la propriété de métadonnées, 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"

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

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

Emplacement de la définitionDefinition location

Quand vous créez une définition d’initiative ou de stratégie, il est important de spécifier son emplacement.While creating an initiative or policy definition, it is important that you specify the definition location.

L’emplacement de la définition détermine l’étendue à laquelle la définition d’initiative ou de stratégie peut être affectée.The definition location determines the scope to which the initiative or policy definition can be assigned to. L’emplacement peut être spécifié en tant que groupe d’administration ou d’abonnement.The location can be specified as a management group or a subscription.

Note

Si vous envisagez d’appliquer cette définition de stratégie à plusieurs abonnements, l’emplacement doit correspondre à un groupe d’administration qui contient les abonnements auxquels vous allez affecter l’initiative ou la stratégie.If you plan to apply this policy definition to multiple subscriptions, the location must be a management group that contains the subscriptions you will assign the initiative or policy to.

Nom d’affichage et descriptionDisplay name and description

Vous pouvez utiliser displayName et description pour distinguer la définition de stratégie et préciser le contexte d’utilisation.You can use displayName and description to identify the policy definition and provide context for when it is used.

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

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 (field) répond à certains critères.A condition evaluates whether a field meets certain criteria. Les conditions prises en charge sont les suivantes :The supported conditions are:

  • "equals": "value"
  • "notEquals": "value"
  • "like": "value"
  • "notLike": "value"
  • "match": "value"
  • "notMatch": "value"
  • "contains": "value"
  • "notContains": "value"
  • "in": ["value1","value2"]
  • "notIn": ["value1","value2"]
  • "containsKey": "keyName"
  • "notContainsKey": "keyName"
  • "exists": "bool"

Lorsque vous utilisez les conditions j’aime et je n’aime pas, vous pouvez utiliser un caractère générique (*) dans la valeur.When using the like and notLike conditions, you can provide a wildcard (*) in the value.

Lorsque vous utilisez les conditions correspondance et non correspondance entrez # pour représenter un chiffre, ? pour une lettre et tout autre caractère pour représenter ce caractère réel.When using the match and notMatch conditions, provide # to represent a digit, ? for a letter, and any other character to represent that actual character. Pour obtenir des exemples, consultez Autoriser plusieurs modèles de nom.For examples, see Allow multiple name patterns.

ChampsFields

Les conditions sont formées à partir de champs.Conditions are formed by using fields. Un champ représente des propriétés dans la charge utile de la requête de ressource qui est utilisée pour décrire l'état de la ressource.A field represents properties in the resource request payload that is used to describe 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, y compris les parents (par exemple « myServer/myDatabase »)Returns the full name of the resource, including any parents (for example "myServer/myDatabase")
  • kind
  • type
  • location
  • tags
  • tags.tagName
  • tags[tagName]
    • Cette syntaxe en crochet prend en charge les noms de balise qui contiennent des pointsThis bracket syntax supports tag names that contain periods
  • alias de propriété : pour en obtenir la liste, consultez Alias.property aliases - for a list, see Aliases.

Autres accesseursAlternative Accessors

Champ est l’accesseur principal utilisé dans les règles de stratégie.Field is the primary accessor used in policy rules. Il inspecte directement la ressource qui est évaluée.It directly inspects the resource that is being evaluated. Toutefois, la stratégie prend en charge un autre accesseur, source.However, policy supports one other accessor, source.

"source": "action",
"equals": "Microsoft.Compute/virtualMachines/write"

Source ne prend en charge qu’une seule valeur, action.Source only supports one value, action. Action retourne l’action d’autorisation de la requête en cours d’évaluation.Action returns the authorization action of the request that is being evaluated. Les actions d’autorisation sont exposées dans la section d’autorisation du journal d’activité.Authorization actions are exposed in the authorization section of the Activity Log.

Quand la stratégie évalue les ressources existantes en arrière-plan, elle définit action sur une action d’autorisation /write sur le type de ressource.When policy is evaluating existing resources in the background, it sets action to a /write authorization action on the resource's type.

RésultatEffect

La stratégie prend en charge les types d’effet suivants :Policy supports the following types of effect:

  • deny : génère un événement dans le journal d’audit et fait échouer la requête.Deny: generates an event in the audit log and fails the request
  • audit : génère un événement d’avertissement dans le journal d’audit, mais ne fait pas échouer la requête.Audit: generates a warning event in audit log but does not fail the request
  • append : ajoute l’ensemble de champs défini à la requête.Append: adds the defined set of fields to the request
  • AuditIfNotExists : active l’audit si une ressource n’existe pas.AuditIfNotExists: enables auditing if a resource does not exist
  • DeployIfNotExists : déploie une ressource si elle n’existe pas déjà.DeployIfNotExists: deploys a resource if it does not already exist. Actuellement, cet effet est uniquement pris en charge par le biais de stratégies intégrées.Currently, this effect is only supported through built-in policies.

Pour append, vous devez fournir les détails suivants :For append, you must provide the following details:

"effect": "append",
"details": [{
    "field": "field name",
    "value": "value of the field"
}]

La valeur peut être une chaîne ou un objet au format JSON.The value can be either a string or a JSON format object.

Avec AuditIfNotExists et DeployIfNotExists, vous pouvez évaluer l’existence d’une ressource connexe et appliquer une règle et un effet correspondant quand cette ressource n’existe pas.With AuditIfNotExists and DeployIfNotExists you can evaluate the existence of a related resource and apply a rule and a corresponding effect when that resource does not exist. Par exemple, vous pouvez exiger qu’un observateur réseau soit déployé pour tous les réseaux virtuels.For example, you can require that a network watcher is deployed for all virtual networks. Pour obtenir un exemple d’audit quand une extension de machine virtuelle n’est pas déployée, consultez Auditer si une extension n’existe pas.For an example of auditing when a virtual machine extension is not deployed, see Audit if extension does not exist.

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 permitted 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 découvrir les alias actuellement pris en charge par Azure Policy, utilisez une des méthodes suivantes :To discover what aliases are currently supported by Azure Policy, use one of the following methods:

  • Azure PowerShellAzure PowerShell

    # Login first with Connect-AzureRmAccount if not using Cloud Shell
    
    $azContext = Get-AzureRmContext
    $azProfile = [Microsoft.Azure.Commands.Common.Authentication.Abstractions.AzureRmProfileProvider]::Instance.Profile
    $profileClient = New-Object -TypeName Microsoft.Azure.Commands.ResourceManager.Common.RMProfileClient -ArgumentList ($azProfile)
    $token = $profileClient.AcquireAccessToken($azContext.Subscription.TenantId)
    $authHeader = @{
        'Content-Type'='application/json'
        'Authorization'='Bearer ' + $token.AccessToken
    }
    
    # Invoke the REST API
    $response = Invoke-RestMethod -Uri 'https://management.azure.com/providers/?api-version=2017-08-01&$expand=resourceTypes/aliases' -Method Get -Headers $authHeader
    
    # Create an Array List to hold discovered aliases
    $aliases = New-Object System.Collections.ArrayList
    
    foreach ($ns in $response.value) {
        foreach ($rT in $ns.resourceTypes) {
            if ($rT.aliases) {
                foreach ($obj in $rT.aliases) {
                    $alias = [PSCustomObject]@{
                        Namespace       = $ns.namespace
                        resourceType    = $rT.resourceType
                        alias           = $obj.name
                    }
                    $aliases.Add($alias) | Out-Null
                }
            }
        }
    }
    
    # Output the list, sort, and format. You can customize with Where-Object to limit as desired.
    $aliases | Sort-Object -Property Namespace, resourceType, alias | Format-Table
    
  • Azure CLIAzure CLI

    # Login first with az login if not using Cloud Shell
    
    # Get Azure Policy aliases for a specific Namespace
    az provider show --namespace Microsoft.Automation --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
    

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 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 toutes les définitions de stratégies de balisage associées en une même initiative.For example, you can group all related tagging policy definitions in 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