regola dei criteri della struttura di definizione Criteri di Azure

La regola dei if criteri è costituita da blocchi e then . if Nel blocco si definiscono una o più condizioni che specificano quando vengono applicati i criteri. È possibile applicare gli operatori logici a queste condizioni per definire con precisione lo scenario di un criterio.

Per informazioni dettagliate su ogni effetto, ordine di valutazione, proprietà ed esempi, vedere nozioni di base sugli effetti delle definizioni Criteri di Azure.

then Nel blocco si definisce l'effetto che si verifica quando vengono soddisfatte le if condizioni.

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

Per altre informazioni su policyRule, passare allo schema di definizione dei criteri.

Operatori logici

Gli operatori logici supportati sono:

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

La not sintassi inverte il risultato della condizione. La allOf sintassi (simile all'operazione logica and ) richiede che tutte le condizioni siano vere. La anyOf sintassi (simile all'operazione logica or ) richiede che una o più condizioni siano vere.

È possibile annidare gli operatori logici. Nell'esempio seguente viene illustrata un'operazione not annidata all'interno di un'operazione allOf .

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

Condizioni

Una condizione valuta se un valore soddisfa determinati criteri. Le condizioni supportate sono:

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

Per less, lessOrEqualsgreater, e greaterOrEquals, se il tipo di proprietà non corrisponde al tipo di condizione, viene generato un errore. I confronti tra stringhe vengono eseguiti usando InvariantCultureIgnoreCase.

Quando si usano le like condizioni e notLike , specificare un carattere jolly (*) nel valore . Il valore non deve avere più di un carattere jolly.

