Struktura definicji zasad platformy Azure

Usługa Azure Policy ustala konwencje dotyczące zasobów. Definicje zasad opisują warunki zgodności zasobów i efekt, jaki należy zastosować, jeśli warunek zostanie spełniony. Warunek porównuje pole lub wartość właściwości zasobu z wartością wymaganą. Dostęp do pól właściwości zasobu jest uzyskiwany przy użyciu aliasów. Gdy pole właściwości zasobu jest tablicą, można użyć specjalnego aliasu tablicy, aby wybrać wartości ze wszystkich elementów członkowskich tablicy i zastosować warunek do każdego z nich. Dowiedz się więcej o warunkach.

Definiując konwencje, można kontrolować koszty i łatwiej zarządzać zasobami. Można na przykład określić, że dozwolone są tylko niektóre typy maszyn wirtualnych. Możesz też wymagać, aby zasoby miały określony tag. Przypisania zasad są dziedziczone przez zasoby podrzędne. Jeśli przypisanie zasad jest stosowane do grupy zasobów, jest ono stosowane do wszystkich zasobów w tej grupie zasobów.

Schemat zasad definicji zasadRule znajduje się tutaj: https://schema.management.azure.com/schemas/2020-10-01/policyDefinition.json

Do utworzenia definicji zasad służy kod JSON. Definicja zasad zawiera następujące elementy:

  • nazwa wyświetlana
  • description (opis)
  • tryb
  • metadane
  • parameters
  • reguła zasad
    • ocena logiczna
    • Efekt

Na przykład poniższy kod JSON pokazuje zasady ograniczające miejsce wdrażania zasobów:

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

Azure Policy wbudowane i wzorce znajdują się w Azure Policy przykładach.

Nazwa wyświetlana i opis

Nazwa wyświetlana i opis służą do identyfikowania definicji zasad i określania kontekstu, kiedy jest używany. displayName ma maksymalną długość 128 znaków i opis maksymalnie 512 znaków.

Uwaga

Podczas tworzenia lub aktualizowania definicji zasad, identyfikatora, typu i nazwy są definiowane przez właściwości zewnętrzne względem formatu JSON i nie są niezbędne w pliku JSON. Pobieranie definicji zasad za pomocą zestawu SDK zwraca właściwości identyfikatora, typu i nazwy w ramach kodu JSON, ale każda z nich jest tylko do odczytu powiązana z definicją zasad.

Typ

Chociaż nie można ustawić właściwości typu , istnieją trzy wartości zwracane przez zestaw SDK i widoczne w portalu:

  • Builtin: Te definicje zasad są udostępniane i obsługiwane przez firmę Microsoft.
  • Custom: wszystkie definicje zasad utworzone przez klientów mają tę wartość.
  • Static: wskazuje definicję zasad zgodności z przepisami z własnością firmy Microsoft. Wyniki zgodności dla tych definicji zasad są wynikami inspekcji innych firm dotyczących infrastruktury firmy Microsoft. W Azure Portal ta wartość jest czasami wyświetlana jako zarządzana przez firmę Microsoft. Aby uzyskać więcej informacji, zobacz Wspólna odpowiedzialność w chmurze.

Tryb

Tryb jest konfigurowany w zależności od tego, czy zasady są przeznaczone dla właściwości usługi Azure Resource Manager lub właściwości dostawcy zasobów.

tryby Resource Manager

Tryb określa, które typy zasobów są oceniane dla definicji zasad. Obsługiwane tryby to:

  • all: ocenianie grup zasobów, subskrypcji i wszystkich typów zasobów
  • indexed: ocenianie tylko typów zasobów obsługujących tagi i lokalizację

Na przykład zasób Microsoft.Network/routeTables obsługuje tagi i lokalizację i jest oceniany w obu trybach. Nie można jednak oznaczyć zasobu Microsoft.Network/routeTables/routes i nie jest oceniany w Indexed trybie.

Zalecamy ustawienie trybu na all wartość w większości przypadków. Wszystkie definicje zasad utworzone za pośrednictwem portalu używają all trybu . Jeśli używasz programu PowerShell lub interfejsu wiersza polecenia platformy Azure, możesz ręcznie określić parametr mode . Jeśli definicja zasad nie zawiera wartości trybu, wartość domyślna all to w Azure PowerShell i w null interfejsie wiersza polecenia platformy Azure. Tryb null jest taki sam jak w indexed przypadku obsługi zgodności z poprzednimi wersjami.

indexed należy używać podczas tworzenia zasad wymuszających tagi lub lokalizacje. Chociaż nie jest to wymagane, uniemożliwia ona wyświetlanie tagów i lokalizacji jako niezgodnych w wynikach zgodności zasobów, które nie obsługują tagów i lokalizacji. Wyjątkiem są grupy zasobów i subskrypcje. Definicje zasad, które wymuszają lokalizację lub tagi w grupie zasobów lub subskrypcji, powinny ustawiać tryb na i konkretnie określać allMicrosoft.Resources/subscriptions/resourceGroups typ lub Microsoft.Resources/subscriptions . Aby zapoznać się z przykładem, zobacz Pattern: Tags - Sample #1 (Wzorzec: tagi — przykład nr 1). Aby uzyskać listę zasobów, które obsługują tagi, zobacz Obsługa tagów dla zasobów platformy Azure.

