Struktura definicji zasad platformy Azure

Azure Policy ustanawia konwencje dotyczące zasobów. Definicje zasad opisują warunki zgodności zasobów i efekt, który należy podjąć, jeśli warunek zostanie spełniony. Warunek porównuje pole właściwości zasobu lub wartość z wymaganą wartością. Dostęp do pól właściwości zasobu uzyskuje się 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 były o określonym tagu. Przypisania zasad są dziedziczone przez zasoby podrzędne. Jeśli przypisanie zasad jest stosowane do grupy zasobów, ma zastosowanie do wszystkich zasobów w tej grupie zasobów.

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

Aby utworzyć definicję zasad, należy użyć danych JSON. Definicja zasad zawiera elementy dla:

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

Na przykład poniższy kod JSON przedstawia zasady, które ograniczają miejsce wdrożenia 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ę Azure Policy przykładach.

Nazwa wyświetlana i opis

Wartości displayName i description służą do identyfikowania definicji zasad i określania kontekstu, kiedy są używane. Parametr displayName ma maksymalną długość 128 znaków i opis o maksymalnej długości 512 znaków.

Uwaga

Podczas tworzenia lub aktualizowania definicji zasad identyfikator , typ i nazwa są definiowane przez właściwości zewnętrzne niż dane JSON i nie są wymagane w pliku JSON. Pobieranie definicji zasad za pośrednictwem zestawu SDK zwraca właściwości identyfikatora, typu i nazwy w ramach pliku JSON, ale każda z nich jest informacjami tylko do odczytu powiązanymi z definicją zasad.

Typ

Nie można ustawić właściwości type, ale zestaw SDK zwraca trzy wartości, które są widoczne w portalu:

  • Builtin: te definicje zasad są udostępniane i utrzymywane 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 infrastruktury firmy Microsoft innych firm. W Azure Portal wartość jest czasami wyświetlana jako zarządzana przez firmę Microsoft. Aby uzyskać więcej informacji, zobacz Shared responsibility in the cloud (Wspólna odpowiedzialność w chmurze).

Tryb

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

Resource Manager trybu

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

  • all: ocena grup zasobów, subskrypcji i wszystkich typów zasobów
  • indexed: oceniaj tylko typy zasobów, które obsługują 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 Microsoft.Network/routeTables/routes oznaczać zasobu i nie jest on oceniany w Indexed trybie.

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

indexed należy używać podczas tworzenia zasad, które wymuszają tagi lub lokalizacje. Chociaż nie jest to wymagane, zapobiega wyświetlaniu w wynikach zgodności zasobów, które nie obsługują tagów i lokalizacji, jako niezgodne. 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 all w szczególności dotyczyć Microsoft.Resources/subscriptions/resourceGroups typu lub Microsoft.Resources/subscriptions . Aby uzyskać przykład, zobacz Pattern: Tags - Sample #1(Wzorzec: tagi — przykładowe #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ący tryb dostawcy zasobów jest w pełni obsługiwany:

  • Microsoft.Kubernetes.Data do zarządzania klastrami Kubernetes na platformie Azure lub poza platformą Azure. Definicje korzystające z tego trybu dostawcy zasobów używają efektów inspekcji, odmowy i wyłączenia. Ten tryb obsługuje definicje niestandardowe w publicznej wersji zapoznawczej. Zobacz Tworzenie definicji zasad na podstawie szablonu ograniczenia, aby utworzyć definicję niestandardową na podstawie istniejącego szablonu ograniczenia open policy agent (OPA) GateKeeper v3. Użycie efektu EnforceOPAConstraint jest przestarzałe.

Następujące tryby dostawcy zasobów są obecnie obsługiwane w wersji zapoznawczej:

Uwaga

Tryby dostawcy zasobów obsługują tylko wbudowane definicje zasad i nie obsługują wy wyjątków, jeśli nie zostanie jawnie określone.

Metadane

Opcjonalna metadata właściwość przechowuje informacje o definicji zasad. Klienci mogą definiować wszelkie 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ółowe informacje o wersji zawartości definicji zasad.
  • category (ciąg): określa, w której kategorii w Azure Portal wyświetlana jest definicja zasad.
  • preview (wartość logiczna): flaga true lub false dla , jeśli definicja zasad jest w wersji zapoznawczej.
  • deprecated (wartość logiczna): flaga true lub false dla , jeśli definicja zasad została oznaczona jako przestarzała.

Uwaga

