Azure Policy-definitionsstruktur

Azure Policy upprättar konventioner för resurser. Principdefinitioner beskriver resursefterlevnadsvillkor och vilken effekt som ska gälla om ett villkor uppfylls. Ett villkor jämför ett fält eller ett värde för en resursegenskap med ett obligatoriskt värde. Resursegenskapsfält används med hjälp av alias. När ett resursegenskapsfält är en matris kan ett särskilt matrisalias användas för att välja värden från alla matrismedlemmar och tillämpa ett villkor på var och en. Läs mer om villkor.

Genom att definiera konventioner kan du kontrollera kostnaderna och enklare hantera dina resurser. Du kan till exempel ange att endast vissa typer av virtuella datorer tillåts. Eller så kan du kräva att resurserna har en viss tagg. Principtilldelningar ärvs av underordnade resurser. Om en principtilldelning används för en resursgrupp är den tillämplig på alla resurser i den resursgruppen.

Schemat policy definition policyRule finns här: https://schema.management.azure.com/schemas/2020-10-01/policyDefinition.json

Du använder JSON för att skapa en principdefinition. Principdefinitionen innehåller element för:

  • visningsnamn
  • beskrivning
  • mode
  • metadata
  • parametrar
  • principregel
    • logisk utvärdering
    • Effekt av

Följande JSON visar till exempel en princip som begränsar var resurser distribueras:

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

Azure Policy inbyggda och mönster finns i Azure Policy exempel.

Visningsnamn och beskrivning

Du använder displayName och beskrivning för att identifiera principdefinitionen och ange kontext för när den används. displayName har en maximal längd på 128 tecken och en beskrivning på högst 512 tecken.

Anteckning

När du skapar eller uppdaterar en principdefinition definieras id, typ och namn av egenskaper som är externa för JSON och behövs inte i JSON-filen. Om du hämtar principdefinitionen via SDK returneras egenskaperna id, typ och namn som en del av JSON,men var och en är skrivskyddad information relaterad till principdefinitionen.

Typ

Även om typegenskapen inte kan anges finns det tre värden som returneras av SDK och visas i portalen:

  • Builtin: Dessa principdefinitioner tillhandahålls och underhålls av Microsoft.
  • Custom: Alla principdefinitioner som skapats av kunder har det här värdet.
  • Static: Anger en principdefinition för regelefterlevnad med Microsoft Ownership. Efterlevnadsresultaten för dessa principdefinitioner är resultatet av granskningar från tredje part i Microsofts infrastruktur. I Azure Portal visas det här värdet ibland som Microsoft-hanterat. Mer information finns i Delat ansvar i molnet.

Läge

Läget konfigureras beroende på om principen är inriktad på en Azure Resource Manager-egenskap eller en resursprovideregenskap.

Resource Manager lägen

Läget avgör vilka resurstyper som utvärderas för en principdefinition. De lägen som stöds är:

  • all: utvärdera resursgrupper, prenumerationer och alla resurstyper
  • indexed: utvärdera endast resurstyper som stöder taggar och platser

Resursen Microsoft.Network/routeTables stöder till exempel taggar och platser och utvärderas i båda lägena. Resursen kan dock Microsoft.Network/routeTables/routes inte taggas och utvärderas inte i Indexed läge.

Vi rekommenderar att du anger läget till all i de flesta fall. Alla principdefinitioner som skapas via portalen använder all läget. Om du använder PowerShell eller Azure CLI kan du ange lägesparametern manuellt. Om principdefinitionen inte innehåller ett lägesvärdeall är standardvärdet i Azure PowerShell och till null i Azure CLI. Ett null läge är detsamma som att använda indexed för att stödja bakåtkompatibilitet.

indexed ska användas när du skapar principer som framtvingar taggar eller platser. Även om det inte krävs förhindrar det att resurser som inte stöder taggar och platser visas som inkompatibla i efterlevnadsresultaten. Undantaget är resursgrupper och prenumerationer. Principdefinitioner som framtvingar plats eller taggar för en resursgrupp eller prenumeration bör ange läge till all och specifikt rikta in sig Microsoft.Resources/subscriptions/resourceGroups på typen eller Microsoft.Resources/subscriptions . Ett exempel finns i Mönster: Taggar – Exempel #1. En lista över resurser som stöder taggar finns i Taggstöd för Azure-resurser.

Lägen för resursprovider