Tryby dostawcy zasobów

Następujące tryby dostawcy zasobów są w pełni obsługiwane:

Następujące tryby dostawcy zasobów są obecnie obsługiwane jako wersja zapoznawcza:

  • Microsoft.Network.Datado zarządzania niestandardowymi zasadami członkostwa w usłudze Azure Virtual Network Manager przy użyciu Azure Policy.

Uwaga

Jeśli nie określono jawnie, tryby dostawcy zasobów obsługują tylko wbudowane definicje zasad, a wykluczenia nie są obsługiwane na poziomie składnika.

Metadane

Właściwość opcjonalna metadata przechowuje informacje o definicji zasad. Klienci mogą definiować dowolne właściwości i wartości przydatne dla swojej organizacji w programie metadata. Istnieją jednak pewne typowe właściwości używane przez Azure Policy i wbudowane. Każda metadata właściwość ma limit 1024 znaków.

Typowe właściwości metadanych

  • version (ciąg): śledzi szczegóły dotyczące wersji zawartości definicji zasad.
  • category(ciąg): określa, w której kategorii w Azure Portal jest wyświetlana definicja zasad.
  • preview (wartość logiczna): prawda lub fałsz flagi, jeśli definicja zasad jest w wersji zapoznawczej.
  • deprecated (wartość logiczna): prawda lub fałsz flaga, jeśli definicja zasad została oznaczona jako przestarzała.
  • portalReview (ciąg): określa, czy parametry mają być przeglądane w portalu, niezależnie od wymaganych danych wejściowych.

Uwaga

Usługa Azure Policy używa versionwłaściwości , previewi deprecated , aby przekazać poziom zmian do wbudowanej definicji zasad lub inicjatywy i stanu. Format to version : {Major}.{Minor}.{Patch}. Określone stany, takie jak przestarzałe lub podgląd, są dołączane do version właściwości lub w innej właściwości jako wartość logiczna. Aby uzyskać więcej informacji na temat sposobu, w jaki Azure Policy wersje wbudowane, zobacz Wbudowane przechowywanie wersji. Aby dowiedzieć się więcej o tym, co oznacza, że zasady mają być przestarzałe lub w wersji zapoznawczej, zobacz Zasady w wersji zapoznawczeji przestarzałe.

Parametry

Parametry ułatwiają zarządzanie zasadami przez zredukowanie liczby definicji zasad. Pomyśl o parametrach takich jak pola w formularzu — name, , addresscity, state. Te parametry zawsze pozostają takie same, jednak ich wartości zmieniają się w zależności od osoby wypełniającej formularz. Parametry działają w taki sam sposób, kiedy tworzysz zasady. Uwzględniając parametry w definicji zasad, można ponownie użyć tych samych zasad w różnych scenariuszach, stosując inne wartości.

Uwaga

Parametry można dodać do istniejącej i przypisanej definicji. Nowy parametr musi zawierać właściwość defaultValue . Zapobiega to pośrednio nieprawidłowym przypisaniom zasad lub inicjatywy.

Właściwości parametru

Parametr ma następujące właściwości, które są używane w definicji zasad:

  • name: nazwa parametru. Używany przez parameters funkcję wdrażania w regule zasad. Aby uzyskać więcej informacji, zobacz używanie wartości parametru.
  • type: określa, czy parametr jest ciągiem, tablicą, obiektem, wartością logiczną, liczbą całkowitą, zmienną zmienną lub datą/godziną.
  • metadata: Definiuje podwłaściwości używane głównie przez Azure Portal do wyświetlania przyjaznych dla użytkownika informacji:
    • description: wyjaśnienie parametru, dla którego jest używany. Może służyć do udostępniania przykładów akceptowalnych wartości.
    • displayName: przyjazna nazwa wyświetlana w portalu dla parametru.
    • strongType: (Opcjonalnie) Używane podczas przypisywania definicji zasad za pośrednictwem portalu. Udostępnia listę kontekstową. Aby uzyskać więcej informacji, zobacz strongType.
    • assignPermissions: (Opcjonalnie) Ustaw wartość true, aby Azure Portal tworzyć przypisania ról podczas przypisywania zasad. Ta właściwość jest przydatna w przypadku, gdy chcesz przypisać uprawnienia poza zakresem przypisania. Istnieje jedno przypisanie roli na definicję roli w zasadach (lub na definicję roli we wszystkich zasadach w ramach inicjatywy). Wartość parametru musi być prawidłowym zasobem lub zakresem.
  • defaultValue: (Opcjonalnie) Ustawia wartość parametru w przypisaniu, jeśli nie podano żadnej wartości. Wymagane podczas aktualizowania przypisanej istniejącej definicji zasad. W przypadku parametrów typu oject wartość musi być zgodna z odpowiednim schematem.
  • allowedValues: (Opcjonalnie) Udostępnia tablicę wartości, które parametr akceptuje podczas przypisywania. Dozwolone porównania wartości są uwzględniane w wielkości liter. W przypadku parametrów typu oject wartości muszą być zgodne z odpowiednim schematem.
  • schema: (Opcjonalnie) Zapewnia walidację danych wejściowych parametrów podczas przypisywania przy użyciu schematu JSON zdefiniowanego przez siebie. Ta właściwość jest obsługiwana tylko w przypadku parametrów typu obiektu i jest zgodna z implementacją schematu Json.NET 2019-09. Więcej informacji na temat używania schematów można uzyskać na stronie https://json-schema.org/ i przetestować schematy robocze pod adresem https://www.jsonschemavalidator.net/.

