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:

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. La definizione dei criteri consente di usare un'unica località qualsiasi per il parametro allowedLocations. Il valore predefinito è eastus2:

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

Il valore di type è string, quindi è 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 il tipo dimatrice. 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 dei criteri, la proprietà type in un parametro non può essere modificata.

Questa nuova definizione dei parametri accetta più di un valore durante l'assegnazione dei criteri. Dopo aver definito la proprietà della matrice allowedValues, i valori disponibili durante l'assegnazione sono esclusivamente quelli disponibili nell'elenco predefinito delle opzioni. 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, viene visualizzato un parametro di matrice di tipo come singola casella di testo. in cui viene visualizzato il suggerimento "Usare il ; per separare i valori. Ad esempio: Londra;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 creazionePUT come parte del corpo della richiesta come valore della proprietà properties.parameters

Uso di matrici in condizioni

In e notIn

Le in condizioni e notIn funzionano solo con i valori della 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 conteggio valori conta il numero di membri della matrice che soddisfano una condizione. Fornisce un modo per valutare la stessa condizione più volte, usando valori diversi in ogni iterazione. Ad esempio, la condizione seguente verifica se il nome della risorsa corrisponde a qualsiasi modello da una matrice di modelli:

{
    "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 tre volte, una volta per ogni membro di , conteggiando il where numero di [ "test*", "dev*", "prod*" ]volte valutato in true. In ogni iterazione il valore del membro della matrice corrente viene associato al nome dell'indice pattern definito da count.name. Questo valore può quindi essere fatto riferimento all'interno della where condizione chiamando una funzione modello speciale: current('pattern').

Iterazione current('pattern') valore restituito
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 il riferimento ai parametri anziché una matrice letterale:

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

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

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

Il conteggio dei valori supporta anche matrici di oggetti complessi, consentendo condizioni più complesse. Ad esempio, la condizione seguente definisce un valore di tag desiderato per ogni modello di nome e verifica se il nome della risorsa corrisponde al modello, ma non ha il valore del 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 esempi utili, vedere esempi di conteggio dei valori.

Riferimenti alle proprietà delle risorse della matrice

Molti casi d'uso richiedono l'uso delle proprietà della matrice nella risorsa valutata. Alcuni scenari richiedono il riferimento a un'intera matrice, ad esempio verificandone 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. Comprendere i diversi modi Criteri di Azure può fare riferimento alle proprietà delle risorse e come questi riferimenti si comportano quando fanno riferimento alle proprietà della matrice è la chiave per la scrittura di condizioni che coprono questi scenari.

Riferimenti alle proprietà delle risorse

Le proprietà delle risorse possono essere a cui fare riferimento Criteri di Azure usando alias Esistono due modi per fare riferimento ai valori di una proprietà di risorsa all'interno di Criteri di Azure:

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

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

  • Usare field() la funzione 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 "tutto". Se l'alias rappresenta una raccolta di valori, verifica se tutti i singoli valori soddisfano la condizione. La field() funzione restituisce i valori rappresentati dall'alias così come è, che può quindi essere modificato da altre funzioni modello.

Riferimenti ai campi della matrice

Le proprietà della risorsa matrice sono rappresentate da due tipi diversi di alias. Alias e alias di matrice "normali" collegati [*] :

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

Riferimento alla matrice

Il primo alias rappresenta un singolo valore, il valore della proprietà dal contenuto della stringArray 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 stringArray matrice con un singolo valore stringa. La maggior parte delle condizioni, tra cui equals, accetta solo valori stringa, quindi non è molto usato per confrontare una matrice con una stringa. Lo scenario principale in cui si fa riferimento alla proprietà array è utile quando si verifica se esiste:

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

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

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

Riferimento alla raccolta dei membri della matrice

Gli alias che usano la [*] sintassi rappresentano una raccolta di valori di proprietà selezionati da una proprietà array, diversa dalla selezione della proprietà matrice stessa. Nel caso di Microsoft.Test/resourceType/stringArray[*], restituisce 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 "valore".

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

Se la matrice è vuota, la condizione restituirà 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 da ogni membro della matrice. Esempio:

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

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

Quando si usa la field() funzione 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, la possibilità di applicare funzioni modello ai valori delle field() proprietà delle risorse, è limitata. L'unica funzione modello che può essere usata in questo caso sono quelle che accettano gli argomenti della 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 Espressione conteggio campi.

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[*] Raccolta vuota di valori.
Microsoft.Test/resourceType/missingArray[*].property 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, 3, 4

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

Expression 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 di conteggio dei campi

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

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

Se usato senza una condizione, count restituisce semplicemente la lunghezza di una where matrice. Con il contenuto della risorsa di esempio della sezione precedente, l'espressione seguente count viene valutata 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 seguente count viene valutata true perché sono presenti quattro membri della matrice nelle nestedArray matrici:

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

Il potere di count è nella where condizione. Quando viene specificato, Criteri di Azure enumera i membri della matrice e valuta ognuno rispetto alla condizione, conteggiando il numero di membri della matrice valutati in true. In particolare, in ogni iterazione della valutazione della condizione, Criteri di Azure seleziona un singolo membro della matrice i e valuta il contenuto della where risorsa rispetto alla where condizione come se i sia l'unico membro della matrice. La disponibilità di un solo membro di matrice in ogni iterazione consente di applicare condizioni complesse in ogni singolo membro della matrice.

Esempio:

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

Per valutare l'espressionecount, Criteri di Azure valuta la condizione tre volte, una volta per ogni membro di , conteggiando il where numero di stringArrayvolte valutato in true. Quando la condizione fa riferimento ai Microsoft.Test/resourceType/stringArray[*] membri della where matrice, anziché selezionare tutti i membri di , seleziona solo un singolo membro della stringArraymatrice ogni volta che:

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

Restituisce count1.

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 where Risultato della valutazione
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

Restituisce count1.

Il fatto che l'espressione venga valutata rispetto all'intero contenuto della richiesta (con modifiche solo al membro della matrice attualmente enumerato) significa che la wherewhere condizione può fare riferimento anche ai campi esterni alla matrice:

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

Le espressioni di conteggio annidate possono essere usate per applicare le condizioni ai campi della matrice nidificata. Ad esempio, la condizione seguente verifica che la objectArray[*] matrice 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 del conteggio annidato
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 nestedArray[*] figlio con due membri, l'espressione conteggio esterno restituisce 2.

Esempio più complesso: verificare che la objectArray[*] matrice abbia esattamente due membri con nestedArray[*] tutti i membri uguali 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 del conteggio annidato
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 nestedArray[*] figlio che contiene 2 o 3, l'espressione conteggio esterno restituisce 2.

Nota

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

Accesso al membro della matrice corrente con funzioni modello

Quando si usano le funzioni modello, usare la current() funzione 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 current() funzione. Ad esempio:

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

Funzione campo all'interno di dove le condizioni

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

  1. Gli alias di matrice vengono risolti in una raccolta di valori selezionati da tutti i membri della matrice.
  2. field() le funzioni che fanno riferimento agli alias della matrice restituiscono una matrice con i valori selezionati.
  3. Facendo riferimento all'alias della matrice conteggiata all'interno della where condizione, 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 con conteggio con una funzione all'interno della where condizione, restituisce unafield() matrice con un singolo membro. Sebbene questo comportamento non sia intuitivo, è coerente con l'idea che gli alias della 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 where Risultato della valutazione
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 con conteggiato con una field() funzione, il modo per farlo consiste nel eseguirne il wrapping con una first() funzione modello:

{
  "count": {
    "field": "Microsoft.Test/resourceType/stringArray[*]",
    "where": {
      "field": "Microsoft.Test/resourceType/stringArray[*]",
      "equals": "[first(field('Microsoft.Test/resourceType/stringArray[*]'))]"
    }
  }
}
Iterazione Valori dell'espressione where Risultato della valutazione
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 esempi utili, vedere Esempi di conteggio dei campi.

Modifica di matrici

Aggiungere emodificare le proprietà di una risorsa durante la creazione o l'aggiornamento. Quando si utilizzano le proprietà della matrice, il comportamento di questi effetti dipende dal fatto che l'operazione stia tentando di modificare l'alias [*] o meno:

Nota

L'uso dell'effetto modify con alias è attualmente in 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 add operazione Criteri di Azure aggiunge l'intera matrice specificata nei dettagli dell'effetto, se mancante.
Microsoft.Storage/storageAccounts/networkAcls.ipRules modify con addOrReplace operazione 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 add operazione Criteri di Azure aggiunge il membro della matrice specificato nei dettagli dell'effetto.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*] modify con addOrReplace operazione 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 action proprietà di ogni membro della matrice.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].action modify con add operazione Criteri di Azure aggiunge un valore alla action proprietà di ogni membro della matrice.
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].action modify con addOrReplace operazione Criteri di Azure aggiunge o sostituisce la proprietà esistente 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 "tutti" o "uno qualsiasi dei" membri di una matrice nel contenuto della richiesta soddisfano una condizione. Tuttavia, 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 di conteggio consentite. Ecco alcuni esempi per i casi d'uso comuni:

Esempio di regola dei criteri per la tabella dello scenario seguente:

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

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

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

Per ogni condizione di esempio riportata di seguito, sostituire <field> con "field": "Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].value".

Di seguito sono riportati i risultati della combinazione della condizione, la regola dei criteri di esempio e la matrice di valori esistenti precedenti:

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

Passaggi successivi