Följande lägen för resursprovider stöds fullt ut:

  • Microsoft.Kubernetes.Data för att hantera Kubernetes-kluster och komponenter som poddar, containrar och ingresser. Stöds för Azure Kubernetes Service kluster och Azure Arc-aktiverade Kubernetes-kluster. Definitioner som använder det här resursproviderläget använder effektgranskning, neka och inaktiverad.
  • Microsoft.KeyVault.Dataför hantering av valv och certifikat i Azure Key Vault. Mer information om dessa principdefinitioner finns i Integrera Azure Key Vault med Azure Policy.

Följande lägen för resursprovider stöds för närvarande som en förhandsversion:

Anteckning

Om inget uttryckligen anges stöder resursproviderlägen endast inbyggda principdefinitioner, och undantag stöds inte på komponentnivå.

Metadata

Den valfria metadata egenskapen lagrar information om principdefinitionen. Kunder kan definiera alla egenskaper och värden som är användbara för deras organisation i metadata. Det finns dock några vanliga egenskaper som används av Azure Policy och inbyggda. Varje metadata egenskap har en gräns på 1 024 tecken.

Vanliga metadataegenskaper

  • version (sträng): Spårar information om versionen av innehållet i en principdefinition.
  • category(sträng): Avgör under vilken kategori i Azure Portal principdefinitionen visas.
  • preview (booleskt): Sant eller falskt flagga för om principdefinitionen är förhandsversion.
  • deprecated (booleskt): Sant eller falskt flagga för om principdefinitionen har markerats som inaktuell.
  • portalReview (sträng): Avgör om parametrar ska granskas i portalen, oavsett vilka indata som krävs.

Anteckning

Azure Policy-tjänsten använder versionegenskaperna , previewoch deprecated för att förmedla ändringsnivån till en inbyggd principdefinition eller initiativ och tillstånd. Formatet version är: {Major}.{Minor}.{Patch}. Specifika tillstånd, till exempel inaktuella eller förhandsgranskning, läggs till i version egenskapen eller i en annan egenskap som ett booleskt värde. Mer information om hur Azure Policy inbyggda versioner finns i Inbyggd versionshantering. Mer information om vad det innebär för en princip att bli inaktuell eller i förhandsversion finns i Förhandsversion och inaktuella principer.

Parametrar

Parametrar underlättar hanteringen av principer genom att minska antalet principdefinitioner. Tänk på parametrar som fälten i ett formulär - name, address, city, state. Dessa parametrar förblir alltid desamma, men deras värden ändras baserat på den person som fyller i formuläret. Parametrar fungerar på samma sätt när du skapar principer. Genom att inkludera parametrar i en principdefinition kan du återanvända principen för olika scenarier med hjälp av olika värden.

Anteckning

Parametrar kan läggas till i en befintlig och tilldelad definition. Den nya parametern måste innehålla egenskapen defaultValue . Detta förhindrar att befintliga tilldelningar av principen eller initiativet indirekt blir ogiltiga.

Parameteregenskaper

En parameter har följande egenskaper som används i principdefinitionen:

  • name: Namnet på parametern. Används av distributionsfunktionen parameters i principregeln. Mer information finns i använda ett parametervärde.
  • type: Avgör om parametern är en sträng, matris, objekt, boolesk, heltal, flyttal eller datetime.
  • metadata: Definierar underegenskaper som främst används av Azure Portal för att visa användarvänlig information:
    • description: Förklaringen av vad parametern används för. Kan användas för att ge exempel på godtagbara värden.
    • displayName: Det egna namnet som visas i portalen för parametern.
    • strongType: (Valfritt) Används när du tilldelar principdefinitionen via portalen. Innehåller en sammanhangsmedveten lista. Mer information finns i strongType.
    • assignPermissions: (Valfritt) Ange som sant för att ha Azure Portal skapa rolltilldelningar under principtilldelningen. Den här egenskapen är användbar om du vill tilldela behörigheter utanför tilldelningsomfånget. Det finns en rolltilldelning per rolldefinition i principen (eller per rolldefinition i alla principer i initiativet). Parametervärdet måste vara en giltig resurs eller ett giltigt omfång.
  • defaultValue: (Valfritt) Anger värdet för parametern i en tilldelning om inget värde anges. Krävs när du uppdaterar en befintlig principdefinition som har tilldelats. För oject-type-parametrar måste värdet matcha rätt schema.
  • allowedValues: (Valfritt) Tillhandahåller en matris med värden som parametern accepterar under tilldelningen. Tillåtna värdejämförelser är skiftlägeskänsliga. För oject-type-parametrar måste värdena matcha rätt schema.
  • schema: (Valfritt) Ger validering av parameterindata under tilldelningen med hjälp av ett självdefinierat JSON-schema. Den här egenskapen stöds endast för objekttypsparametrar och följer implementeringen Json.NET Schema 2019-09. Du kan lära dig mer om att använda scheman på https://json-schema.org/ och testa utkastscheman på https://www.jsonschemavalidator.net/.

