Condividi tramite

Creare i criteri per le proprietà della matrice nelle risorse di Azure

  • Articolo

Le proprietà di Azure Resource Manager sono comunemente definite come stringhe e valori booleani. Quando esiste una relazione uno-a-molti, le proprietà complesse sono invece definite come matrici. In Criteri di Azure le matrici vengono usate in modi diversi:

  • Tipo di parametro di definizione, per fornire più opzioni.
  • Parte di una regola dei criteri che usa le condizioni in o notIn.
  • Parte di una regola dei criteri che conta il numero di membri della matrice che soddisfano una condizione.
  • Negli effetti di append e modify per aggiornare una matrice esistente

Questo articolo descrive tutti gli usi di Criteri di Azure e offre diverse definizioni di esempio.

Matrici di parametri

Definire una matrice di parametri

La definizione di un parametro come matrice consente l'uso di criteri flessibili quando è necessario più di un valore. Questa definizione di criteri consente qualsiasi posizione singola per il parametro allowedLocations e per impostazione predefinita eastus2:

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

Come type stringa, è possibile impostare un solo valore quando si assegnano i criteri. Se si assegnano questi criteri, le risorse nell'ambito sono consentite solo all'interno di un'unica area di Azure. La maggior parte delle definizioni dei criteri deve consentire un elenco di opzioni approvate, ad esempio eastus2, eastus e westus2.

Per creare la definizione dei criteri per consentire più opzioni, usare la matrice type. Gli stessi criteri possono essere riscritti nel modo seguente:

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

Nota

Dopo aver salvato una definizione di criteri, la type proprietà in un parametro non può essere modificata.

Questa nuova definizione dei parametri accetta più di un valore durante l'assegnazione dei criteri. Con la proprietà allowedValues della matrice definita, i valori disponibili durante l'assegnazione sono ulteriormente limitati all'elenco predefinito di scelte. L'uso di allowedValues è facoltativo.

Passare i valori a una matrice di parametri durante l'assegnazione

Quando si assegnano i criteri tramite il portale di Azure, un parametro di matrice viene visualizzato come una singola casella di type testo. L'hint indica Use ; to separate values. (e.g. London;New York). Per passare i valori delle località consentite di eastus2, eastus e westus2 al parametro, usare la stringa seguente:

eastus2;eastus;westus2

Il formato del valore del parametro è diverso quando si usa l'interfaccia della riga di comando di Azure, Azure PowerShell o l'API REST. I valori vengono passati tramite una stringa JSON che include anche il nome del parametro.

{
  "allowedLocations": {
    "value": [
      "eastus2",
      "eastus",
      "westus2"
    ]
  }
}

Per usare questa stringa con ogni SDK, usare i comandi seguenti:

  • Interfaccia della riga di comando di Azure: comando az policy assignment create con il parametro params.
  • Azure PowerShell: cmdlet New-AzPolicyAssignment con il parametro PolicyParameter.
  • API REST: nell'operazione di creazione PUT come parte del corpo della richiesta come valore della properties.parameters proprietà .

Uso di matrici nelle condizioni

In e notIn

Le condizioni di in e notIn funzionano solo con valori di matrice. Controllano l'esistenza di un valore in una matrice. La matrice può essere una matrice JSON letterale o un riferimento a un parametro di matrice. Ad esempio:

{
  "field": "tags.environment",
  "in": [
    "dev",
    "test"
  ]
}

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

Conteggio dei valori

L'espressione value count conta il numero di membri della matrice che soddisfano una condizione. Fornisce un modo per valutare la stessa condizione più volte, usando valori diversi a ogni iterazione. Ad esempio, la condizione seguente controlla se il nome della risorsa corrisponde a un criterio di una matrice di criteri:

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

Per valutare l'espressione, Criteri di Azure valuta la condizione where tre volte, una volta per ogni membro di [ "test*", "dev*", "prod*" ], contando quante volte restituisce true. A ogni iterazione il valore del membro della matrice corrente viene associato al nome dell'indice pattern definito da count.name. È quindi possibile fare riferimento a questo valore all'interno della condizione where chiamando una funzione modello speciale: current('pattern').

