Condividi tramite

Regola dei criteri della struttura delle definizioni di Criteri di Azure

  • Articolo

La regola dei criteri è costituita da blocchi if e then. Nel blocco if, si definisce una o più condizioni che specificano quando i criteri vengono applicati. È 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 Effetti sulle definizioni di Criteri di Azure.

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

{
  "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 sintassi not inverte il risultato della condizione. La sintassi allOf (simile all'operazione logica and) richiede che tutte le condizioni siano vere. La sintassi anyOf (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 nidificata nell'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, lessOrEquals, greater 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 condizioni like e notLike, specificare un carattere jolly (*) nel valore. Il valore non deve contenere più di un carattere jolly.

Quando si usano le condizioni di match 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 corrispondente a tale carattere effettivo. Mentre match e notMatch fanno distinzione tra maiuscole e 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 con anteposti gli eventuali nomi delle risorse 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

  • 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 il quale 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 il quale 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 espressioni field che fanno riferimento all'alias di matrice [*], ogni elemento della matrice viene valutato singolarmente con and logici tra gli elementi. Per altre informazioni, vedere Fare riferimento alle proprietà delle risorse della matrice.

Le condizioni che usano espressioni field possono sostituire la sintassi di definizione dei criteri legacy "source": "action", che viene 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 la logica field:

{
  "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 seguente, concat viene usato per creare una ricerca nei campi di tag per il tag che ha come nome il valore del parametro tagName. Se il tag non esiste, viene usato l'effetto modify per aggiungere il tag usando il valore del tag con lo stesso nome impostato sul gruppo di risorse padre delle risorse controllate tramite la funzione di ricerca resourcegroup().

{
  "if": {
    "field": "[concat('tags[', parameters('tagName'), ']')]",
    "exists": "false"
  },
  "then": {
    "effect": "modify",
    "details": {
      "operations": [
        {
          "operation": "add",
          "field": "[concat('tags[', parameters('tagName'), ']')]",
          "value": "[resourcegroup().tags[parameters('tagName')]]"
        }
      ],
      "roleDefinitionIds": [
        "/providers/microsoft.authorization/roleDefinitions/4a9ae827-6dc8-4573-8ac7-8239d42aa03f"
      ]
    }
  }
}

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 risultato deny implicito. Per altre informazioni, vedere come evitare errori dei modelli. Usare enforcementMode di doNotEnforce per evitare l'effetto di una valutazione non riuscita su risorse nuove o aggiornate durante il test e la convalida di una nuova definizione dei criteri.

Esempi d'uso di value

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

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

Questa regola dei criteri usa value per verificare se il risultato di più funzioni annidate equals true. 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 numerose funzioni annidate complesse. Se il risultato di una funzione modello è un errore, la valutazione dei criteri non riesce. Una valutazione non riuscita è un risultato deny implicito. Un esempio di value che 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 substring() per confrontare i primi tre caratteri di name con abc. Se name è più breve di tre caratteri, la funzione substring() genera un errore. Questo errore fa sì che il criterio diventi un effetto deny.

Usare invece la funzione if() per verificare se i primi tre caratteri di name sono uguali ad abc senza consentire che un name più breve di tre caratteri generi 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 name prima di provare a ottenere un substring() su un valore con meno di tre caratteri. Se name è troppo breve, viene invece restituito il valore "not starting with abc" e viene confrontato con abc. Una risorsa con un nome breve che non inizia con abc non soddisfa 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 controllano se "almeno uno", "esattamente uno", "tutti" o "nessuno" dei membri della matrice soddisfano una condizione. count valuta ogni membro della matrice per un'espressione della condizione e somma i risultati true, che vengono quindi confrontati con l'operatore dell'espressione.

Conteggio campi

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

{
  "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 dell’alias della matrice di count.field. Se questa proprietà non viene specificata, tutti i membri della matrice con il percorso "field" verranno valutati come 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 (facoltativo): Il valore viene confrontato con il numero di elementi che soddisfano l'espressione della condizione count.where. È 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'espressione field count, vedere Riferimento alle proprietà delle risorse della matrice.

Conteggio dei 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 espressioni value count è:

{
  "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 condizione count.where. Facoltativo quando l'espressione count non si trova in un elemento figlio di un'altra espressione count. 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 (facoltativo): Il valore viene confrontato con il numero di elementi che soddisfano l'espressione della condizione count.where. È necessario usare una condizione numerica.

Funzione corrente

La funzione current() è disponibile solo all'interno della condizione di count.where. 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 espressione count. 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 espressione count. 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 che un solo membro della matrice soddisfi 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 che almeno un membro della matrice soddisfi 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 della matrice corrisponda a più proprietà nell'espressione della 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 la funzione current() all'interno delle condizioni di where 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 la funzione field() all'interno delle condizioni where 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 funzione current() 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 porzione details.deployment.properties.template della distribuzione del modello in una definizione dei criteri deployIfNotExists.

La funzione seguente è disponibile per l'uso in una regola dei criteri, ma è diversa da quella usata 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 corrente nel formato DateTime ISO 8601 universale yyyy-MM-ddTHH:mm:ss.fffffffZ.

Le funzioni seguenti sono disponibili solo nelle regole dei criteri:

  • addDays(dateTime, numberOfDaysToAdd)

    • dateTime: [Obbligatorio] stringa - Stringa nel formato DateTime ISO 8601 universale 'yyyy-MM-ddTHH: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 della creazione o dell'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)

Esempio di funzione dei criteri

Questo esempio di regola dei criteri usa la resourceGroup funzione risorsa per ottenere la proprietà name, in combinazione con la matrice concat e la funzione oggetto per creare una condizione like che fa in modo che il nome della risorsa inizi 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 della condizione nella condizione if 4096
Espressioni della condizione nel blocco then 128 Si applica a existenceCondition dei criteri auditIfNotExists e deployIfNotExists
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 Value count annidate, 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 funzione concat() 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

Un criterio che supera i limiti precedenti durante la valutazione diventa di fatto un criterio deny e può 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