Reguła zasad struktury definicji usługi Azure Policy

Reguła zasad składa się z bloków if i then . W bloku zdefiniujesz if co najmniej jeden warunek określający, kiedy zasady są wymuszane. Aby dokładnie zdefiniować scenariusz zasad, do warunków można zastosować operatory logiczne.

Aby uzyskać szczegółowe informacje na temat każdego efektu, kolejności oceny, właściwości i przykładów, zobacz Podstawy efektu definicji usługi Azure Policy.

W bloku zdefiniujesz efekt, który występuje po spełnieniu then if warunków.

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

Aby uzyskać więcej informacji na temat zasadRule, przejdź do schematu definicji zasad.

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 not odwraca wynik warunku. Składnia (podobna allOf do operacji logicznej and ) wymaga spełnienia wszystkich warunków. Składnia (podobna anyOf do operacji logicznej or ) wymaga, aby co najmniej jeden warunek był spełniony.

Operatory logiczne można zagnieżdżać. W poniższym przykładzie pokazano operację not zagnieżdżona w ramach allOf operacji.

"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 less, lessOrEquals, greateri greaterOrEquals, jeśli typ właściwości nie jest zgodny z typem warunku, zgłaszany jest błąd. Porównania ciągów są wykonywane przy użyciu polecenia InvariantCultureIgnoreCase.

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