Iterazione Valore restituito da current('pattern')
1 "test*"
2 "dev*"
3 "prod*"

La condizione è true solo se il conteggio dei risultati è maggiore di 0.

Per rendere la condizione precedente più generica, usare un parameters riferimento anziché una matrice letterale:

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

Quando l'espressione value count non è in nessun'altra count espressione, count.name è facoltativa e la current() funzione può essere usata senza argomenti:

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

Supporta value count anche matrici di oggetti complessi, consentendo condizioni più complesse. Ad esempio, la condizione seguente definisce un valore di tag desiderato per ogni criterio name e controlla se il nome della risorsa corrisponde al criterio, ma non ha il valore di tag richiesto:

{
  "count": {
    "value": [
      {
        "pattern": "test*",
        "envTag": "dev"
      },
      {
        "pattern": "dev*",
        "envTag": "dev"
      },
      {
        "pattern": "prod*",
        "envTag": "prod"
      },
    ],
    "name": "namePatternRequiredTag",
    "where": {
      "allOf": [
        {
          "field": "name",
          "like": "[current('namePatternRequiredTag').pattern]"
        },
        {
          "field": "tags.env",
          "notEquals": "[current('namePatternRequiredTag').envTag]"
        }
      ]
    }
  },
  "greater": 0
}

Per alcuni esempi utili, vedere gli esempi di value count.

Riferimenti alle proprietà delle risorse della matrice

Molti casi d'uso richiedono di gestire le proprietà della matrice nella risorsa valutata. Alcuni scenari richiedono di fare riferimento a un'intera matrice (ad esempio, verificarne la lunghezza). Altri richiedono l'applicazione di una condizione a ogni singolo membro della matrice (ad esempio, assicurarsi che tutte le regole del firewall blocchino l'accesso da Internet). Per scrivere le condizioni che soddisfino questi scenari, è fondamentale capire quali sono i diversi modi in cui Criteri di Azure può fare riferimento alle proprietà delle risorse e qual è il comportamento di questi riferimenti nel caso siano rivolti alle proprietà della matrice.

Riferimenti alle proprietà delle risorse

Criteri di Azure può fare riferimento alle proprietà delle risorse tramite alias. Esistono due modi per fare riferimento ai valori della proprietà di una risorsa in Criteri di Azure:

  • Usare la condizione del campo per verificare se tutte le proprietà della risorsa selezionate soddisfano una condizione. Esempio:

    {
  "field": "Microsoft.Test/resourceType/property",
  "equals": "value"
}

  • Usare la funzione field() per accedere al valore di una proprietà. Esempio:

    {
  "value": "[take(field('Microsoft.Test/resourceType/property'), 7)]",
  "equals": "prefix_"
}

La condizione del campo ha un comportamento implicito allOf . Se l'alias rappresenta una raccolta di valori, verifica se tutti i singoli valori soddisfano la condizione. La funzione field() restituisce i valori rappresentati dall'alias così come sono, che possono quindi essere modificati da altre funzioni modello.

Riferimenti ai campi della matrice

Le proprietà delle risorse della matrice sono rappresentate da due tipi diversi di alias. Un alias normale e alias [*] di matrice associati:

  • Microsoft.Test/resourceType/stringArray
  • Microsoft.Test/resourceType/stringArray[*]

Riferimenti alla matrice

Il primo alias rappresenta un singolo valore, ovvero il valore della proprietà stringArray dal contenuto della richiesta. Poiché il valore di tale proprietà è una matrice, non è utile nelle condizioni dei criteri. Ad esempio:

{
  "field": "Microsoft.Test/resourceType/stringArray",
  "equals": "..."
}

Questa condizione confronta l'intera matrice stringArray con un singolo valore stringa. La maggior parte delle condizioni, tra cui equals, accetta solo valori stringa, quindi non è molto utile confrontare una matrice con una stringa. Lo scenario principale in cui è utile fare riferimento alla proprietà della matrice è quando ne viene verificata l'esistenza:

{
  "field": "Microsoft.Test/resourceType/stringArray",
  "exists": "true"
}