Usługa Azure Policy używa właściwości , i , aby przekazać poziom zmiany wbudowanej definicji zasad lub version preview inicjatywy i deprecated stanu. Format pliku version to: {Major}.{Minor}.{Patch} . Określone stany, takie jak przestarzałe lub podgląd, są dołączane do właściwości lub innej właściwości version jako wartość logiczna. Aby uzyskać więcej informacji na temat sposobu Azure Policy wbudowanych wersji, zobacz Wbudowane wersje.

Parametry

Parametry ułatwiają zarządzanie zasadami przez zmniejszenie liczby definicji zasad. Parametry takie jak pola w formularzu — name , address , , city 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ą tak samo podczas tworzenia zasad. Uwzględniając parametry w definicji zasad, można ponownie użyć tych zasad dla różnych scenariuszy przy użyciu różnych wartości.

Uwaga

Parametry można dodać do istniejącej i przypisanej definicji. Nowy parametr musi zawierać właściwość defaultValue. Zapobiega to pośredniemu unieważnieniu istniejących przypisań 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 ramach reguły 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ą, zmiennoprzecinkową lub datą/godziną.
  • metadata: definiuje właściwości podrzędne używane głównie przez Azure Portal do wyświetlania przyjaznych dla użytkownika informacji:
    • description: wyjaśnienie, do czego służy parametr . Może służyć do podania przykładów dopuszczalnych wartości.
    • displayName: przyjazna nazwa parametru wyświetlana w portalu.
    • strongType: (Opcjonalnie) Używany podczas przypisywania definicji zasad za pośrednictwem portalu. Zawiera listę z kontekstem. 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 dla definicji roli we wszystkich zasadach w inicjatywie). Wartość parametru musi być prawidłowym zasobem lub zakresem.
  • defaultValue: (Opcjonalnie) Ustawia wartość parametru w przypisaniu, jeśli nie zostanie podana żadna wartość. Wymagane podczas aktualizowania istniejącej definicji zasad, która jest przypisana.
  • allowedValues: (Opcjonalnie) Dostarcza tablicę wartości, które parametr akceptuje podczas przypisywania. W porównaniach dozwolonych wartości jest wielkość liter.

Na przykład można zdefiniować definicję zasad, aby ograniczyć lokalizacje, w których można wdrożyć zasoby. Parametrem dla tej definicji zasad może być allowedLocations. Ten parametr będzie używany przez każde przypisanie definicji zasad w celu ograniczenia akceptowanych wartości. Użycie 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"
        ]
    }
}

Używanie wartości parametru

W regułę zasad należy odwoływać się do parametrów przy użyciu następującej parameters składni funkcji:

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

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

strongType

W ramach metadata właściwości można użyć strongType, aby podać 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 get-AzResourceProvider. Format typu zasobu strongType 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 get-AzResourceProvider. Te typy to:

  • Microsoft.RecoveryServices/vaults/backupPolicies

Dozwolone wartości strongType typu innego niż typ zasobu 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 docelowymi w hierarchii lokalizacji definicji do przypisania.

Jeśli lokalizacja definicji to:

  • Subskrypcja — definicję zasad można przypisać tylko do zasobów w ramach tej subskrypcji.
  • Grupa zarządzania — definicję zasad można przypisać tylko do zasobów w ramach podrzędnych grup zarządzania i subskrypcji podrzędnej. Jeśli zamierzasz zastosować definicję zasad do kilku subskrypcji, lokalizacja musi być grupą zarządzania, która zawiera każdą subskrypcję.

Aby uzyskać więcej informacji, zobacz Opis zakresu w Azure Policy.

Reguła zasad

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

W bloku Następnie zdefiniuj efekt, który ma miejsce 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 operacji logicznej And) wymaga, aby wszystkie warunki zawierały wartość true. Składnia anyOf (podobna do operacji logicznej Or) wymaga, aby co najmniej jeden z warunków był prawdziwy.

Można zagnieżdżać operatory logiczne. W poniższym przykładzie pokazano nie operację, która jest zagnieżdżona w 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 wartości less, lessOrEquals, greater i greaterOrEquals, jeśli typ właściwości nie pasuje do typu warunku, zgłaszany jest błąd. Porównywanie ciągów jest dokonywane przy użyciu . InvariantCultureIgnoreCase

W przypadku używania warunków like i notLike należy podać symbol * wieloznaczny w wartości . Wartość nie powinna mieć więcej niż jednego symbolu wieloznacznego * .