Quando si usano le match condizioni e notMatch , specificare un hashtag (#) per trovare una corrispondenza con una cifra, un punto interrogativo (?) per una lettera e un punto (.) in modo che corrisponda a qualsiasi carattere e qualsiasi altro carattere in base al carattere effettivo. Mentre match e fanno distinzione tra maiuscole e notMatch minuscole, tutte le altre condizioni che valutano un oggetto stringValue non fanno distinzione tra maiuscole e minuscole. Le alternative senza distinzione tra maiuscole e minuscole sono disponibili in matchInsensitively e notMatchInsensitively.

Campi

Condizioni che valutano se i valori delle proprietà nel payload della richiesta di risorse soddisfano determinati criteri possono essere formati usando un'espressione field . Sono supportati i seguenti campi:

• name

• fullName

  • Restituisce il nome completo della risorsa. Il nome completo di una risorsa è il nome della risorsa anteporto a qualsiasi nome di risorsa padre ( ad esempio myServer/myDatabase).

• kind

• type

• location

  • I campi percorso vengono normalizzati per supportare vari formati. Ad esempio, East US 2 è considerato uguale a eastus2.
  • Usare global per le risorse che sono indipendenti dalla posizione.

• id

  • Restituisce l'ID risorsa della risorsa da valutare.
  • Esempio: /subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myRG/providers/Microsoft.KeyVault/vaults/myVault

• identity.type

  • Restituisce il tipo di identità gestita abilitata per la risorsa.

• tags

• tags['<tagName>']

  • Questa sintassi tra parentesi quadre supporta nomi di tag con segni di punteggiatura, ad esempio un trattino, punti o spazi.
  • Dove tagName è il nome del tag per cui convalidare la condizione.
  • Esempi: tags['Acct.CostCenter'] dove Acct.CostCenter è il nome del tag.

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

  • Questa sintassi tra parentesi quadre supporta nomi di tag contenenti apostrofi eseguendo l'escape con esso in caratteri di escape con apostrofi doppi.
  • Dove tagName è il nome del tag per cui convalidare la condizione.
  • Esempio: tags['''My.Apostrophe.Tag'''] dove 'My.Apostrophe.Tag' è il nome del tag.

  Nota

  tags.<tagName>, tags[tagName] e tags[tag.with.dots] sono comunque modi accettabili per dichiarare un campo tags. Tuttavia, le espressioni preferibili sono quelle elencate in precedenza.

• alias delle proprietà; per un elenco, vedere alias.

  Nota

  Nelle field espressioni che fanno riferimento all'alias [*] di matrice ogni elemento della matrice viene valutato singolarmente con elementi logici and tra gli elementi. Per altre informazioni, vedere Riferimento alle proprietà delle risorse della matrice.

Le condizioni che usano field espressioni possono sostituire la sintassi "source": "action"di definizione dei criteri legacy , usata per lavorare per le operazioni di scrittura. Ad esempio, questo non è più supportato:

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

Tuttavia, è possibile ottenere il comportamento desiderato usando field la logica:

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

Usare tag con parametri

È possibile passare a un campo di tag un valore di parametro. Passare un parametro a un campo di tag aumenta la flessibilità della definizione dei criteri durante l'assegnazione dei criteri.

Nell'esempio concat seguente viene usato per creare una ricerca di campi tag per il tag denominato valore del tagName parametro . Se tale tag non esiste, l'effetto modify viene usato per aggiungere il tag usando il valore dello stesso tag denominato impostato nel gruppo di risorse padre delle risorse controllate usando la resourcegroup() funzione di ricerca.

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

Valore

Condizioni che valutano se un valore soddisfa determinati criteri possono essere formate usando un'espressione value . I valori possono essere valori letterali, i valori dei parametri o i valori restituiti di qualsiasi funzione di modello supportata.

Avviso

Se il risultato di una funzione modello è un errore, la valutazione dei criteri non riesce. Una valutazione non riuscita è un oggetto implicito deny. Per altre informazioni, vedere come evitare errori dei modelli. Usare enforcementMode di doNotEnforce per evitare l'impatto di una valutazione non riuscita su risorse nuove o aggiornate durante il test e la convalida di una nuova definizione di criteri.

Esempi d'uso di value

Questo esempio di regola dei criteri usa value per confrontare il risultato della resourceGroup() funzione e la proprietà restituita name con una like condizione di *netrg. La regola nega qualsiasi risorsa non di in alcun gruppo di Microsoft.Network/*type risorse il cui nome termina in *netrg.

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

Questo esempio di regola dei criteri usa value per verificare se il risultato di più funzioni equalstruenidificate . La regola respinge qualsiasi risorsa che non dispone di almeno tre tag.

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

Evitare gli errori dei modelli

L'uso di funzioni modello in value consente molte funzioni annidate complesse. Se il risultato di una funzione modello è un errore, la valutazione dei criteri non riesce. Una valutazione non riuscita è un oggetto implicito deny. Esempio di che value ha esito negativo in determinati scenari:

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

La regola dei criteri di esempio precedente usa la sottostringa() per confrontare i primi tre caratteri di name con abc. Se name è più breve di tre caratteri, la substring() funzione genera un errore. Questo errore fa sì che il criterio diventi un deny effetto.

Usare invece la funzione if() per verificare se i primi tre caratteri uguali nameabc senza consentire a un name carattere più breve di tre caratteri di generare un errore:

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

Con la regola dei criteri modificata, if() controlla la lunghezza di prima di name tentare di ottenere un substring() valore con meno di tre caratteri. Se name è troppo breve, viene restituito il valore "not starting with abc" e confrontato con abc. Una risorsa con un nome breve che non inizia con abc non riesce ancora la regola dei criteri, ma non causa più un errore durante la valutazione.

Conteggio

Condizioni che contano il numero di membri di una matrice che soddisfano determinati criteri possono essere formate usando un'espressione count . Gli scenari comuni verificano se "almeno uno di", "esattamente uno di", "tutto" o "nessuno dei membri della matrice" soddisfa una condizione. count Valuta ogni membro della matrice per un'espressione condizione e somma i risultati reali, che vengono quindi confrontati con l'operatore di espressione.

Conteggio campi

Contare il numero di membri di una matrice nel payload della richiesta che soddisfano un'espressione di condizione. La struttura delle field count espressioni è:

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

Le proprietà seguenti vengono usate con field count:

• count.field (obbligatorio): contiene il percorso della matrice e deve essere un alias di matrice.
• count.where (facoltativo): espressione di condizione da valutare singolarmente per ogni membro della matrice alias della matrice di count.field. Se questa proprietà non viene specificata, tutti i membri della matrice con il percorso di 'field' vengono valutati su true. All'interno di questa proprietà è possibile usare qualunque condizione. Gli operatori logici possono essere usati all'interno di questa proprietà per creare requisiti di valutazione complessi.
• condition (obbligatorio): il valore viene confrontato con il numero di elementi che soddisfano l'espressione della count.where condizione. È necessario usare una condizione numerica.

Per altre informazioni su come usare le proprietà della matrice in Criteri di Azure, inclusa una spiegazione dettagliata su come viene valutata l'espressionefield count, vedere Riferimento alle proprietà delle risorse della matrice.

Conteggio valori

Contare il numero di membri di una matrice che soddisfano una condizione. La matrice può essere una matrice letterale o un riferimento al parametro di matrice. La struttura delle value count espressioni è:

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

Le proprietà seguenti vengono usate con value count:

• count.value (obbligatorio): matrice da valutare.
• count.name (obbligatorio): nome dell'indice, composto da lettere e cifre in inglese. Definisce un nome per il valore del membro della matrice valutato nell'iterazione corrente. Il nome viene usato per fare riferimento al valore corrente all'interno della count.where condizione. Facoltativo quando l'espressione count non si trova in un elemento figlio di un'altra count espressione. Se non specificato, il nome dell'indice viene impostato in modo implicito su "default".
• count.where (facoltativo): espressione della condizione da valutare singolarmente per ogni membro della matrice di count.value. Se questa proprietà non viene specificata, tutti i membri della matrice vengono valutati su true. All'interno di questa proprietà è possibile usare qualunque condizione. Gli operatori logici possono essere usati all'interno di questa proprietà per creare requisiti di valutazione complessi. È possibile accedere al valore del membro della matrice attualmente enumerato chiamando la funzione corrente .
• condition (obbligatorio): il valore viene confrontato con il numero di elementi che soddisfano l'espressione della count.where condizione. È necessario usare una condizione numerica.

Funzione corrente

La current() funzione è disponibile solo all'interno della count.where condizione. Restituisce il valore del membro della matrice attualmente enumerato dalla valutazione dell'espressione count .

Utilizzo del conteggio dei valori

• current(<index name defined in count.name>). Ad esempio: current('arrayMember').
• current(). Consentito solo quando l'espressione value count non è figlio di un'altra count espressione. Restituisce lo stesso valore riportato in precedenza.

Se il valore restituito dalla chiamata è un oggetto, sono supportate le funzioni di accesso alle proprietà. Ad esempio: current('objectArrayMember').property.

Utilizzo del conteggio dei campi

• current(<the array alias defined in count.field>). Ad esempio: current('Microsoft.Test/resource/enumeratedArray[*]').
• current(). Consentito solo quando l'espressione field count non è figlio di un'altra count espressione. Restituisce lo stesso valore riportato in precedenza.
• current(<alias of a property of the array member>). Ad esempio: current('Microsoft.Test/resource/enumeratedArray[*].property').

Esempi di conteggio dei campi

Esempio 1: Verificare se una matrice è vuota

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

Esempio 2: Verificare la presenza di un solo membro della matrice per soddisfare l'espressione della condizione

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

Esempio 3: Verificare la presenza di almeno un membro della matrice per soddisfare l'espressione della condizione

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

Esempio 4: Verificare che tutti i membri della matrice di oggetti soddisfino l'espressione della condizione

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

Esempio 5: Verificare che almeno un membro di matrice corrisponda a più proprietà nell'espressione condizione

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

Esempio 6: usare current() la funzione all'interno delle where condizioni per accedere al valore del membro della matrice attualmente enumerato in una funzione modello. Questa condizione controlla se una rete virtuale contiene un prefisso di indirizzo non compreso nell'intervallo CIDR 10.0.0.0/24.

{
  "count": {
    "field": "Microsoft.Network/virtualNetworks/addressSpace.addressPrefixes[*]",
    "where": {
      "value": "[ipRangeContains('10.0.0.0/24', current('Microsoft.Network/virtualNetworks/addressSpace.addressPrefixes[*]'))]",
      "equals": false
    }
  },
  "greater": 0
}

Esempio 7: Usare field() la funzione all'interno delle where condizioni per accedere al valore del membro della matrice attualmente enumerato. Questa condizione controlla se una rete virtuale contiene un prefisso di indirizzo non compreso nell'intervallo CIDR 10.0.0.0/24.

{
  "count": {
    "field": "Microsoft.Network/virtualNetworks/addressSpace.addressPrefixes[*]",
    "where": {
      "value": "[ipRangeContains('10.0.0.0/24', first(field(('Microsoft.Network/virtualNetworks/addressSpace.addressPrefixes[*]')))]",
      "equals": false
    }
  },
  "greater": 0
}

Esempi di conteggio dei valori

Esempio 1: controllare se il nome della risorsa corrisponde a uno dei modelli di nome specificati.

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

Esempio 2: Controllare se il nome della risorsa corrisponde a uno dei modelli di nome specificati. La current() funzione non specifica un nome di indice. Il risultato è lo stesso dell'esempio precedente.

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

Esempio 3: controllare se il nome della risorsa corrisponde a uno dei modelli di nome specificati forniti da un parametro di matrice.

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

Esempio 4: verificare se uno dei prefissi degli indirizzi di rete virtuale non è presente nell'elenco dei prefissi approvati.

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

Esempio 5: verificare che tutte le regole del gruppo di sicurezza di rete riservate siano definite in un gruppo di sicurezza di rete. Le proprietà delle regole del gruppo di sicurezza di rete riservate vengono definite in un parametro di matrice contenente oggetti .

Valore parametro:

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

Criteri:

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

Funzioni dei criteri

Le funzioni possono essere usate per introdurre logica aggiuntiva in una regola dei criteri. Vengono risolti all'interno della regola dei criteri di una definizione di criteri e all'interno dei valori dei parametri assegnati alle definizioni dei criteri in un'iniziativa.

Tutte le funzioni del modello di Resource Manager sono disponibili per l'uso all'interno di una regola dei criteri, ad eccezione delle seguenti funzioni e funzioni definite dall'utente:

• copyIndex()
• dateTimeAdd()
• dateTimeFromEpoch
• dateTimeToEpoch
• deployment()
• environment()
• extensionResourceId()
• lambda() Per altre informazioni, vedere lambda
• listAccountSas()
• listKeys()
• listSecrets()
• list*
• managementGroup()
• newGuid()
• pickZones()
• providers()
• reference()
• resourceId()
• subscriptionResourceId()
• tenantResourceId()
• tenant()
• variables()

Nota

Queste funzioni sono ancora disponibili all'interno della details.deployment.properties.template parte della distribuzione del modello in una deployIfNotExists definizione di criteri.

La funzione seguente è disponibile per l'uso in una regola dei criteri, ma differisce dall'uso in un modello di Azure Resource Manager (modello arm):

• utcNow() - A differenza di un modello di Resource Manager, questa proprietà può essere usata all'esterno di defaultValue.
  • Restituisce una stringa impostata sulla data e l'ora correnti nel formato yyyy-MM-ddTHH:mm:ss.fffffffZDateTime ISO universale 8601 .

Le funzioni seguenti sono disponibili solo nelle regole dei criteri:

• addDays(dateTime, numberOfDaysToAdd)

  • dateTime: [Obbligatorio] stringa - Stringa nel formato DateTime ISO universale 8601 'aaaa-MM-ggTHH:mm:ss. FFFFFFFZ'
  • numberOfDaysToAdd: [Obbligatorio] Integer - Numero di giorni da aggiungere

• field(fieldName)

  • fieldName: [Obbligatorio] stringa - Nome del campo da recuperare
  • Restituisce il valore di tale campo dalla risorsa valutata dalla condizione If.
  • field viene usato principalmente con auditIfNotExists e deployIfNotExists per fare riferimento ai campi della risorsa da valutare. Altre informazioni sono disponibili nell'esempio DeployIfNotExists.

• requestContext().apiVersion

  • Restituisce la versione dell'API della richiesta che ha attivato la valutazione del criterio, ad esempio: 2021-09-01. Questo valore è la versione dell'API usata nella richiesta PUT/PATCH per le valutazioni sulla creazione/aggiornamento delle risorse. La versione più recente dell'API viene sempre usata durante la valutazione della conformità sulle risorse esistenti.

• policy()

  • Restituisce le informazioni seguenti sui criteri da valutare. È possibile accedere alle proprietà dall'oggetto restituito (ad esempio: [policy().assignmentId]).

    {
      "assignmentId": "/subscriptions/11111111-1111-1111-1111-111111111111/providers/Microsoft.Authorization/policyAssignments/myAssignment",
      "definitionId": "/providers/Microsoft.Authorization/policyDefinitions/34c877ad-507e-4c82-993e-3452a6e0ad3c",
      "setDefinitionId": "/providers/Microsoft.Authorization/policySetDefinitions/42a694ed-f65e-42b2-aa9e-8052e9740a92",
      "definitionReferenceId": "StorageAccountNetworkACLs"
    }
    

• ipRangeContains(range, targetRange)

  • range: [Obbligatorio] stringa - Stringa che specifica un intervallo di indirizzi IP per verificare se targetRange si trova all'interno.
  • targetRange: [Obbligatorio] stringa - Stringa che specifica un intervallo di indirizzi IP da convalidare come incluso nell'intervallo.
  • Restituisce un valore booleano che indica se l'intervallo di indirizzi IP di intervallo contiene l'intervallo di indirizzi IP targetRange. Gli intervalli vuoti o la combinazione tra le famiglie IP non è consentita e genera un errore di valutazione.

  Formati supportati:

  • Singolo indirizzo IP (esempi: 10.0.0.0, 2001:0DB8::3:FFFE)
  • Intervallo CIDR (esempi: 10.0.0.0/24, 2001:0DB8::/110)
  • Intervallo definito dagli indirizzi IP iniziali e finali (esempi: 192.168.0.1-192.168.0.9, 2001:0DB8::-2001:0DB8::3:FFFF)

• current(indexName)

  • Funzione speciale che può essere usata solo all'interno di espressioni count.

Esempio di funzione dei criteri

Questo esempio di regola di criteri usa la resourceGroup funzione di risorsa per ottenere la proprietà, combinata con la name matrice e la concat funzione oggetto per compilare una like condizione che impone il nome della risorsa per iniziare con il nome del gruppo di risorse.

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

Limiti delle regole dei criteri

Limiti applicati durante la creazione

Durante la creazione o l'assegnazione di un criterio vengono applicati limiti alla struttura delle regole dei criteri. I tentativi di creare o assegnare definizioni di criteri che superano questi limiti avranno esito negativo.

Limite	valore	Dettagli aggiuntivi
Espressioni di condizione nella if condizione	4096
Espressioni di condizione nel then blocco	128	Si applica all'oggetto existenceCondition di auditIfNotExists e deployIfNotExists ai criteri
Funzioni dei criteri per ogni regola dei criteri	2048
Numero dei parametri della funzione dei criteri	128	Esempio: [function('parameter1', 'parameter2', ...)]
Profondità delle funzioni dei criteri annidate	64	Esempio: [function(nested1(nested2(...)))]
Lunghezza della stringa dell'espressione delle funzioni dei criteri	81920	Esempio: lunghezza di "[function(....)]"
Field count espressioni per matrice	5
Value count espressioni per regola dei criteri	10
Value count conteggio iterazioni di espressione	100	Per le espressioni annidate Value count , questo include anche il numero di iterazioni dell'espressione padre

Limiti applicati durante la valutazione

Limiti alle dimensioni degli oggetti elaborati dalle funzioni dei criteri durante la valutazione dei criteri. Questi limiti non possono essere sempre applicati durante la creazione perché dipendono dal contenuto valutato. Ad esempio:

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

La lunghezza della stringa creata dalla concat() funzione dipende dal valore delle proprietà nella risorsa valutata.

Limite	Valore	Esempio
Lunghezza della stringa restituita da una funzione	131072	[concat(field('longString1'), field('longString2'))]
Profondità degli oggetti complessi fornita come parametro a una funzione o restituita da essa	128	[union(field('largeObject1'), field('largeObject2'))]
Numero di nodi degli oggetti complessi fornito come parametro a una funzione o restituito da essa	32768	[concat(field('largeArray1'), field('largeArray2'))]

Avviso

I criteri che superano i limiti precedenti durante la valutazione diventeranno effettivamente un deny criterio e possono bloccare le richieste in ingresso. Quando si scrivono criteri con funzioni complesse, tenere presente questi limiti e testare i criteri sulle risorse che potrebbero superarli.

Passaggi successivi

• Per altre informazioni sulla struttura di definizione dei criteri, vedere Nozioni di base, parametri e alias.
• Per le iniziative, passare alla struttura di definizione dell'iniziativa.
• Vedere gli esempi in Esempi di Criteri di Azure.
• Leggere Informazioni sugli effetti di Criteri.
• Vedere come creare criteri a livello di codice.
• Leggere le informazioni su come ottenere dati sulla conformità.
• Informazioni su come correggere le risorse non conformi.
• Rivedere le caratteristiche di un gruppo di gestione illustrate in Organizzare le risorse con i gruppi di gestione di Azure.