Con la funzione field(), il valore restituito è la matrice del contenuto della richiesta, che può quindi essere usata con una delle funzioni modello supportate che accettano argomenti di matrice. Ad esempio, la condizione seguente controlla se la lunghezza di stringArray è maggiore di 0:

{
  "value": "[length(field('Microsoft.Test/resourceType/stringArray'))]",
  "greater": 0
}

Riferimenti alla raccolta di membri della matrice

Gli alias che usano la [*] sintassi rappresentano una raccolta di valori di proprietà selezionati da una proprietà di matrice, diversa dalla selezione della proprietà matrice stessa. Ad esempio, restituisce Microsoft.Test/resourceType/stringArray[*] una raccolta con tutti i membri di stringArray. Come accennato in precedenza, una field condizione verifica che tutte le proprietà della risorsa selezionate soddisfino la condizione, pertanto la condizione seguente è true solo se tutti i membri di stringArray sono uguali a "value".

{
  "field": "Microsoft.Test/resourceType/stringArray[*]",
  "equals": "value"
}

Se la matrice è vuota, la condizione restituisce true perché nessun membro della matrice è in violazione. In questo scenario, è consigliabile usare invece l'espressione count. Se la matrice contiene oggetti, è possibile usare un alias [*] per selezionare il valore di una proprietà specifica di ogni membro della matrice. Esempio:

{
  "field": "Microsoft.Test/resourceType/objectArray[*].property",
  "equals": "value"
}

Questa condizione è true se i valori di tutte le proprietà property in objectArray sono uguali a "value". Per altri esempi, vedere Altri esempi di alias.

Quando si usa la funzione field() per fare riferimento a un alias di matrice, il valore restituito è una matrice di tutti i valori selezionati. Questo comportamento significa che il caso d'uso comune della funzione field(), ovvero la possibilità di applicare funzioni modello ai valori delle proprietà delle risorse, è limitato. Le uniche funzioni modello che possono essere usate in questo caso sono quelle che accettano argomenti di matrice. Ad esempio, è possibile ottenere la lunghezza della matrice con [length(field('Microsoft.Test/resourceType/objectArray[*].property'))]. Tuttavia, scenari più complessi come l'applicazione della funzione modello a ogni membro della matrice e il confronto con un valore desiderato sono possibili solo quando si usa l'espressione count. Per altre informazioni, vedere Espressioni field count.

Per riepilogare, vedere il contenuto della risorsa di esempio seguente e i valori selezionati restituiti da vari alias:

{
  "tags": {
    "env": "prod"
  },
  "properties": {
    "stringArray": [
      "a",
      "b",
      "c"
    ],
    "objectArray": [
      {
        "property": "value1",
        "nestedArray": [
          1,
          2
        ]
      },
      {
        "property": "value2",
        "nestedArray": [
          3,
          4
        ]
      }
    ]
  }
}

Quando si usa la condizione di campo nel contenuto della risorsa di esempio, i risultati sono i seguenti:

Alias Valori selezionati
Microsoft.Test/resourceType/missingArray null
Microsoft.Test/resourceType/missingArray[*] Una raccolta vuota di valori.
Microsoft.Test/resourceType/missingArray[*].property Una raccolta vuota di valori.
Microsoft.Test/resourceType/stringArray ["a", "b", "c"]
Microsoft.Test/resourceType/stringArray[*] "a", "b", "c"
Microsoft.Test/resourceType/objectArray[*] { "property": "value1", "nestedArray": [ 1, 2 ] },
{ "property": "value2", "nestedArray": [ 3, 4 ] }
Microsoft.Test/resourceType/objectArray[*].property "value1", "value2"
Microsoft.Test/resourceType/objectArray[*].nestedArray [ 1, 2 ], [ 3, 4 ]
Microsoft.Test/resourceType/objectArray[*].nestedArray[*] 1, 2, 34

Quando si usa la field() funzione nel contenuto della risorsa di esempio, i risultati sono i seguenti:

Espressione Valore restituito
[field('Microsoft.Test/resourceType/missingArray')] ""
[field('Microsoft.Test/resourceType/missingArray[*]')] []
[field('Microsoft.Test/resourceType/missingArray[*].property')] []
[field('Microsoft.Test/resourceType/stringArray')] ["a", "b", "c"]
[field('Microsoft.Test/resourceType/stringArray[*]')] ["a", "b", "c"]
[field('Microsoft.Test/resourceType/objectArray[*]')] [{ "property": "value1", "nestedArray": [ 1, 2 ] }, { "property": "value2", "nestedArray": [ 3, 4 ] }]
[field('Microsoft.Test/resourceType/objectArray[*].property')] ["value1", "value2"]
[field('Microsoft.Test/resourceType/objectArray[*].nestedArray')] [[ 1, 2 ], [ 3, 4 ]]
[field('Microsoft.Test/resourceType/objectArray[*].nestedArray[*]')] [1, 2, 3, 4]

Espressioni field count

Le espressioni field count contano il numero di membri della matrice che soddisfano una condizione e confrontano il conteggio con un valore obiettivo. Count è più intuitiva e versatile per la valutazione delle matrici rispetto alle condizioni field. La sintassi è:

{
  "count": {
    "field": <[*
    ] alias>,
    "where": <optional policy condition expression>
  },
  "equals|greater|less|any other operator": <target value>
}

Se usata senza una condizione where, count restituisce semplicemente la lunghezza di una matrice. Con il contenuto della risorsa di esempio della sezione precedente, l'espressione count restituisce true perché stringArray ha tre membri:

{
  "count": {
    "field": "Microsoft.Test/resourceType/stringArray[*]"
  },
  "equals": 3
}

Questo comportamento funziona anche con matrici annidate. Ad esempio, l'espressione count seguente restituisce true perché le matrici nestedArray contengono quattro membri:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*].nestedArray[*]"
  },
  "greaterOrEquals": 4
}

La potenza di count è dovuta alla condizione where. Quando count viene specificato, Criteri di Azure enumera i membri della matrice e valuta ognuno in base alla condizione, conteggiando il numero di membri della matrice valutati in true. In particolare, in ogni iterazione della valutazione della where condizione, Criteri di Azure seleziona un singolo membro i della matrice e valuta il contenuto della risorsa rispetto alla where condizione come se i fosse l'unico membro della matrice. Con un unico membro della matrice disponibile in ogni iterazione, è possibile applicare condizioni complesse su ogni singolo membro.

Esempio:

{
  "count": {
    "field": "Microsoft.Test/resourceType/stringArray[*]",
    "where": {
      "field": "Microsoft.Test/resourceType/stringArray[*]",
      "equals": "a"
    }
  },
  "equals": 1
}

Per valutare l'espressione count, Criteri di Azure valuta la condizione where tre volte, una volta per ogni membro di stringArray, contando quante volte restituisce true. Quando la where condizione fa riferimento ai membri della Microsoft.Test/resourceType/stringArray[*] matrice, anziché selezionare tutti i membri di stringArray, seleziona solo un singolo membro di matrice ogni volta:

Iterazione Valori di Microsoft.Test/resourceType/stringArray[*] selezionati Risultato della valutazione where
1 "a" true
2 "b" false
3 "c" false

count restituisce 1.

Ecco un'espressione più complessa:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
      "allOf": [
        {
          "field": "Microsoft.Test/resourceType/objectArray[*].property",
          "equals": "value2"
        },
        {
          "field": "Microsoft.Test/resourceType/objectArray[*].nestedArray[*]",
          "greater": 2
        }
      ]
    }
  },
  "equals": 1
}
Iterazione Valori selezionati Risultato della valutazione where
1 Microsoft.Test/resourceType/objectArray[*].property= =>>"value1" Microsoft.Test/resourceType/objectArray[*].nestedArray[*]
1,2		 false
2 Microsoft.Test/resourceType/objectArray[*].property= =>>"value2" Microsoft.Test/resourceType/objectArray[*].nestedArray[*]
3,4		 true

count restituisce 1.