W przypadku używania warunków match i notMatch podaj , aby dopasować cyfrę, dla litery, aby dopasować dowolny znak i dowolny inny znak, aby dopasować # ten rzeczywisty ? . znak. Podczas gdy w dopasowaniach i notMatch jest uwzględniania wielkość liter, we wszystkich innych warunkach, które oceniają wartość stringValue, wielkość liter nie jest uwzględniania. Alternatywy bez uwzględniania liter są dostępne w 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 dołączaną przez wszelkie nazwy 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 jest East US 2 uznawany 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 nawiasów obsługuje nazwy tagów z interpunkcją, takimi jak łącznik, okres lub spacja.
    • Gdzie <tagName> to nazwa tagu, aby zweryfikować warunek.
    • Przykłady: tags['Acct.CostCenter'] gdzie Acct.CostCenter to nazwa tagu.
  • tags['''<tagName>''']
    • Ta składnia nawiasów obsługuje nazwy tagów, które mają apostrofy, ucieczki z podwójnymi apostrofami.
    • Gdzie ' <tagName> to nazwa tagu, dla którego ma być weryfikowany warunek.
    • Przykład: tags['''My.Apostrophe.Tag'''] gdzie "My.Apostrophe.Tag" to nazwa tagu.
  • aliasy właściwości — aby uzyskać listę, zobacz Aliasy.

Uwaga

tags.<tagName>, tags[tagName] i są nadal tags[tag.with.dots] akceptowalnymi sposobami deklarowania pola tagów. Preferowane są jednak wyrażenia wymienione powyżej.

Uwaga

W wyrażeniach pól odwołujących się [ * ] do aliasu każdy element w tablicy jest oceniany indywidualnie za pomocą elementów logicznych i między elementami. Aby uzyskać więcej informacji, zobacz Odwołania do właściwości zasobów tablicy.

Używanie tagów z parametrami

Wartość parametru może zostać przekazana do pola tagu. Przekazanie parametru do pola tagu zwiększa elastyczność definicji zasad podczas przypisywania zasad.

W poniższym przykładzie parametr jest używany do tworzenia pola tagów odnośnika dla tagu o nazwie concat wartość parametru tagName. Jeśli ten tag nie istnieje, efekt modify służy do dodawania tagu przy użyciu wartości tego samego nazwanego tagu ustawionego dla nadrzędnej grupy zasobów inspekcji zasobów przy użyciu funkcji resourcegroup() wyszukiwania.

{
    "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ściami mogą być literały, wartości parametrówlub zwracane wartości dowolnych obsługiwanych funkcji szablonu.

Ostrzeżenie

Jeśli wynikiem funkcji szablonu jest błąd, ocena zasad zakończy się niepowodzeniem. Ocena nie powiodła się, czyli niejawna odmowa. Aby uzyskać więcej informacji, zobacz unikanie błędów szablonów. Użyj trybu enforcementMode usługi DoNotEnforce, aby zapobiec wpływowi oceny, która zakończyła się niepowodzeniem, na nowe lub zaktualizowane zasoby podczas testowania i sprawdzania poprawności nowej definicji zasad.

Przykłady wartości

W tym przykładzie reguły zasad użyto wartości , aby porównać wynik funkcji i zwróconą właściwość resourceGroup() name z warunkiem like o wartości *netrg . Reguła nie zezwala na żaden zasób tego 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"
    }
}

Ta przykładowa reguła zasad używa wartości , aby sprawdzić, czy wynik wielu zagnieżdżonych funkcji jest równy true . 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 szablonu

Użycie funkcji szablonu w wartości umożliwia korzystanie z wielu złożonych zagnieżdżonych funkcji. Jeśli wynikiem funkcji szablonu jest błąd, ocena zasad zakończy się niepowodzeniem. Ocena nie powiodła się, czyli niejawna odmowa. 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"
        }
    }
}

Przykładowa reguła zasad powyżej używa substring() do porównania pierwszych trzech znaków nazwy z abc. Jeśli nazwa jest krótsza niż trzy znaki, substring() funkcja powoduje błąd. 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 zezwalania na to, aby nazwa krótsza niż trzy znaki spowodowała 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"
        }
    }
}

W przypadku poprawionej reguły zasad program sprawdza długość nazwy przed próbą uzyskania wartości o długości mniejszej if() niż trzy substring() znaki. Jeśli nazwa jest zbyt krótka, zamiast tego jest zwracana wartość "nie rozpoczynająca się od abc" i porównywana z wartością abc. Zasób o krótkiej nazwie, która nie zaczyna się od abc, nadal kończy się niepowodzeniem z regułą zasad, ale nie powoduje już błędu podczas oceny.