Przykładowe parametry

Przykład 1

Na przykład można zdefiniować definicję zasad, aby ograniczyć lokalizacje, w których można wdrażać zasoby. Parametr dla tej definicji zasad może być dozwolonyLokalizacja. Ten parametr będzie używany przez każde przypisanie definicji zasad w celu ograniczenia akceptowanych wartości. Użycie funkcji strongType zapewnia ulepszone środowisko podczas wykonywania przypisania za pośrednictwem portalu:

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

Przykładowe dane wejściowe dla tego parametru typu tablicy (bez strongType) w czasie przypisania mogą być ["westus", "eastus2"].

Przykład 2

W bardziej zaawansowanym scenariuszu można zdefiniować zasady wymagające zasobników klastra Kubernetes do używania określonych etykiet. Parametr dla tej definicji zasad może być labelSelector, który będzie używany przez każde przypisanie definicji zasad w celu określenia zasobów Kubernetes, których dotyczy pytanie na podstawie kluczy etykiet i wartości:

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

Przykładowe dane wejściowe dla tego parametru typu obiektu w czasie przypisania będą w formacie JSON, zweryfikowane przez określony schemat i mogą być następujące:

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

Używanie wartości parametru

W regule zasad odwołujesz się do parametrów z następującą parameters składnią funkcji:

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

Ten przykład odwołuje się do parametru allowedLocations , który został pokazany we właściwościach parametru.

strongType

metadata W ramach właściwości można użyć metody strongType, aby udostępnić listę opcji wielokrotnego wyboru w Azure Portal. strongType może być obsługiwanym typem zasobu lub dozwoloną wartością. Aby określić, czy typ zasobu jest prawidłowy dla strongType, użyj polecenia Get-AzResourceProvider. Format dla typu zasobustrongType to <Resource Provider>/<Resource Type>. Na przykład Microsoft.Network/virtualNetworks/subnets.

Obsługiwane są niektóre typy zasobów , które nie są zwracane przez polecenie Get-AzResourceProvider . Są to następujące typy:

  • Microsoft.RecoveryServices/vaults/backupPolicies

Niedozwolone wartości typu zasobu dla elementu strongType to:

  • location
  • resourceTypes
  • storageSkus
  • vmSKUs
  • existingResourceGroups

Lokalizacja definicji

Podczas tworzenia inicjatywy lub zasad należy określić lokalizację definicji. Lokalizacja definicji musi być grupą zarządzania lub subskrypcją. Ta lokalizacja określa zakres, do którego można przypisać inicjatywę lub zasady. Zasoby muszą być bezpośrednimi członkami lub elementami podrzędnym w hierarchii lokalizacji definicji, która ma być docelowa dla przypisania.

Jeśli lokalizacja definicji to:

  • Subskrypcja — do definicji zasad można przypisać tylko zasoby w ramach tej subskrypcji.
  • Grupa zarządzania — do definicji zasad można przypisać tylko zasoby w podrzędnych grupach zarządzania i subskrypcjach podrzędnych. Jeśli planujesz zastosować definicję zasad do kilku subskrypcji, lokalizacja musi być grupą zarządzania zawierającą każdą subskrypcję.

Aby uzyskać więcej informacji, zobacz Omówienie zakresu w Azure Policy.

Reguła zasad

Reguła zasad składa się z bloków If i Then . W bloku Jeśli zdefiniujesz co najmniej jeden warunki, które określają, kiedy zasady są wymuszane. Aby dokładnie zdefiniować scenariusz zasad, do warunków można zastosować operatory logiczne.

W bloku Następnie zdefiniujesz efekt, który występuje po spełnieniu warunków If .

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

Operatory logiczne

Obsługiwane operatory logiczne to:

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

Składnia nie odwraca wyniku warunku. Składnia allOf (podobna do logicznej i operacji) wymaga spełnienia wszystkich warunków. Składnia anyOf (podobna do logicznej lub operacji) wymaga, aby co najmniej jeden warunek był spełniony.

Operatory logiczne można zagnieżdżać. W poniższym przykładzie pokazano, że operacja nie jest zagnieżdżona w ramach operacji allOf .

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

Warunki

Warunek ocenia, czy wartość spełnia określone kryteria. Obsługiwane warunki to:

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