Il fatto che l'espressione where venga valutata rispetto all'intero contenuto della richiesta (con modifiche solo al membro della matrice attualmente in fase di enumerazione) significa che la condizione where può anche fare riferimento a campi esterni alla matrice:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
      "field": "tags.env",
      "equals": "prod"
    }
  },
  "equals": 0
}
Iterazione Valori selezionati Risultato della valutazione where
1 tags.env =>"prod" true
2 tags.env =>"prod" true

Le espressioni count annidate possono essere usate per applicare condizioni ai campi di matrice annidati. Ad esempio, la condizione seguente controlla che la matrice objectArray[*] abbia esattamente due membri con nestedArray[*] che contiene uno o più membri:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
      "count": {
        "field": "Microsoft.Test/resourceType/objectArray[*].nestedArray[*]"
      },
      "greaterOrEquals": 1
    }
  },
  "equals": 2
}
Iterazione Valori selezionati Risultato della valutazione di count annidata
1 Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>1, 2 nestedArray[*] ha 2 membri =>true
2 Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>3, 4 nestedArray[*] ha 2 membri =>true

Poiché entrambi i membri di objectArray[*] hanno una matrice figlio nestedArray[*] con due membri, l'espressione count esterna restituisce 2.

Esempio più complesso: verificare che la matrice objectArray[*] abbia esattamente due membri con nestedArray[*] contenente qualsiasi membro uguale a 2 o 3:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
      "count": {
        "field": "Microsoft.Test/resourceType/objectArray[*].nestedArray[*]",
        "where": {
          "field": "Microsoft.Test/resourceType/objectArray[*].nestedArray[*]",
          "in": [
            2,
            3
          ]
        }
      },
      "greaterOrEquals": 1
    }
  },
  "equals": 2
}
Iterazione Valori selezionati Risultato della valutazione di count annidata
1 Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>1, 2 nestedArray[*] contiene 2 =>true
2 Microsoft.Test/resourceType/objectArray[*].nestedArray[*] =>3, 4 nestedArray[*] contiene 3 =>true

Poiché entrambi i membri di objectArray[*] hanno una matrice figlio nestedArray[*] contenente 2 o 3, l'espressione count esterna restituisce 2.

Nota

Le espressioni field count annidate possono fare riferimento solo a matrici annidate. Ad esempio, l'espressione count che fa riferimento a Microsoft.Test/resourceType/objectArray[*] può avere un'espressione count annidata destinata alla matrice annidata Microsoft.Test/resourceType/objectArray[*].nestedArray[*], ma non può avere un'espressione count annidata destinata a Microsoft.Test/resourceType/stringArray[*].

Accesso al membro della matrice corrente con funzioni modello

Quando si usano funzioni modello, usare la funzione current() per accedere al valore del membro della matrice corrente o ai valori di una delle relative proprietà. Per accedere al valore del membro della matrice corrente, passare l'alias definito in count.field o uno dei relativi alias figlio come argomento alla funzione current(). Ad esempio:

{
  "count": {
    "field": "Microsoft.Test/resourceType/objectArray[*]",
    "where": {
      "value": "[current('Microsoft.Test/resourceType/objectArray[*].property')]",
      "like": "value*"
    }
  },
  "equals": 2
}
Iterazione Valore restituito da current() Risultato della valutazione where
1 Valore di property nel primo membro di objectArray[*]: value1 true
2 Valore di property nel primo membro di objectArray[*]: value2 true

Funzione field all'interno di condizioni where

La funzione field() può essere usata anche per accedere al valore del membro della matrice corrente, purché l'espressione count non si trovi all'interno di una condizione di esistenza (la funzione field() fa sempre riferimento alla risorsa valutata nella condizione if). Il comportamento di field() quando fa riferimento alla matrice valutata si basa sui concetti seguenti:

  • Gli alias di matrice vengono risolti in una raccolta di valori selezionati da tutti i membri della matrice.
  • Le funzioni field() che fanno riferimento agli alias di matrice restituiscono una matrice con i valori selezionati.
  • Facendo riferimento all'alias della matrice conteggiata all'interno della condizione where, viene restituita una raccolta con un singolo valore selezionato dal membro della matrice valutato nell'iterazione corrente.