W przypadku korzystania z match warunków i notMatch podaj hasztag (#), aby dopasować cyfrę, znak zapytania (?) dla litery i kropkę (.), aby dopasować dowolny znak i dowolny inny znak, aby dopasować ten rzeczywisty znak. Chociaż match i notMatch są uwzględniane wielkość liter, wszystkie inne warunki, które oceniają stringValue , są bez uwzględniania wielkości liter. Alternatywy bez uwzględniania wielkości liter są dostępne w usługach 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 field wyrażenia. Obsługiwane są następujące pola:

• name

• fullName

  • Zwraca pełną nazwę zasobu. Pełną nazwą zasobu jest nazwa zasobu poprzedzona wszelkimi 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 wartość jest uznawana za równą eastus2.
  • Użyj globalnego dla zasobów, które są niezależne od lokalizacji.

• id

  • Zwraca identyfikator zasobu, który jest obliczany.
  • Przykład: /subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myRG/providers/Microsoft.KeyVault/vaults/myVault

• identity.type

  • Zwraca typ tożsamości zarządzanej włączonej w zasobie.

• tags

• tags['<tagName>']

  • Ta składnia nawiasu obsługuje nazwy tagów, które mają znaki interpunkcyjne, takie jak łącznik, kropka lub spacja.
  • Gdzie tagName to nazwa tagu do zweryfikowania warunku.
  • Przykłady: tags['Acct.CostCenter'] gdzie Acct.CostCenter to nazwa tagu.

• tags['''<tagName>''']

  • Ta składnia nawiasu obsługuje nazwy tagów, które mają w nim apostrofy, uciekając z podwójnymi apostrofami.
  • Gdzie tagName to nazwa tagu do zweryfikowania warunku.
  • Przykład: tags['''My.Apostrophe.Tag'''] gdzie 'My.Apostrophe.Tag' to nazwa tagu.

  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.

• aliasy właściwości — aby uzyskać listę, zobacz Aliasy.

  Uwaga

  W field wyrażeniach odwołujące się do aliasu [*] tablicy każdy element w tablicy jest obliczany indywidualnie z logicznymi and między elementami. Aby uzyskać więcej informacji, zobacz Odwoływanie się do właściwości zasobu tablicy.

Warunki używające field wyrażeń mogą zastąpić starszą składnię "source": "action"definicji zasad , która służy do pracy na potrzeby operacji zapisu. Na przykład nie jest to już obsługiwane:

{
  "source": "action",
  "like": "Microsoft.Network/publicIPAddresses/*"
}

Jednak żądane zachowanie można osiągnąć przy użyciu field logiki:

{
  "field": "type",
  "equals": "Microsoft.Network/publicIPAddresses"
}

Używanie tagów z parametrami

Wartość parametru można przekazać do pola tagu. Przekazanie 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, modify efekt jest używany do dodawania tagu przy użyciu wartości tego samego nazwanego tagu ustawionego na przeprowadź inspekcję nadrzędnej grupy zasobów 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 value wyrażenia. 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 zakończy się niepowodzeniem. Ocena nieudana jest niejawną denywartością . Aby uzyskać więcej informacji, zobacz Unikanie błędów szablonów. Użyj funkcji enforcementMode , doNotEnforce aby zapobiec wpływowi oceny niepowodzenia na nowe lub zaktualizowane zasoby podczas testowania i weryfikowania nowej definicji zasad.

Przykłady wartości

Ten przykład reguły zasad używa value metody do porównania wyniku resourceGroup() funkcji i zwróconej name właściwości z like warunkiem *netrg. Reguła odrzuca żaden zasób nie w Microsoft.Network/* type ż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 value metody do sprawdzania, czy wynik wielu zagnieżdżonych funkcji equals 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 szablonów

Korzystanie z funkcji szablonu w programie value umożliwia korzystanie z wielu złożonych funkcji zagnieżdżonych. Jeśli wynikiem funkcji szablonu jest błąd, ocena zasad zakończy się niepowodzeniem. Ocena nieudana jest niejawną denywartością . Przykład błędu value 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 podciągów(), aby porównać pierwsze trzy znaki z name wartością abc. Jeśli name funkcja jest krótsza niż trzy znaki, substring() funkcja powoduje wystąpienie błędu. Ten błąd powoduje, że zasady staną się deny efektem.

Zamiast tego użyj funkcji if(), aby sprawdzić, czy pierwsze trzy znaki równe abc bez zezwolenia name na krótsze niż trzy znaki name powodują 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 if() zasad sprawdza długość name przed próbą uzyskania substring() wartości o mniejszej niż trzy znaki. Jeśli name wartość jest zbyt krótka, wartość "nie zaczyna się od abc" jest zwracana zamiast tego i porównywana z wartością 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.

Count

Warunki, które zliczą, ile elementów członkowskich tablicy spełnia określone kryteria, można utworzyć przy użyciu count wyrażenia. 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. field count Struktura wyrażeń 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 field countprogramem :

• count.field (wymagane): zawiera ścieżkę do tablicy i musi być aliasem tablicy.
• count.where(opcjonalnie): Wyrażenie warunku do indywidualnej oceny dla każdej tablicy aliasowej składowej tablicy .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. Dowolny warunek może być używany wewnątrz tej właściwości. Operatory logiczne mogą być używane wewnątrz tej właściwości w celu utworzenia złożonych wymagań dotyczących oceny.
• condition (wymagane): wartość jest porównywana z liczbą elementów, które spełniają count.where wyrażenie warunku. Należy użyć warunku liczbowego.

Aby uzyskać więcej informacji na temat sposobu pracy z właściwościami tablicy w usłudze Azure Policy, w tym szczegółowym wyjaśnieniem sposobu field count obliczania wyrażenia, zobacz Referencing array resource properties (Odwoływanie się do właściwości zasobu 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. value count Struktura wyrażeń 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 value countprogramem :

• count.value (wymagane): tablica do oceny.
• count.name (wymagane): nazwa indeksu składająca się z angielskich liter i cyfr. 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 count wyrażenie nie znajduje się w elemecie podrzędnym innego count wyrażenia. Jeśli nie zostanie podana, nazwa indeksu jest niejawnie ustawiona na "default".
• count.where(opcjonalnie): wyrażenie warunku do indywidualnej oceny 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. Dowolny warunek może być używany wewnątrz tej właściwości. Operatory logiczne mogą być używane wewnątrz tej właściwości w celu utworzenia złożonych wymagań dotyczących oceny. Dostęp do wartości aktualnie wyliczanego elementu członkowskiego tablicy można uzyskać, wywołując bieżącą funkcję.
• condition (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 count ocenę wyrażenia.

Użycie liczby wartości

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

Jeśli wartość zwracana 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 field count wyrażenie nie jest elementem podrzędnym innego count wyrażenia. 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. Sprawdź, czy co najmniej 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 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 where warunków, aby uzyskać dostęp do wartości aktualnie wyliczanej składowej 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 where warunków, aby uzyskać dostęp do wartości aktualnie wyliczonego elementu członkowskiego 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: Sprawdź, 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. Sprawdź, 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
  }
]

Zasady:

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

Funkcje zasad

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

Wszystkie funkcje szablonu usługi 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()
• dateTimeFromEpoch
• dateTimeToEpoch
• deployment()
• environment()
• extensionResourceId()
• lambda() Aby uzyskać więcej informacji, przejdź do usługi lambda
• listAccountSas()
• listKeys()
• listSecrets()
• list*
• managementGroup()
• newGuid()
• pickZones()
• providers()
• reference()
• resourceId()
• subscriptionResourceId()
• tenantResourceId()
• tenant()
• variables()

Uwaga

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

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 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: [Required] string - String in the Universal ISO 8601 DateTime format 'yyyy-MM-ddTHH:mm:ss. FFFFFFFZ'
  • numberOfDaysToAdd: [Wymagane] liczba całkowita — liczba dni do dodania

• field(fieldName)

  • fieldName: [Wymagany] ciąg — nazwa pola do pobrania
  • Zwraca wartość tego pola z zasobu obliczanego przez warunek If.
  • field jest używany głównie z polami auditIfNotExists i deployIfNotExists do odwołujących się do zasobów, 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 w istniejących zasobach.

• 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/11111111-1111-1111-1111-111111111111/providers/Microsoft.Authorization/policyAssignments/myAssignment",
      "definitionId": "/providers/Microsoft.Authorization/policyDefinitions/34c877ad-507e-4c82-993e-3452a6e0ad3c",
      "setDefinitionId": "/providers/Microsoft.Authorization/policySetDefinitions/42a694ed-f65e-42b2-aa9e-8052e9740a92",
      "definitionReferenceId": "StorageAccountNetworkACLs"
    }
    

• ipRangeContains(range, targetRange)

  • range: [Wymagany] ciąg — ciąg określający zakres adresów IP, aby sprawdzić, czy element targetRange znajduje się w obrębie .
  • targetRange: [Wymagany] ciąg — 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)

  • Funkcja specjalna, która może być używana tylko wewnątrz wyrażeń liczbowych.

Przykład funkcji zasad

Ten przykład reguły zasad używa resourceGroup funkcji zasobów do pobrania name właściwości 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 if warunku	4096
Wyrażenia warunku w then bloku	128	Dotyczy zasad existenceCondition 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(....)]"
Field count wyrażenia na tablicę	5
Value count wyrażenia na regułę zasad	10
Value count liczba iteracji wyrażeń	100	W przypadku wyrażeń zagnieżdżonych Value count 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. Na 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, staną się zasadami deny 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ć.

Następne kroki

• Aby uzyskać więcej informacji na temat struktury definicji zasad, przejdź do podstawowych informacji, parametrów i aliasów.
• W przypadku inicjatyw przejdź do struktury definicji inicjatywy.
• Zapoznaj się z przykładami w przykładach usługi Azure Policy.
• Przejrzyj wyjaśnienie działania zasad.
• Dowiedz się, jak programowo tworzyć zasady.
• Dowiedz się, jak uzyskać dane zgodności.
• Dowiedz się, jak korygować niezgodne zasoby.
• Sprawdź, co to jest grupa zarządzania za pomocą funkcji Organizowanie zasobów przy użyciu grup zarządzania platformy Azure.