Exempelparametrar

Exempel 1

Du kan till exempel definiera en principdefinition för att begränsa de platser där resurser kan distribueras. En parameter för den principdefinitionen kan vara allowedLocations. Den här parametern används av varje tilldelning av principdefinitionen för att begränsa de godkända värdena. Användningen av strongType ger en förbättrad upplevelse när du slutför tilldelningen via portalen:

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

Ett exempel på indata för den här parametern av matristyp (utan strongType) vid tilldelningstiden kan vara ["westus", "eastus2"].

Exempel 2

I ett mer avancerat scenario kan du definiera en princip som kräver att Kubernetes-klusterpoddar använder angivna etiketter. En parameter för den principdefinitionen kan vara labelSelector, som används av varje tilldelning av principdefinitionen för att ange Kubernetes-resurser i fråga baserat på etikettnycklar och värden:

"parameters": {
    "labelSelector": {
        "type": "Object",
        "metadata": {
            "displayName": "Kubernetes label selector",
            "description": "Label query to select Kubernetes resources for policy evaluation. An empty label selector matches all Kubernetes resources."
        },
        "defaultValue": {},
        "schema": {
            "description": "A label selector is a label query over a set of resources. The result of matchLabels and matchExpressions are ANDed. An empty label selector matches all resources.",
            "type": "object",
            "properties": {
                "matchLabels": {
                    "description": "matchLabels is a map of {key,value} pairs.",
                    "type": "object",
                    "additionalProperties": {
                        "type": "string"
                    },
                    "minProperties": 1
                },
                "matchExpressions": {
                    "description": "matchExpressions is a list of values, a key, and an operator.",
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "key": {
                                "description": "key is the label key that the selector applies to.",
                                "type": "string"
                            },
                            "operator": {
                                "description": "operator represents a key's relationship to a set of values.",
                                "type": "string",
                                "enum": [
                                    "In",
                                    "NotIn",
                                    "Exists",
                                    "DoesNotExist"
                                ]
                            },
                            "values": {
                                "description": "values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty.",
                                "type": "array",
                                "items": {
                                    "type": "string"
                                }
                            }
                        },
                        "required": [
                            "key",
                            "operator"
                        ],
                        "additionalProperties": false
                    },
                    "minItems": 1
                }
            },
            "additionalProperties": false
        }
    },
}

Ett exempel på indata för den här parametern av objekttyp vid tilldelningstiden skulle vara i JSON-format, validerat av det angivna schemat och kan vara:

{
    "matchLabels": {
        "poolID": "abc123",
        "nodeGroup": "Group1",
        "region": "southcentralus"
    },
    "matchExpressions": [
        {
            "key": "name",
            "operator": "In",
            "values": ["payroll", "web"]
        },
        {
            "key": "environment",
            "operator": "NotIn",
            "values": ["dev"]
        }
    ]
}

Använda ett parametervärde

I principregeln refererar du till parametrar med följande parameters funktionssyntax:

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

Det här exemplet refererar till parametern allowedLocations som visades i parameteregenskaper.

strongType

I egenskapen metadata kan du använda strongType för att tillhandahålla en flervalslista med alternativ i Azure Portal. strongType kan vara en resurstyp som stöds eller ett tillåtet värde. Om du vill avgöra om en resurstyp är giltig för strongType använder du Get-AzResourceProvider. Formatet för en resurstypstrongType är <Resource Provider>/<Resource Type>. Till exempel Microsoft.Network/virtualNetworks/subnets.

Vissa resurstyper som inte returneras av Get-AzResourceProvider stöds. Dessa typer är:

  • Microsoft.RecoveryServices/vaults/backupPolicies

De värden som inte är tillåtna för resurstypen för strongType är:

  • location
  • resourceTypes
  • storageSkus
  • vmSKUs
  • existingResourceGroups

Definitionsplats

När du skapar ett initiativ eller en princip måste du ange definitionsplatsen. Definitionsplatsen måste vara en hanteringsgrupp eller en prenumeration. Den här platsen bestämmer det omfång som initiativet eller principen kan tilldelas till. Resurser måste vara direkta medlemmar i eller underordnade i hierarkin för den definitionsplats som ska riktas för tilldelning.