Questo comportamento significa che quando si fa riferimento al membro della matrice conteggiata con una funzione field() all'interno della condizione where, viene restituita una matrice con un singolo membro. Anche se questo comportamento potrebbe non essere intuitivo, è coerente con l'idea che gli alias di matrice restituiscono sempre una raccolta di proprietà selezionate. Ecco un esempio:

{
  "count": {
    "field": "Microsoft.Test/resourceType/stringArray[*]",
    "where": {
      "field": "Microsoft.Test/resourceType/stringArray[*]",
      "equals": "[field('Microsoft.Test/resourceType/stringArray[*]')]"
    }
  },
  "equals": 0
}
Iterazione Valori dell'espressione Risultato della valutazione where
1 Microsoft.Test/resourceType/stringArray[*]= =>"a"
[field('Microsoft.Test/resourceType/stringArray[*]')] >[ "a" ]		 false
2 Microsoft.Test/resourceType/stringArray[*]= =>"b"
[field('Microsoft.Test/resourceType/stringArray[*]')] >[ "b" ]		 false
3 Microsoft.Test/resourceType/stringArray[*]= =>"c"
[field('Microsoft.Test/resourceType/stringArray[*]')] >[ "c" ]		 false

Pertanto, quando è necessario accedere al valore dell'alias della matrice conteggiata con una funzione field(), occorre eseguirne il wrapping con una funzione modello first():

{
  "count": {
    "field": "Microsoft.Test/resourceType/stringArray[*]",
    "where": {
      "field": "Microsoft.Test/resourceType/stringArray[*]",
      "equals": "[first(field('Microsoft.Test/resourceType/stringArray[*]'))]"
    }
  }
}
Iterazione Valori dell'espressione Risultato della valutazione where
1 Microsoft.Test/resourceType/stringArray[*]= =>"a"
[first(field('Microsoft.Test/resourceType/stringArray[*]'))] >"a"		 true
2 Microsoft.Test/resourceType/stringArray[*]= =>"b"
[first(field('Microsoft.Test/resourceType/stringArray[*]'))] >"b"		 true
3 Microsoft.Test/resourceType/stringArray[*]= =>"c"
[first(field('Microsoft.Test/resourceType/stringArray[*]'))] >"c"		 true

Per alcuni esempi utili, vedere gli esempi di field count.

Modifica delle matrici

Gli effetti append e modify alterano le proprietà di una risorsa durante la creazione o l'aggiornamento. Quando si lavora con le proprietà della matrice, il comportamento di questi effetti dipende dal fatto che l'operazione stia tentando di modificare o meno l'alias [*] :

Nota

L'uso dell'effetto modify con alias è attualmente in fase di anteprima.

Alias Effetto Risultato
Microsoft.Storage/storageAccounts/networkAcls.ipRules append Criteri di Azure aggiunge l'intera matrice specificata nei dettagli dell'effetto, se mancante.
Microsoft.Storage/storageAccounts/networkAcls.ipRules modify con operazione add Criteri di Azure aggiunge l'intera matrice specificata nei dettagli dell'effetto, se mancante.
Microsoft.Storage/storageAccounts/networkAcls.ipRules modify con operazione addOrReplace Criteri di Azure aggiunge l'intera matrice specificata nei dettagli dell'effetto, se mancante, o sostituisce la matrice esistente.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*] append Criteri di Azure aggiunge il membro della matrice specificato nei dettagli dell'effetto.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*] modify con operazione add Criteri di Azure aggiunge il membro della matrice specificato nei dettagli dell'effetto.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*] modify con operazione addOrReplace Criteri di Azure rimuove tutti i membri della matrice esistenti e aggiunge il membro della matrice specificato nei dettagli dell'effetto.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].action append Criteri di Azure aggiunge un valore alla proprietà action di ogni membro della matrice.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].action modify con operazione add Criteri di Azure aggiunge un valore alla proprietà action di ogni membro della matrice.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].action modify con operazione addOrReplace Criteri di Azure aggiunge o sostituisce la proprietà action di ogni membro della matrice.

Per altre informazioni, vedere gli esempi di Append.