W przypadku mniejszej liczby , lessOrEquals, greater i greaterOrEquals, jeśli typ właściwości nie jest zgodny z typem warunku, zostanie zgłoszony błąd. Porównania ciągów są wykonywane przy użyciu polecenia InvariantCultureIgnoreCase.

W przypadku używania warunków takich jak i nieLike należy podać symbol wieloznaczny * w wartości . Wartość nie powinna zawierać więcej niż jednego symbolu wieloznacznych *.

W przypadku korzystania z warunków dopasowania i notMatch podaj # , aby dopasować cyfrę do ? litery, . aby dopasować dowolny znak i dowolny inny znak do dopasowania do tego rzeczywistego znaku. Podczas gdy dopasowanie i notMatch są uwzględniane wielkość liter, wszystkie inne warunki, które oceniają wartość stringValue , są bez uwzględniania wielkości liter. Alternatywy bez uwzględniania wielkości liter są dostępne w elemecie matchInsensitively i notMatchInsensitively.

Pola

Warunki, które oceniają, czy wartości właściwości w ładunku żądania zasobu spełniają określone kryteria, można utworzyć przy użyciu wyrażenia pola . Obsługiwane są następujące pola:

  • name
  • fullName
    • Zwraca pełną nazwę zasobu. Pełna nazwa zasobu jest nazwą zasobu poprzedzoną wszystkimi nazwami zasobów nadrzędnych (na przykład "myServer/myDatabase").
  • kind
  • type
  • location
    • Pola lokalizacji są znormalizowane w celu obsługi różnych formatów. Na przykład East US 2 jest uważany za równy eastus2.
    • Użyj globalnego dla zasobów, które są niezależne od lokalizacji.
  • id
    • Zwraca identyfikator zasobu, który jest oceniany.
    • Przykład: /subscriptions/06be863d-0996-4d56-be22-384767287aa2/resourceGroups/myRG/providers/Microsoft.KeyVault/vaults/myVault
  • identity.type
  • tags
  • tags['<tagName>']
    • Ta składnia nawiasu kwadratowego obsługuje nazwy tagów, które mają znaki interpunkcyjne, takie jak łącznik, kropka lub spacja.
    • Gdzie <tagName> jest nazwą tagu, aby zweryfikować warunek.
    • Przykłady: tags['Acct.CostCenter'] gdzie acct.CostCenter jest nazwą tagu.
  • tags['''<tagName>''']
    • Ta składnia nawiasu kwadratowego obsługuje nazwy tagów, które mają w nim apostrofy, uciekając z podwójnymi apostrofami.
    • Gdzie "<tagName>" jest nazwą tagu, aby zweryfikować warunek.
    • Przykład: tags['''My.Apostrophe.Tag'''] gdzie "My.Apostrophe.Tag" jest nazwą tagu.
  • aliasy właściwości — aby uzyskać listę, zobacz Aliasy.

Uwaga

tags.<tagName>, tags[tagName]i tags[tag.with.dots] są nadal akceptowalne sposoby deklarowania pola tagów. Jednak preferowane wyrażenia są wymienione powyżej.

Uwaga

W wyrażeniach pól odnoszących się do aliasu [*] każdy element w tablicy jest oceniany indywidualnie przy użyciu elementów logicznych i między nimi. Aby uzyskać więcej informacji, zobacz Odwoływanie się do właściwości zasobów tablicy.

Używanie tagów z parametrami

Wartość parametru można przekazać do pola tagu. Przekazywanie parametru do pola tagu zwiększa elastyczność definicji zasad podczas przypisywania zasad.

W poniższym przykładzie concat jest używany do tworzenia wyszukiwania pól tagów dla tagu o nazwie wartość parametru tagName . Jeśli ten tag nie istnieje, efekt modyfikacji jest używany do dodawania tagu przy użyciu wartości tego samego tagu o nazwie ustawionego na przeprowadź inspekcję grupy zasobów nadrzędnych przy użyciu funkcji odnośnika 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"
            ]
        }
    }
}

Wartość

Warunki, które oceniają, czy wartość spełnia określone kryteria, można utworzyć przy użyciu wyrażenia wartości . Wartości mogą być literałami, wartościami parametrów lub zwracanymi wartościami dowolnych obsługiwanych funkcji szablonu.

Ostrzeżenie

Jeśli wynikiem funkcji szablonu jest błąd, ocena zasad kończy się niepowodzeniem. Ocena nieudana jest niejawną odmową. Aby uzyskać więcej informacji, zobacz Unikanie błędów szablonów. Użyj funkcji enforcementMode usługi DoNotEnforce , aby zapobiec wpływowi nieudanej oceny na nowe lub zaktualizowane zasoby podczas testowania i sprawdzania poprawności nowej definicji zasad.

Przykłady wartości