Om definitionsplatsen är en:

  • Prenumeration – Endast resurser i den prenumerationen kan tilldelas principdefinitionen.
  • Hanteringsgrupp – Endast resurser i underordnade hanteringsgrupper och underordnade prenumerationer kan tilldelas principdefinitionen. Om du planerar att tillämpa principdefinitionen på flera prenumerationer måste platsen vara en hanteringsgrupp som innehåller varje prenumeration.

Mer information finns i Förstå omfång i Azure Policy.

Principregel

Principregeln består av om och sedan block. I om-blocket definierar du ett eller flera villkor som anger när principen tillämpas. Du kan använda logiska operatorer för dessa villkor för att exakt definiera scenariot för en princip.

I blocket Sedan definierar du den effekt som inträffar när if-villkoren uppfylls.

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

Logiska operatorer

Logiska operatorer som stöds är:

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

Inte syntaxen invertera resultatet av villkoret. AllOf-syntaxen (liknar den logiska och åtgärden) kräver att alla villkor är sanna. AnyOf-syntaxen (liknar den logiska eller åtgärden) kräver att ett eller flera villkor är sanna.

Du kan kapsla logiska operatorer. I följande exempel visas en icke-åtgärd som är kapslad i en allOf-åtgärd .

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

Villkor

Ett villkor utvärderar om ett värde uppfyller vissa kriterier. De villkor som stöds är:

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

För less, lessOrEquals, greater och greaterOrEquals utlöses ett fel om egenskapstypen inte matchar villkorstypen. Strängjämförelser görs med .InvariantCultureIgnoreCase

När du använder villkoren like och notLike anger du ett jokertecken * i värdet. Värdet får inte ha fler än ett jokertecken *.

När du använder matchnings - och notMatch-villkor anger # du att matcha en siffra, ? en bokstav, . så att den matchar alla tecken och andra tecken som matchar det faktiska tecknet. Matchning och notMatch är skiftlägeskänsliga, men alla andra villkor som utvärderar en stringValue är skiftlägesokänsliga. Skiftlägesokänsliga alternativ är tillgängliga i matchInsensitively och inteMatchInsensitively.

Fält

Villkor som utvärderar om värdena för egenskaper i resursbegärans nyttolast uppfyller vissa kriterier kan skapas med hjälp av ett fältuttryck . Följande fält stöds:

  • name
  • fullName
    • Returnerar resursens fullständiga namn. Det fullständiga namnet på en resurs är resursnamnet som läggs till av överordnade resursnamn (till exempel "myServer/myDatabase").
  • kind
  • type
  • location
    • Platsfält normaliseras för att stödja olika format. Till exempel East US 2 anses vara lika med eastus2.
    • Använd global för resurser som är platsagnostiska.
  • id
    • Returnerar resurs-ID för resursen som utvärderas.
    • Exempel: /subscriptions/06be863d-0996-4d56-be22-384767287aa2/resourceGroups/myRG/providers/Microsoft.KeyVault/vaults/myVault
  • identity.type
  • tags
  • tags['<tagName>']
    • Den här hakparentessyntaxen stöder taggnamn som har skiljetecken, till exempel bindestreck, punkt eller blanksteg.
    • Där <tagName> är namnet på taggen som villkoret ska verifieras för.
    • Exempel: tags['Acct.CostCenter'] där Acct.CostCenter är namnet på taggen.
  • tags['''<tagName>''']
    • Den här hakparentessyntaxen stöder taggnamn som har apostrofer i sig genom att fly med dubbla apostrofer.
    • Där "<tagName>" är namnet på taggen som villkoret ska verifieras för.
    • Exempel: tags['''My.Apostrophe.Tag'''] där "My.Apostrophe.Tag" är namnet på taggen.
  • egenskapsalias – en lista finns i Alias.

Anteckning

tags.<tagName>, tags[tagName]och tags[tag.with.dots] är fortfarande godkända sätt att deklarera ett taggfält. De föredragna uttrycken är dock de som anges ovan.

Anteckning

I fältuttryck som refererar till [*] alias utvärderas varje element i matrisen individuellt med logiska och mellan element. Mer information finns i Referera till matrisresursegenskaper.

Använda taggar med parametrar

Ett parametervärde kan skickas till ett taggfält. Om du skickar en parameter till ett taggfält ökar flexibiliteten för principdefinitionen under principtilldelningen.