Altri esempi di alias

È consigliabile usare le espressioni di conteggio dei campi per verificare se allOfo anyOf i membri di una matrice nel contenuto della richiesta soddisfano una condizione. Per alcune condizioni semplici, è possibile ottenere lo stesso risultato usando una funzione di accesso al campo con un alias di matrice, come descritto in Riferimento all'insieme di membri della matrice. Questo modello può essere utile nelle regole dei criteri che superano il limite di espressioni consentite count . Ecco alcuni esempi per i casi d'uso comuni:

Regola dei criteri di esempio per la tabella di scenario seguente:

"policyRule": {
  "if": {
    "allOf": [
      {
        "field": "Microsoft.Storage/storageAccounts/networkAcls.ipRules",
        "exists": "true"
      },
            <-- Condition (see table below) -->
    ]
  },
  "then": {
    "effect": "[parameters('effectType')]"
  }
}

La ipRules matrice è la seguente per la tabella dello scenario seguente:

"ipRules": [
  {
    "value": "127.0.0.1",
    "action": "Allow"
  },
  {
    "value": "192.168.1.1",
    "action": "Allow"
  }
]

Per ognuno degli esempi di condizione seguenti, sostituire <field> con "field": "Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].value".

I risultati seguenti sono il risultato della combinazione della condizione e della regola dei criteri di esempio e della matrice di valori esistenti precedenti:

Condizione Risultato Scenario Spiegazione
{<field>,"notEquals":"127.0.0.1"} Nothing Nessuna corrispondenza Un elemento matrice restituisce false (127.0.0.1 != 127.0.0.1) e uno come true (127.0.0.1 != 192.168.1.1), quindi la notEquals condizione è false e l'effetto non viene attivato.
{<field>,"notEquals":"10.0.4.1"} Effetto dei criteri Nessuna corrispondenza Entrambi gli elementi della matrice restituiscono true (10.0.4.1 != 127.0.0.1 and 10.0.4.1 != 192.168.1.1), quindi la notEquals condizione è true e l'effetto viene attivato.
"not":{<field>,"notEquals":"127.0.0.1" } Effetto dei criteri Una o più corrispondenze Un elemento matrice restituisce false (127.0.0.1 != 127.0.0.1) e uno come true (127.0.0.1 != 192.168.1.1), quindi la notEquals condizione è false. L'operatore logico restituisce true (non false), quindi l'effetto viene attivato.
"not":{<field>,"notEquals":"10.0.4.1"} Nothing Una o più corrispondenze Entrambi gli elementi della matrice restituiscono true (10.0.4.1 != 127.0.0.1 and 10.0.4.1 != 192.168.1.1), quindi la notEquals condizione è true. L'operatore logico restituisce false (non true), quindi l'effetto non viene attivato.
"not":{<field>,"Equals":"127.0.0.1"} Effetto dei criteri Corrispondenza non totale Un elemento matrice restituisce true (127.0.0.1 == 127.0.0.1) e uno come false (127.0.0.1 == 192.168.1.1), quindi la Equals condizione è false. L'operatore logico restituisce true (non false), quindi l'effetto viene attivato.
"not":{<field>,"Equals":"10.0.4.1"} Effetto dei criteri Corrispondenza non totale Entrambi gli elementi della matrice restituiscono false (10.0.4.1 == 127.0.0.1 and 10.0.4.1 == 192.168.1.1), quindi la Equals condizione è false. L'operatore logico restituisce true (non false), quindi l'effetto viene attivato.
{<field>,"Equals":"127.0.0.1"} Nothing Corrispondenza totale Un elemento matrice restituisce true (127.0.0.1 == 127.0.0.1) e uno come false (127.0.0.1 == 192.168.1.1), quindi la Equals condizione è false e l'effetto non viene attivato.
{<field>,"Equals":"10.0.4.1"} Nothing Corrispondenza totale Entrambi gli elementi della matrice restituiscono false (10.0.4.1 == 127.0.0.1 and 10.0.4.1 == 192.168.1.1), quindi la Equals condizione è false e l'effetto non viene attivato.

Passaggi successivi