Liczba

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

Liczba pól

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

{
    "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 licznikiem 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 [ * ] aliasu członka tablicy count.field . Jeśli ta właściwość nie zostanie podany, wszystkie elementy członkowskie tablicy ze ścieżką "field" będą oceniane na wartość true. W tej właściwości można użyć dowolnego warunku. Operatory logiczne mogą być używane wewnątrz tej właściwości do tworzenia złożonych wymagań dotyczących oceny.
  • <condition>(wymagane): wartość jest porównywana z liczbą elementów, które spełniły wyrażenie warunku count.where. Należy użyć warunku liczbowego.

Wyrażenia liczby pól mogą wyliczyć tę samą tablicę pól maksymalnie trzy razy w jednej definicji policyRule.

Aby uzyskać więcej informacji na temat pracy z właściwościami tablicy w programie Azure Policy, w tym szczegółowe wyjaśnienie dotyczące sposobu oceniania wyrażenia liczby pól, zobacz Odwołania do właściwości zasobów tablicy.

Liczba wartości

Policz, 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 jest:

{
    "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 licznikiem wartości:

  • count.value (wymagane): tablica do oceny.
  • count.name (wymagane): nazwa indeksu składająca się z angielskich liter i cyfr. Definiuje nazwę dla wartości członka tablicy ocenianego w bieżącej iteracji. Nazwa jest używana do odwoływania się do bieżącej wartości wewnątrz count.where warunku. Opcjonalne, gdy wyrażenie count nie znajduje się w podzmieniu innego wyrażenia count. Jeśli nie zostanie podany, nazwa indeksu jest niejawnie ustawiona na "default" .
  • count.where (opcjonalnie): wyrażenie warunku do indywidualnej oceny dla każdego członka tablicy count.value . Jeśli ta właściwość nie zostanie podany, wszystkie elementy członkowskie tablicy będą obliczane na wartość true. W tej właściwości można użyć dowolnego warunku. Operatory logiczne mogą być używane wewnątrz tej właściwości do tworzenia złożonych wymagań dotyczących oceny. Do wartości aktualnie wyliczeniowego członka tablicy można uzyskać dostęp, wywołując bieżącą funkcję.
  • <condition> (wymagane): wartość jest porównywana z liczbą elementów, które spełniły count.where wyrażenie warunku. Należy użyć warunku liczbowego.

Wymuszane są następujące limity:

  • W jednej definicji policyRule można użyć maksymalnie 10 wyrażeń zliczania wartości.
  • Każde wyrażenie liczby wartości może wykonać maksymalnie 100 iteracji. Ta liczba zawiera liczbę iteracji wykonywanych przez dowolne nadrzędne wyrażenia liczby wartości.

Bieżąca funkcja

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

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 podrzędnem innego wyrażenia count. Zwraca taką samą wartość jak powyżej.

Jeśli wartość zwracana przez wywołanie jest obiektem, obsługiwane są konstruktory 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 podrzędnym wyrażeniem innej liczby. Zwraca taką samą wartość jak 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 członek 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, czy co najmniej jeden członek tablicy spełnia wyrażenie 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. Sprawdzanie, czy co najmniej jeden członek 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 funkcji wewnątrz warunków, aby uzyskać dostęp do wartości aktualnie wyliczeniowego członka current() where tablicy w funkcji szablonu. Ten warunek sprawdza, czy sieć wirtualna zawiera prefiks adresu, który nie należy do zakresu 10.0.0.0/24 CIDR.

{
    "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 funkcji wewnątrz warunków, aby uzyskać dostęp do wartości field() aktualnie where wyliczeniowego członka tablicy. Ten warunek sprawdza, czy sieć wirtualna zawiera prefiks adresu, który nie należy do zakresu 10.0.0.0/24 CIDR.

{
    "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: Sprawdź, czy nazwa zasobu pasuje do dowolnego z podanych wzorców nazw.

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

Przykład 2: Sprawdź, czy nazwa zasobu pasuje do żadnego 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 pasuje do dowolnego 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 zarezerwowane reguły sieciowej sieci są zdefiniowane w sieciowej. Właściwości zarezerwowanych reguł sieciowej grupy danych 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 efektu:

  • Dołącz: dodaje zdefiniowany zestaw pól do żądania
  • Inspekcja: generuje zdarzenie ostrzeżenia w dzienniku aktywności, ale nie kończy się niepowodzeniem żądania
  • AuditIfNotExists: generuje zdarzenie ostrzeżenia 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 celu zapewnienia zgodności z regułą zasad
  • Modyfikowanie: dodaje, aktualizuje lub usuwa zdefiniowane tagi z zasobu lub subskrypcji
  • EnforceOPAConstraint (przestarzałe): konfiguruje kontroler na danych agenta Open Policy z programem Gatekeeper v3 dla samodzielnie zarządzanych klastrów Kubernetes na platformie Azure
  • EnforceRegoPolicy (przestarzałe): konfiguruje kontroler najechań open policy agent z programem 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 Azure Policy efekty).

Funkcje zasad

Wszystkie Resource Manager szablonu 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()
  • deployment()
  • list*
  • newGuid()
  • pickZones()
  • providers()
  • reference()
  • resourceId()
  • variables()

Uwaga

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

Następująca funkcja jest dostępna do użycia w regułę zasad, ale różni się od użycia w szablonie usługi Azure Resource Manager (szablon usługi ARM):

  • utcNow()— W przeciwieństwie do szablonu usługi ARM tej właściwości można używać poza właściwością defaultValue.
    • Zwraca ciąg, który jest ustawiony na bieżącą datę i godzina w formacie DateTime uniwersalnego standardu ISO 8601. yyyy-MM-ddTHH:mm:ss.fffffffZ

Następujące funkcje są dostępne tylko w zasadach:

  • addDays(dateTime, numberOfDaysToAdd)

    • dateTime:[Required] string - String in the Universal ISO 8601 DateTime format 'yyyy-MM-ddTHH:mm:ss. FFFFFFFZ'
    • numberOfDaysToAdd:[Required] integer — liczba dni do dodania
  • field(fieldName)

    • fieldName: [Required] string — nazwa pola do pobrania
    • Zwraca wartość tego pola z zasobu, który jest oceniany przez warunek If.
    • field Jest używany głównie z auditIfNotExists i DeployIfNotExists odwołania do pól w zasobie, który jest oceniany. Przykład tego użycia można znaleźć w przykładzie DeployIfNotExists.
  • requestContext().apiVersion

    • Zwraca wersję interfejsu API żądania, która wyzwoliła ocenę zasad (przykład: 2021-09-01 ). Ta wartość to wersja interfejsu API, która była używana w żądaniu PUT/PATCH do oceny podczas tworzenia/aktualizowania zasobów. Najnowsza wersja interfejsu API jest zawsze używana podczas oceny zgodności 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)

    • range: [Required] ciąg - ciąg określający zakres adresów IP, aby sprawdzić, czy targetRange znajduje się w.
    • targetRange: ciąg [Required] — ciąg określający zakres adresów IP, które mają zostać zweryfikowane jako uwzględnione w zakresie.
    • Zwraca wartość logiczną dla tego, 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 adresy IP początku i końca (przykłady: 192.168.0.1-192.168.0.9 , 2001:0DB8::-2001:0DB8::3:FFFF )
  • current(indexName)

Przykład funkcji zasad

W tym przykładzie reguły zasad użyto funkcji resource w celu uzyskania właściwości name w połączeniu z funkcją tablicy i obiektu w celu skompilowania warunku, który wymusza nazwę zasobu, aby rozpocząć od resourceGroup nazwy grupy concat like zasobów.

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

Aliasy

Za pomocą aliasów właściwości można uzyskać dostęp 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 zasobu. Każdy alias jest mapowy 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 stale rośnie. Aby dowiedzieć się, jakie aliasy są obecnie obsługiwane przez Azure Policy, użyj jednej z następujących metod:

  • Azure Policy dla Visual Studio Code (zalecane)

    Użyj rozszerzenia Azure Policy dla Visual Studio Code, aby wyświetlać i odnajdywać aliasy właściwości zasobów.

    Zrzut ekranu przedstawiający rozszerzenie Azure Policy dla Visual Studio Code najechanie kursorem na właściwość 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 modify, użyj następującego polecenia w Azure PowerShell 4.6.0 lub wyższej:

    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 dostępne aliasy mają wersję, która jest wyświetlana jako "normalna" nazwa i inny, który [*] jest do niej dołączony. Na przykład:

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

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

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

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

Gdy są używane w warunku pola, aliasy tablicy umożliwiają porównywanie poszczególnych elementów tablicy z wartością docelową. W przypadku korzystania z wyrażenia count można:

  • Sprawdzanie rozmiaru tablicy
  • Sprawdź, czy wszystkie\njeden z elementów tablicy spełnia warunek złożony
  • Sprawdź, 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 zasobów tablicy.

Następne kroki