I följande exempel concat används för att skapa en taggfältsökning för taggen med namnet värdet för parametern tagName . Om taggen inte finns används ändringseffekten för att lägga till taggen med hjälp av värdet för samma namngivna tagguppsättning i den överordnade resursgruppen för granskade resurser med hjälp resourcegroup() av uppslagsfunktionen.

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

Värde

Villkor som utvärderar om ett värde uppfyller vissa villkor kan skapas med hjälp av ett värdeuttryck . Värden kan vara literaler, värden för parametrar eller returnerade värden för alla mallfunktioner som stöds.

Varning

Om resultatet av en mallfunktion är ett fel misslyckas principutvärderingen. En misslyckad utvärdering är en implicit nekande. Mer information finns i Undvika fel i mallar. Använd enforcementMode för DoNotEnforce för att förhindra påverkan av en misslyckad utvärdering på nya eller uppdaterade resurser när du testar och validerar en ny principdefinition.

Värdeexempel

Det här principregelexemplet använder värdet för att jämföra resultatet av resourceGroup() funktionen och den returnerade namnegenskapen med ett liknande villkor för *netrg. Regeln nekar alla resurser som inte är av typenMicrosoft.Network/* i en resursgrupp vars namn slutar på .*netrg

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

Det här principregelexemplet använder värde för att kontrollera om resultatet av flera kapslade funktioner ärtrue lika med. Regeln nekar alla resurser som inte har minst tre taggar.

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

Undvika mallfel

Användning av mallfunktioner i värde möjliggör många komplexa kapslade funktioner. Om resultatet av en mallfunktion är ett fel misslyckas principutvärderingen. En misslyckad utvärdering är en implicit nekande. Ett exempel på ett värde som misslyckas i vissa scenarier:

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

Exempelprincipregeln ovan använder substring() för att jämföra de tre första tecknen med abc. Om namnet är kortare än tre tecken substring() resulterar funktionen i ett fel. Det här felet gör att principen blir en neka-effekt .

Använd i stället funktionen if() för att kontrollera om de tre första tecknen i namnet är lika med abc utan att tillåta att ett namn som är kortare än tre tecken orsakar ett fel:

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

Med den ändrade principregeln if() kontrollerar du namnlängden innan du försöker hämta ett substring() värde med färre än tre tecken. Om namnet är för kort returneras värdet "startar inte med abc" i stället och jämförs med abc. En resurs med ett kort namn som inte börjar med abc misslyckas fortfarande med principregeln, men orsakar inte längre ett fel under utvärderingen.

Antal

Villkor som räknar hur många medlemmar i en matris som uppfyller vissa villkor kan skapas med hjälp av ett antalsuttryck . Vanliga scenarier kontrollerar om "minst en av", "exakt en av", "alla av" eller "ingen av" matrismedlemmarna uppfyller ett villkor. Count utvärderar varje matrismedlem för ett villkorsuttryck och summerar de sanna resultaten, som sedan jämförs med uttrycksoperatorn.

Antal fält

Räkna hur många medlemmar i en matris i nyttolasten för begäran som uppfyller ett villkorsuttryck. Strukturen för fältantalsuttryck är:

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

Följande egenskaper används med antal fält:

  • count.field (obligatoriskt): Innehåller sökvägen till matrisen och måste vara ett matrisalias.
  • count.where (valfritt): Villkorsuttrycket som ska utvärderas individuellt för varje [*] aliasmatrismedlem i count.field. Om den här egenskapen inte anges utvärderas alla matrismedlemmar med sökvägen "fält" till true. Alla villkor kan användas i den här egenskapen. Logiska operatorer kan användas i den här egenskapen för att skapa komplexa utvärderingskrav.
  • <condition> (required): Värdet jämförs med antalet objekt som uppfyllde villkorsuttrycket count.where . Ett numeriskt villkor ska användas.

Mer information om hur du arbetar med matrisegenskaper i Azure Policy, inklusive detaljerad förklaring av hur uttrycket för antal fält utvärderas, finns i Referera till matrisresursegenskaper.

Antal värden

Räkna hur många medlemmar i en matris som uppfyller ett villkor. Matrisen kan vara en literalmatris eller en referens till matrisparametern. Strukturen för värdeantalsuttryck är:

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

Följande egenskaper används med antal värden:

  • count.value (obligatoriskt): Matrisen som ska utvärderas.
  • count.name (obligatoriskt): Indexnamnet, som består av engelska bokstäver och siffror. Definierar ett namn för värdet för matrismedlemmen som utvärderas i den aktuella iterationen. Namnet används för att referera till det aktuella värdet i villkoret count.where . Valfritt när count-uttrycket inte finns i ett underordnat till ett annat antalsuttryck . När det inte anges anges indexnamnet implicit till "default".
  • count.where (valfritt): Villkorsuttrycket som ska utvärderas individuellt för varje matrismedlem i count.value. Om den här egenskapen inte anges utvärderas alla matrismedlemmar till true. Alla villkor kan användas i den här egenskapen. Logiska operatorer kan användas i den här egenskapen för att skapa komplexa utvärderingskrav. Värdet för den uppräknade matrismedlemmen kan nås genom att anropa den aktuella funktionen.
  • <condition> (required): Värdet jämförs med antalet objekt som uppfyllde villkorsuttrycket count.where . Ett numeriskt villkor ska användas.

Den aktuella funktionen

Funktionen current() är endast tillgänglig i villkoret count.where . Den returnerar värdet för den matrismedlem som för närvarande räknas upp av utvärderingen av count-uttrycket .

Användning av värdeantal

  • current(<index name defined in count.name>). Exempel: current('arrayMember').
  • current(). Tillåts endast när uttrycket för antal värden inte är underordnat ett annat antalsuttryck . Returnerar samma värde som ovan.

Om värdet som returneras av anropet är ett -objekt stöds egenskapsåtkomst. Exempel: current('objectArrayMember').property.

Användning av antal fält

  • current(<the array alias defined in count.field>). Till exempel current('Microsoft.Test/resource/enumeratedArray[*]').
  • current(). Tillåts endast när fältantalsuttrycket inte är underordnat ett annat antalsuttryck . Returnerar samma värde som ovan.
  • current(<alias of a property of the array member>). Till exempel current('Microsoft.Test/resource/enumeratedArray[*].property').

Exempel på antal fält

Exempel 1: Kontrollera om en matris är tom

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

Exempel 2: Sök efter endast en matrismedlem som uppfyller villkorsuttrycket

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

Exempel 3: Sök efter minst en matrismedlem för att uppfylla villkorsuttrycket

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

Exempel 4: Kontrollera att alla objektmatrismedlemmar uppfyller villkorsuttrycket

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

Exempel 5: Kontrollera att minst en matrismedlem matchar flera egenskaper i villkorsuttrycket

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

Exempel 6: Använd current() funktionen inuti where villkoren för att få åtkomst till värdet för den uppräknade matrismedlemmen i en mallfunktion. Det här villkoret kontrollerar om ett virtuellt nätverk innehåller ett adressprefix som inte ligger under CIDR-intervallet 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
}

Exempel 7: Använd field() funktionen inuti where villkoren för att få åtkomst till värdet för den uppräknade matrismedlemmen. Det här villkoret kontrollerar om ett virtuellt nätverk innehåller ett adressprefix som inte ligger under CIDR-intervallet 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
}

Exempel på antal värden

Exempel 1: Kontrollera om resursnamnet matchar något av de angivna namnmönstren.

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

Exempel 2: Kontrollera om resursnamnet matchar något av de angivna namnmönstren. Funktionen current() anger inget indexnamn. Resultatet är detsamma som i föregående exempel.

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

Exempel 3: Kontrollera om resursnamnet matchar något av de angivna namnmönstren som tillhandahålls av en matrisparameter.

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

Exempel 4: Kontrollera om något av adressprefixen för det virtuella nätverket inte finns med i listan över godkända prefix.

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

Exempel 5: Kontrollera att alla reserverade NSG-regler har definierats i en NSG. Egenskaperna för de reserverade NSG-reglerna definieras i en matrisparameter som innehåller objekt.

Parametervärde:

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

Politik:

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

Effekt

Azure Policy stöder följande typer av effekter:

  • Tillägg: lägger till den definierade uppsättningen fält i begäran
  • Granskning: genererar en varningshändelse i aktivitetsloggen men misslyckas inte med begäran
  • AuditIfNotExists: genererar en varningshändelse i aktivitetsloggen om en relaterad resurs inte finns
  • Neka: genererar en händelse i aktivitetsloggen och misslyckas med begäran
  • DeployIfNotExists: distribuerar en relaterad resurs om den inte redan finns
  • Inaktiverad: utvärderar inte resurser för efterlevnad av principregeln
  • Ändra: lägger till, uppdaterar eller tar bort den definierade uppsättningen fält i begäran
  • EnforceOPAConstraint (inaktuell): konfigurerar open policy agent-antagningskontrollanten med Gatekeeper v3 för självhanterade Kubernetes-kluster i Azure
  • EnforceRegoPolicy (inaktuell): konfigurerar open policy agent-antagningskontrollanten med Gatekeeper v2 i Azure Kubernetes Service

Fullständig information om varje effekt, utvärderingsordning, egenskaper och exempel finns i Förstå Azure Policy effekter.

Principfunktioner

Funktioner kan användas för att introducera ytterligare logik i en principregel. De löses inom principregeln för en principdefinition och inom parametervärden som tilldelats till principdefinitioner i ett initiativ.

Alla Resource Manager mallfunktioner är tillgängliga att använda i en principregel, förutom följande funktioner och användardefinierade funktioner:

  • copyIndex()
  • dateTimeAdd()
  • deployment()
  • environment()
  • extensionResourceId()
  • listAccountSas()
  • listKeys()
  • listSecrets()
  • Lista*
  • managementGroup()
  • newGuid()
  • pickZones()
  • providers()
  • reference()
  • resourceId()
  • subscriptionResourceId()
  • tenantResourceId()
  • tenant()
  • utcNow(format)
  • variables()

Anteckning

Dessa funktioner är fortfarande tillgängliga i delen details.deployment.properties.template av malldistributionen i en deployIfNotExists-principdefinition .

Följande funktion är tillgänglig att använda i en principregel, men skiljer sig från användningen i en Azure Resource Manager-mall (ARM-mall):

  • utcNow() – Till skillnad från en ARM-mall kan den här egenskapen användas utanför defaultValue.
    • Returnerar en sträng som är inställd på aktuellt datum och tid i Formatet Universal ISO 8601 DateTime yyyy-MM-ddTHH:mm:ss.fffffffZ.

Följande funktioner är endast tillgängliga i principregler:

  • addDays(dateTime, numberOfDaysToAdd)

    • dateTime: [Obligatorisk] sträng – Sträng i DateTime-formatet Universal ISO 8601 'yyyy-MM-ddTHH:mm:ss. FFFFFFFZ"
    • numberOfDaysToAdd: [Obligatoriskt] heltal – Antal dagar att lägga till
  • field(fieldName)

    • fieldName: [Obligatorisk] sträng – Namnet på det fält som ska hämtas
    • Returnerar värdet för fältet från resursen som utvärderas av villkoret If.
    • field används främst med AuditIfNotExists och DeployIfNotExists för att referera till fält på resursen som utvärderas. Ett exempel på den här användningen visas i exemplet DeployIfNotExists.
  • requestContext().apiVersion

    • Returnerar API-versionen av begäran som utlöste principutvärdering (exempel: 2021-09-01). Det här värdet är den API-version som användes i PUT/PATCH-begäran för utvärderingar om skapande/uppdatering av resurser. Den senaste API-versionen används alltid under kompatibilitetsutvärderingen av befintliga resurser.
  • policy()

    • Returnerar följande information om principen som utvärderas. Egenskaper kan nås från det returnerade objektet (exempel: [policy().assignmentId]).

      {
        "assignmentId": "/subscriptions/ad404ddd-36a5-4ea8-b3e3-681e77487a63/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)

    • intervall: [Obligatorisk] sträng – Sträng som anger ett intervall med IP-adresser för att kontrollera om targetRange är inom.
    • targetRange: [Obligatorisk] sträng – Sträng som anger ett intervall med IP-adresser som ska verifieras enligt intervallet.
    • Returnerar ett booleskt värde för om intervallets IP-adressintervall innehåller ip-adressintervallet targetRange . Tomma intervall eller blandning mellan IP-familjer tillåts inte och resulterar i utvärderingsfel.

    Format som stöds:

    • Enskild IP-adress (exempel: 10.0.0.0, 2001:0DB8::3:FFFE)
    • CIDR-intervall (exempel: 10.0.0.0/24, 2001:0DB8::/110)
    • Intervall som definieras av start- och slut-IP-adresser (exempel: 192.168.0.1-192.168.0.9, 2001:0DB8::-2001:0DB8::3:FFFF)
  • current(indexName)

Exempel på principfunktion

Det här principregelexemplet använder resourceGroup resursfunktionen för att hämta namnegenskapen, kombinerat med matrisen concat och objektfunktionen för att skapa ett like villkor som framtvingar resursnamnet för att börja med resursgruppens namn.

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

Principregelbegränsningar

Begränsningar som framtvingas under redigering

Begränsningar för strukturen för principregler framtvingas under redigering eller tilldelning av en princip. Försök att skapa eller tilldela principdefinitioner som överskrider dessa gränser misslyckas.

Gräns Värde Ytterligare information
Villkorsuttryck i if-villkoret 4096
Villkorsuttryck i then-blocket 128 Gäller för existenceCondition för AuditIfNotExists- och DeployIfNotExists-principer
Principfunktioner per principregel 2048
Antal parametrar för principfunktion 128 Exempel: [function('parameter1', 'parameter2', ...)]
Djup på kapslade principfunktioner 64 Exempel: [function(nested1(nested2(...)))]
Stränglängd för principfunktionsuttryck 81920 Exempel: längden på "[function(....)]"
Fältantalsuttryck per matris 5
Värderäkningsuttryck per principregel 10
Iterationsantal för värderäkningsuttryck 100 För kapslade värderäkningsuttryck omfattar detta även iterationsantalet för det överordnade uttrycket

Begränsningar som framtvingas under utvärderingen

Gränser för storleken på objekt som bearbetas av principfunktioner under principutvärderingen. Dessa gränser kan inte alltid tillämpas under redigeringen eftersom de är beroende av det utvärderade innehållet. Ett exempel:

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

Längden på strängen concat() som skapas av funktionen beror på värdet för egenskaperna i den utvärderade resursen.

Gräns Värde Exempel
Längden på den sträng som returneras av en funktion 131072 [concat(field('longString1'), field('longString2'))]
Djup för komplexa objekt som tillhandahålls som en parameter till eller returneras av en funktion 128 [union(field('largeObject1'), field('largeObject2'))]
Antal noder för komplexa objekt som tillhandahålls som en parameter till eller returneras av en funktion 32768 [concat(field('largeArray1'), field('largeArray2'))]

Varning

En princip som överskrider ovanstående gränser under utvärderingen blir i praktiken en neka-princip och kan blockera inkommande begäranden. När du skriver principer med komplexa funktioner bör du vara uppmärksam på dessa gränser och testa dina principer mot resurser som kan överskrida dem.

Alias

Du använder egenskapsalias för att komma åt specifika egenskaper för en resurstyp. Med alias kan du begränsa vilka värden eller villkor som tillåts för en egenskap i en resurs. Varje alias mappas till vägar i olika API-versioner för en viss resurstyp. Under principutvärdering hämtar principmotorn egenskapssökvägen för den API-versionen.

Listan över alias växer alltid. Om du vill ta reda på vilka alias som för närvarande stöds av Azure Policy använder du någon av följande metoder:

  • Azure Policy tillägg för Visual Studio Code (rekommenderas)

    Använd Azure Policy-tillägget för Visual Studio Code för att visa och identifiera alias för resursegenskaper.

    Skärmbild av Azure Policy-tillägget för Visual Studio Code som hovrar en egenskap för att visa aliasnamnen.

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

    Anteckning

    Om du vill hitta alias som kan användas med ändringseffekten använder du följande kommando i Azure PowerShell 4.6.0 eller senare:

    Get-AzPolicyAlias | Select-Object -ExpandProperty 'Aliases' | Where-Object { $_.DefaultMetadata.Attributes -eq 'Modifiable' }
    
  • Azure 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"
    
  • REST API/ARMClient

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

Förstå aliaset [*]

Flera av de tillgängliga aliasen har en version som visas som ett "normalt" namn och ett annat som har [*] kopplat till sig. Ett exempel:

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

Det "normala" aliaset representerar fältet som ett enda värde. Det här fältet är för exakta matchningsjämförelsescenarier när hela uppsättningen värden måste vara exakt som definierat, varken mer eller mindre.

Aliaset [*] representerar en samling värden som valts från elementen i en matrisresursegenskap. Ett exempel:

Alias Valda värden
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*] Elementen i matrisen ipRules .
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].action Värdena för action egenskapen från varje element i matrisen ipRules .

När de används i ett fältvillkor gör matrisalias det möjligt att jämföra varje enskilt matriselement med ett målvärde. När det används med count-uttryck är det möjligt att:

  • Kontrollera storleken på en matris
  • Kontrollera om alla\några\nett av matriselementen uppfyller ett komplext villkor
  • Kontrollera om exakt n matriselement uppfyller ett komplext villkor

Mer information och exempel finns i Referera till matrisresursegenskaper.

Nästa steg