Ten przykład reguły zasad używa wartości, aby porównać wynik resourceGroup() funkcji i zwróconej właściwości name z warunkiem *netrgtakim jak . Reguła odrzuca żaden zasób nie typu Microsoft.Network/*w żadnej grupie zasobów, której nazwa kończy się na .*netrg

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

Ten przykład reguły zasad używa wartości , aby sprawdzić, czy wynik wielu zagnieżdżonych funkcji jesttrue równy. Reguła odrzuca każdy zasób, który nie ma co najmniej trzech tagów.

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

Unikanie błędów szablonów

Użycie funkcji szablonu w wartości umożliwia korzystanie z wielu złożonych funkcji zagnieżdżonych. Jeśli wynikiem funkcji szablonu jest błąd, ocena zasad kończy się niepowodzeniem. Ocena nieudana jest niejawną odmową. Przykład wartości , która kończy się niepowodzeniem w niektórych scenariuszach:

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

W powyższej przykładowej regule zasad użyto ciągu substring(), aby porównać pierwsze trzy znaki nazwy z abc. Jeśli nazwa jest krótsza substring() niż trzy znaki, funkcja powoduje wystąpienie błędu. Ten błąd powoduje, że zasady stają się efektem odmowy .

Zamiast tego użyj funkcji if(), aby sprawdzić, czy pierwsze trzy znaki nazwy są równe abc bez zezwolenia na krótsze niż trzy znaki, aby spowodować błąd:

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

Poprawiona reguła if() zasad sprawdza długość nazwy przed próbą uzyskania substring() wartości z mniej niż trzema znakami. Jeśli nazwa jest za krótka, wartość "nie zaczyna się od abc" jest zwracana zamiast i porównywana z abc. Zasób o krótkiej nazwie, który nie zaczyna się od abc , nadal kończy się niepowodzeniem reguły zasad, ale nie powoduje już błędu podczas oceny.

Liczba

Warunki, które zliczą liczbę elementów członkowskich tablicy, spełniają określone kryteria, można utworzyć przy użyciu wyrażenia count . Typowe scenariusze sprawdzają, czy "co najmniej jeden z", "dokładnie jeden z", "wszystkie" lub "żadna z" składowych tablicy nie spełnia warunku. Funkcja Count oblicza każdy element członkowski tablicy dla wyrażenia warunku i sumuje prawdziwe wyniki, które są następnie porównywane z operatorem wyrażenia.

Liczba pól

Zlicz, ile elementów członkowskich tablicy w ładunku żądania spełnia wyrażenie warunku. Struktura wyrażeń liczby pól to:

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

Następujące właściwości są używane z liczbą pól:

  • count.field (wymagane): zawiera ścieżkę do tablicy i musi być aliasem tablicy.
  • count.where (opcjonalnie): wyrażenie warunku do indywidualnej oceny dla każdego elementu członkowskiego tablicy aliasów [*] .count.field Jeśli ta właściwość nie jest podana, wszystkie elementy członkowskie tablicy ze ścieżką pola są oceniane na wartość true. Dowolnego warunku można użyć wewnątrz tej właściwości. Operatory logiczne mogą być używane wewnątrz tej właściwości do tworzenia złożonych wymagań oceny.
  • <warunek> (wymagane): wartość jest porównywana z liczbą elementów, które spełniają wyrażenie count.where condition. Należy użyć warunku liczbowego.

Aby uzyskać więcej informacji na temat pracy z właściwościami tablicy w Azure Policy, w tym szczegółowe wyjaśnienie sposobu oceniania wyrażenia liczby pól, zobacz Referencing array resource properties (Odwoływanie się do właściwości zasobów tablicy).

Liczba wartości

Zlicz, ile elementów członkowskich tablicy spełnia warunek. Tablica może być tablicą literału lub odwołaniem do parametru tablicy. Struktura wyrażeń liczby wartości to:

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

Następujące właściwości są używane z liczbą wartości:

  • count.value (wymagane): tablica do obliczenia.
  • count.name (wymagane): nazwa indeksu składająca się z liter i cyfr w języku angielskim. Definiuje nazwę wartości składowej tablicy obliczonej w bieżącej iteracji. Nazwa jest używana do odwoływania się do bieżącej wartości wewnątrz count.where warunku. Opcjonalnie, gdy wyrażenie count nie znajduje się w elemecie podrzędnym innego wyrażenia count . Jeśli nie zostanie podana, nazwa indeksu jest niejawnie ustawiona na "default"wartość .
  • count.where (opcjonalnie): wyrażenie warunku, które ma być obliczane indywidualnie dla każdego elementu członkowskiego tablicy .count.value Jeśli ta właściwość nie jest podana, wszystkie elementy członkowskie tablicy są oceniane na wartość true. Dowolnego warunku można użyć wewnątrz tej właściwości. Operatory logiczne mogą być używane wewnątrz tej właściwości do tworzenia złożonych wymagań oceny. Dostęp do wartości aktualnie wyliczanego elementu członkowskiego tablicy można uzyskać, wywołując bieżącą funkcję.
  • <warunek> (wymagane): wartość jest porównywana z liczbą elementów, które spełniają count.where wyrażenie warunku. Należy użyć warunku liczbowego.

Bieżąca funkcja

Funkcja current() jest dostępna tylko wewnątrz count.where warunku. Zwraca wartość elementu członkowskiego tablicy, który jest obecnie wyliczany przez ocenę wyrażenia count .

Użycie liczby wartości

  • current(<index name defined in count.name>). Na przykład: current('arrayMember').
  • current(). Dozwolone tylko wtedy, gdy wyrażenie liczby wartości nie jest elementem podrzędnym innego wyrażenia count . Zwraca tę samą wartość co powyżej.

Jeśli wartość zwrócona przez wywołanie jest obiektem, obsługiwane są metody dostępu do właściwości. Na przykład: current('objectArrayMember').property.

Użycie liczby pól

  • current(<the array alias defined in count.field>). Na przykład current('Microsoft.Test/resource/enumeratedArray[*]').
  • current(). Dozwolone tylko wtedy, gdy wyrażenie liczby pól nie jest elementem podrzędnym innego wyrażenia count . Zwraca tę samą wartość co powyżej.
  • current(<alias of a property of the array member>). Na przykład current('Microsoft.Test/resource/enumeratedArray[*].property').

Przykłady liczby pól

Przykład 1: Sprawdzanie, czy tablica jest pusta

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

Przykład 2. Sprawdzanie, czy tylko jeden element członkowski tablicy spełnia wyrażenie warunku

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

Przykład 3. Sprawdzanie co najmniej jednego elementu członkowskiego tablicy w celu spełnienia wyrażenia warunku

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

Przykład 4. Sprawdzanie, czy wszystkie elementy członkowskie tablicy obiektów spełniają wyrażenie warunku

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

Przykład 5. Sprawdź, czy co najmniej jeden element członkowski tablicy pasuje do wielu właściwości w wyrażeniu warunku

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

Przykład 6: Użyj current() funkcji wewnątrz warunków, where aby uzyskać dostęp do wartości aktualnie wyliczanego elementu członkowskiego tablicy w funkcji szablonu. Ten warunek sprawdza, czy sieć wirtualna zawiera prefiks adresu, który nie znajduje się w zakresie 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
}

Przykład 7: Użyj field() funkcji wewnątrz warunków, where aby uzyskać dostęp do wartości obecnie wyliczanej składowej tablicy. Ten warunek sprawdza, czy sieć wirtualna zawiera prefiks adresu, który nie znajduje się w zakresie 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
}

Przykłady liczby wartości

Przykład 1: Sprawdzanie, czy nazwa zasobu jest zgodna z dowolnym z podanych wzorców nazw.

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

Przykład 2: Sprawdzanie, czy nazwa zasobu jest zgodna z dowolnym z podanych wzorców nazw. Funkcja current() nie określa nazwy indeksu. Wynik jest taki sam jak w poprzednim przykładzie.

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

Przykład 3: Sprawdź, czy nazwa zasobu jest zgodna z dowolnym z podanych wzorców nazw dostarczonych przez parametr tablicy.

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

Przykład 4: Sprawdź, czy którykolwiek z prefiksów adresów sieci wirtualnej nie znajduje się na liście zatwierdzonych prefiksów.

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

Przykład 5: Sprawdź, czy wszystkie zastrzeżone reguły sieciowej grupy zabezpieczeń są zdefiniowane w sieciowej grupie zabezpieczeń. Właściwości zarezerwowanych reguł sieciowej grupy zabezpieczeń są definiowane w parametrze tablicy zawierającym obiekty.

Wartość parametru:

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

Zasad:

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

Efekt

Azure Policy obsługuje następujące typy efektów:

  • Dołączanie: dodaje zdefiniowany zestaw pól do żądania
  • Inspekcja: generuje zdarzenie ostrzegawcze w dzienniku aktywności, ale nie kończy się niepowodzeniem żądania
  • AuditIfNotExists: generuje zdarzenie ostrzegawcze w dzienniku aktywności, jeśli powiązany zasób nie istnieje
  • Odmów: generuje zdarzenie w dzienniku aktywności i kończy się niepowodzeniem żądania
  • DeployIfNotExists: wdraża powiązany zasób, jeśli jeszcze nie istnieje
  • Wyłączone: nie ocenia zasobów pod kątem zgodności z regułą zasad
  • Modyfikowanie: dodaje, aktualizuje lub usuwa zdefiniowany zestaw pól w żądaniu
  • EnforceOPAConstraint (przestarzałe): konfiguruje kontroler wpływu agenta zasad open policy za pomocą programu Gatekeeper w wersji 3 dla samodzielnie zarządzanych klastrów Kubernetes na platformie Azure
  • EnforceRegoPolicy (przestarzałe): konfiguruje kontroler wpływu agenta zasad open policy za pomocą programu Gatekeeper v2 w Azure Kubernetes Service

Aby uzyskać szczegółowe informacje na temat każdego efektu, kolejności oceny, właściwości i przykładów, zobacz Understanding Azure Policy Effects (Opis efektów Azure Policy).

Funkcje zasad

Funkcje mogą służyć do wprowadzania dodatkowej logiki do reguły zasad. Są one rozwiązywane w ramach reguły zasad definicji zasad i wartości parametrów przypisanych do definicji zasad w inicjatywie.

Wszystkie funkcje szablonu Resource Manager są dostępne do użycia w ramach reguły zasad, z wyjątkiem następujących funkcji i funkcji zdefiniowanych przez użytkownika:

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

Uwaga

Te funkcje są nadal dostępne w details.deployment.properties.template ramach części wdrożenia szablonu w definicji zasad deployIfNotExists .

Poniższa funkcja jest dostępna do użycia w regule zasad, ale różni się od użycia w szablonie usługi Azure Resource Manager (szablon arm):

  • utcNow() — W przeciwieństwie do szablonu usługi ARM ta właściwość może być używana poza wartością defaultValue.
    • Zwraca ciąg, który jest ustawiony na bieżącą datę i godzinę w uniwersalnym formacie yyyy-MM-ddTHH:mm:ss.fffffffZDATETime 8601 .

Następujące funkcje są dostępne tylko w regułach zasad:

  • addDays(dateTime, numberOfDaysToAdd)

    • dateTime: ciąg [Required] — ciąg w formacie DateTime universal ISO 8601 'rrrr-MM-ddTHH:mm:ss. FFFFFFFZ'
    • numberOfDaysToAdd: liczba całkowita [Required] — liczba dni do dodania
  • field(fieldName)

    • fieldName: ciąg [Required] — nazwa pola do pobrania
    • Zwraca wartość tego pola z zasobu, który jest obliczany przez warunek If.
    • field Jest używana głównie z elementami AuditIfNotExists i DeployIfNotExists w celu odwoływanie się do pól w zasobie, które są oceniane. Przykład tego użycia można zobaczyć w przykładzie DeployIfNotExists.
  • requestContext().apiVersion

    • Zwraca wersję interfejsu API żądania, które wyzwoliło ocenę zasad (na przykład: 2021-09-01). Ta wartość to wersja interfejsu API, która została użyta w żądaniu PUT/PATCH do oceny podczas tworzenia/aktualizowania zasobów. Najnowsza wersja interfejsu API jest zawsze używana podczas oceny zgodności dla istniejących zasobów.
  • policy()

    • Zwraca następujące informacje o ocenianych zasadach. Dostęp do właściwości można uzyskać z zwróconego obiektu (na przykład: [policy().assignmentId]).

      {
        "assignmentId": "/subscriptions/ad404ddd-36a5-4ea8-b3e3-681e77487a63/providers/Microsoft.Authorization/policyAssignments/myAssignment",
        "definitionId": "/providers/Microsoft.Authorization/policyDefinitions/34c877ad-507e-4c82-993e-3452a6e0ad3c",
        "setDefinitionId": "/providers/Microsoft.Authorization/policySetDefinitions/42a694ed-f65e-42b2-aa9e-8052e9740a92",
        "definitionReferenceId": "StorageAccountNetworkACLs"
      }
      
  • ipRangeContains(range, targetRange)

    • zakres: ciąg [Wymagany] — ciąg określający zakres adresów IP w celu sprawdzenia, czy element targetRange znajduje się w obrębie.
    • targetRange: ciąg [Wymagane] — ciąg określający zakres adresów IP do zweryfikowania jako uwzględniony w zakresie.
    • Zwraca wartość logiczną określającą, czy zakres adresów IP zakresu zawiera zakres adresów IP targetRange . Puste zakresy lub mieszanie między rodzinami adresów IP nie jest dozwolone i powoduje niepowodzenie oceny.

    Obsługiwane formaty:

    • Pojedynczy adres IP (przykłady: 10.0.0.0, 2001:0DB8::3:FFFE)
    • Zakres CIDR (przykłady: 10.0.0.0/24, 2001:0DB8::/110)
    • Zakres zdefiniowany przez początkowe i końcowe adresy IP (przykłady: 192.168.0.1-192.168.0.9, 2001:0DB8::-2001:0DB8::3:FFFF)
  • current(indexName)

Przykład funkcji zasad

Ten przykład reguły zasad używa resourceGroup funkcji zasobów do pobrania właściwości name w połączeniu z concat tablicą i funkcją obiektu w celu utworzenia like warunku, który wymusza nazwę zasobu, aby rozpocząć od nazwy grupy zasobów.

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

Limity reguł zasad

Limity wymuszane podczas tworzenia

Podczas tworzenia lub przypisywania zasad są wymuszane limity struktury reguł zasad. Próba utworzenia lub przypisania definicji zasad przekraczających te limity zakończy się niepowodzeniem.

Limit Wartość Dodatkowe szczegóły
Wyrażenia warunku w warunku if 4096
Wyrażenia warunku w bloku then 128 Dotyczy istnieniaCondition zasad AuditIfNotExists i DeployIfNotExists
Funkcje zasad na regułę zasad 2048
Liczba parametrów funkcji zasad 128 Przykład: [function('parameter1', 'parameter2', ...)]
Głębokość zagnieżdżonych funkcji zasad 64 Przykład: [function(nested1(nested2(...)))]
Długość ciągu wyrażenia funkcji zasad 81920 Przykład: długość "[function(....)]"
Wyrażenia liczby pól na tablicę 5
Wyrażenia liczby wartości na regułę zasad 10
Liczba wyrażeń liczby wartości — liczba iteracji 100 W przypadku zagnieżdżonych wyrażeń zliczania wartości obejmuje to również liczbę iteracji wyrażenia nadrzędnego

Limity wymuszane podczas oceny

Stosuje ograniczenie do rozmiaru obiektów, które są przetwarzane przez funkcje zasad podczas oceny zasad. Te limity nie zawsze mogą być wymuszane podczas tworzenia, ponieważ zależą one od ocenianej zawartości. Przykład:

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

Długość ciągu utworzonego przez concat() funkcję zależy od wartości właściwości w ocenianym zasobie.

Limit Wartość Przykład
Długość ciągu zwracanego przez funkcję 131072 [concat(field('longString1'), field('longString2'))]
Głębokość złożonych obiektów podawanych jako parametr dla funkcji lub zwracanych przez funkcję 128 [union(field('largeObject1'), field('largeObject2'))]
Liczba węzłów złożonych obiektów podawanych jako parametr dla funkcji lub zwracanych przez funkcję 32768 [concat(field('largeArray1'), field('largeArray2'))]

Ostrzeżenie

Zasady, które przekraczają powyższe limity podczas oceny, skutecznie staną się zasadami odmowy i mogą blokować żądania przychodzące. Podczas pisania zasad ze złożonymi funkcjami należy pamiętać o tych limitach i przetestować zasady względem zasobów, które mogą je przekroczyć.

Aliasy

Aliasy właściwości są używane do uzyskiwania dostępu do określonych właściwości dla typu zasobu. Aliasy umożliwiają ograniczenie dozwolonych wartości lub warunków dla właściwości w zasobie. Każdy alias mapuje na ścieżki w różnych wersjach interfejsu API dla danego typu zasobu. Podczas oceny zasad aparat zasad pobiera ścieżkę właściwości dla tej wersji interfejsu API.

Lista aliasów jest zawsze rozwijana. Aby dowiedzieć się, jakie aliasy są obecnie obsługiwane przez Azure Policy, użyj jednej z następujących metod:

  • rozszerzenie Azure Policy dla Visual Studio Code (zalecane)

    Użyj rozszerzenia Azure Policy dla Visual Studio Code, aby wyświetlić i odnaleźć aliasy dla właściwości zasobu.

    Zrzut ekranu przedstawiający rozszerzenie Azure Policy dla Visual Studio Code umieszczenie wskaźnika myszy na właściwości w celu wyświetlenia nazw aliasów.

  • Azure PowerShell

    # Login first with Connect-AzAccount if not using Cloud Shell
    
    # Use Get-AzPolicyAlias to list available providers
    Get-AzPolicyAlias -ListAvailable
    
    # Use Get-AzPolicyAlias to list aliases for a Namespace (such as Azure Compute -- Microsoft.Compute)
    (Get-AzPolicyAlias -NamespaceMatch 'compute').Aliases
    

    Uwaga

    Aby znaleźć aliasy, które mogą być używane z efektem modyfikacji, użyj następującego polecenia w Azure PowerShell 4.6.0 lub nowszej:

    Get-AzPolicyAlias | Select-Object -ExpandProperty 'Aliases' | Where-Object { $_.DefaultMetadata.Attributes -eq 'Modifiable' }
    
  • Interfejs wiersza polecenia platformy Azure

    # Login first with az login if not using Cloud Shell
    
    # List namespaces
    az provider list --query [*].namespace
    
    # Get Azure Policy aliases for a specific Namespace (such as Azure Compute -- Microsoft.Compute)
    az provider show --namespace Microsoft.Compute --expand "resourceTypes/aliases" --query "resourceTypes[].aliases[].name"
    
  • Interfejs API REST /ARMClient

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

Opis aliasu [*]

Niektóre z dostępnych aliasów mają wersję, która jest wyświetlana jako nazwa "normalna", a inna z dołączonymi do niej wersjami [*]. Przykład:

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

Alias "normalny" reprezentuje pole jako pojedynczą wartość. To pole jest przeznaczone dla dokładnych scenariuszy porównania dopasowania, gdy cały zestaw wartości musi być dokładnie tak zdefiniowany, nie więcej i nie mniej.

Alias [*] reprezentuje kolekcję wartości wybranych z elementów właściwości zasobu tablicy. Przykład:

Alias Wybrane wartości
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*] Elementy tablicy ipRules .
Microsoft.Storage/storageAccounts/networkAcls.ipRules[*].action Wartości action właściwości z każdego elementu tablicy ipRules .

W przypadku użycia w warunku pola aliasy tablicy umożliwiają porównywanie poszczególnych elementów tablicy z wartością docelową. W przypadku użycia z wyrażeniem count można:

  • Sprawdzanie rozmiaru tablicy
  • Sprawdź, czy wszystkie\jakiekolwiek\njeden z elementów tablicy spełnia złożony warunek
  • Sprawdzanie, czy dokładnie n elementów tablicy spełnia warunek złożony

Aby uzyskać więcej informacji i przykładów, zobacz Odwoływanie się do właściwości zasobu tablicy.

Następne kroki