Regra de política de estrutura de definição do Azure Policy

A regra de política consiste em blocos if e then. No bloco if, você define uma ou mais condições que especificam quando a política é imposta. Você pode aplicar os operadores lógicos para essas condições para definir exatamente o cenário para uma política.

Para obter detalhes completos sobre cada efeito, ordem de avaliação, propriedades e exemplos, consulte Fundamentos dos efeitos das definições do Azure Policy.

No bloco then, você definirá o efeito que acontecerá quando as condições de if forem atendidas.

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

Para obter mais informações sobre policyRule, vá para o esquema de definição de política.

Operadores lógicos

Os operadores lógicos compatíveis são:

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

A sintaxe not inverte o resultado da condição. A sintaxe allOf (semelhante à operação and lógica) requer que todas as condições sejam verdadeiras. A sintaxe anyOf (semelhante à operação or lógica) requer que uma ou mais condições sejam verdadeiras.

Você pode aninhar operadores lógicos. A exemplo a seguir mostra uma operação not aninhada dentro de uma operação allOf.

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

Condições

Uma condição avalia se um valor atende a determinados critérios. As condições com suporte são:

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

Para less, lessOrEquals, greater e greaterOrEquals, se o tipo de propriedade não corresponder ao tipo de condição, um erro será gerado. As comparações de cadeias de caracteres são feitas por meio de InvariantCultureIgnoreCase.

Ao usar as condições like e notLike, você fornece um caractere curinga (*) no valor. O valor não deve ter mais de um caractere curinga.

Ao usar as condições match e notMatch, forneça uma hashtag (#) para fazer a correspondência de um dígito, o ponto de interrogação (?) para uma letra, um ponto (.) para fazer a correspondência com qualquer caractere e um outro caractere qualquer para fazer a correspondência com esse mesmo caractere. Embora match e notMatch diferenciem maiúsculas de minúsculas, todas as outras condições que avaliam um stringValue não diferenciam maiúsculas de minúsculas. Alternativas que não diferenciam maiúsculas de minúsculas estão disponíveis em matchInsensitively e notMatchInsensitively.

Fields

Condições que avaliam se os valores das propriedades na carga de solicitação de recurso atendem a determinados critérios podem ser formadas usando uma expressão field. Há suporte para os seguintes campos:

• name

• fullName

  • Retorna o nome completo do recurso. O nome completo de um recurso é o nome do recurso precedido dos nomes dos recursos pai (por exemplo, myServer/myDatabase).

• kind

• type

• location

  • Os campos de localização são normalizados para dar suporte a vários formatos. Por exemplo, East US 2 é considerado igual a eastus2.
  • Use global para recursos independentes de local.

• id

  • Retorna a ID de recurso do recurso que está sendo avaliado.
  • Exemplo: /subscriptions/11111111-1111-1111-1111-111111111111/resourceGroups/myRG/providers/Microsoft.KeyVault/vaults/myVault

• identity.type

  • Retorna o tipo de identidade gerenciada habilitada no recurso.

• tags

• tags['<tagName>']

  • Essa sintaxe de colchete dá suporte a nomes de marca que tem pontuação, como hífen, ponto ou espaço.
  • Em que tagName é o nome da marca para a qual validar a condição.
  • Exemplos: tags['Acct.CostCenter'], onde Acct.CostCenter é o nome da marca.

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

  • Essa sintaxe de colchete dá suporte a nomes de marca contendo apóstrofos, evitando os apóstrofos duplos.
  • Em que tagName é o nome da marca para a qual validar a condição.
  • Exemplo: tags['''My.Apostrophe.Tag'''], onde 'My.Apostrophe.Tag' é o nome da marca.

  Observação

  tags.<tagName>, tags[tagName], e tags[tag.with.dots] ainda são maneiras aceitáveis de declarar um campo de marcas. No entanto, as expressões preferenciais são aquelas listadas acima.

• aliases de propriedade - para obter uma lista, confira Aliases.

  Observação

  Em expressões field que se referem ao alias de matriz [*], cada elemento da matriz é avaliado individualmente com um and lógico entre os elementos. Para obter mais informações, consulte Referenciando propriedades de recurso da matriz.

As condições que usam expressões field podem substituir a sintaxe de definição de política herdada "source": "action", que costumava funcionar para operações de gravação. Por exemplo, não há mais suporte para isso:

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

Mas o comportamento desejado pode ser alcançado usando a lógica field:

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

Usar marcas com parâmetros

Um valor de parâmetro pode ser passado para um campo de marca. Passando um parâmetro para um campo de marca aumenta a flexibilidade da definição de política durante a atribuição de política.

No exemplo a seguir, concat é usado para criar uma pesquisa de campo de marcas para a marca que nomeou o valor do parâmetro tagName. Se essa marca não existir, o efeito modify será usado para adicionar a marca usando o valor da mesma marca nomeada definida no grupo de recursos pai dos recursos auditados por meio da função de pesquisa 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"
      ]
    }
  }
}

Valor

Condições que avaliam se um valor atende a determinados critérios podem ser formadas usando uma expressão value. Os valores podem ser literais, os valores dos parâmetros ou os valores retornados de qualquer função de modelo com suporte.

Exemplos de valor

Este exemplo de regra de política usa value para comparar o resultado da função resourceGroup() e a propriedade name retornada para uma condição like de *netrg. A regra nega qualquer recurso que não seja do Microsoft.Network/* type em qualquer grupo de recursos cujo nome termine com *netrg.

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

Este exemplo de regra de política usa value para verificar se o resultado de várias funções aninhadas equals true. A regra nega qualquer recurso que não tenha pelo menos três marcas.

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

Como evitar falhas de modelo

O uso de funções de modelo em value permite muitas funções aninhadas complexas. Se o resultado de uma função de modelo for um erro, a avaliação da política falhará. Uma avaliação com falha é um deny implícito. Um exemplo de um value que falha em alguns cenários:

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

A regra de política de exemplo acima usa substring() para comparar os três primeiros caracteres de name com abc. Se name for menor que três caracteres, a função substring() resultará em um erro. Esse erro faz com que a política se torne um efeito deny.

Em vez disso, use a função if() para verificar se os três primeiros caracteres do name são iguais a abc sem permitir um name menor que três caracteres cause um erro:

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

Com a regra de política revisada, if() verifica o tamanho do name antes de tentar obter uma substring() em um valor com menos de três caracteres. Se o name for muito curto, o valor "não começa com abc" será retornado e comparado com abc. Um recurso com um nome curto que não começa com abc ainda falha na regra de política, mas deixa de causar erros durante a avaliação.

Count

As condições que fazem a contagem de quantos dos membros de uma matriz atendem a certos critérios podem ser formadas usando a expressão count. Os cenários comuns são verificar se 'pelo menos um dos', 'exatamente um dos', 'todos os' ou 'nenhum dos' membros da matriz atendem à condição. O count avalia cada membro da matriz para uma expressão de condição e soma os resultados true, que é comparado ao operador de expressão.

Contagem de campos

Conta quantos membros de uma matriz no conteúdo de solicitação satisfazem a expressão da condição. A estrutura das expressões field count é:

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

As seguintes propriedades são usadas com field count:

• count.field (obrigatório): contém o caminho para a matriz e precisa ser um alias de matriz.
• count.where (opcional): a expressão de condição usada para avaliar individualmente para cada membro da matriz de alias de matriz de count.field. Se essa propriedade não for fornecida, todos os membros da matriz com o caminho igual a 'field' serão avaliados como true. Qualquer condição pode ser usada nessa propriedade. Os operadores lógicos podem ser usados nessa propriedade para criar requisitos complexos de avaliação.
• condition (obrigatório): O valor é comparado ao número de itens que atendeu à expressão de condição count.where. Uma condição numérica deve ser usada.

Para obter mais detalhes sobre como trabalhar com propriedades de matriz no Azure Policy, incluindo uma explicação detalhada sobre como a expressão field count é avaliada, consulte Referenciando propriedades de recurso da matriz.

Contagem de valor

Conte quantos membros de uma matriz atendem a uma condição. A matriz em questão pode ser uma matriz literal ou uma referência a parâmetro de matriz. A estrutura de expressões value count é:

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

As seguintes propriedades são usadas com value count:

• count.value(obrigatório): a matriz a ser avaliada.
• count.name (obrigatório): o nome do índice, composto por letras e dígitos em inglês. Define um nome para o valor do membro da matriz avaliado na iteração atual. O nome é usado para referenciar o valor atual dentro da condição count.where. Opcional quando a expressão count não está em um filho de outra expressão count. Quando não fornecido, o nome do índice é definido implicitamente como "default".
• count.where (opcional): a expressão de condição usada para avaliar individualmente para cada membro de count.value. Se essa propriedade não for fornecida, todos os membros da matriz são avaliados como true. Qualquer condição pode ser usada nessa propriedade. Os operadores lógicos podem ser usados nessa propriedade para criar requisitos complexos de avaliação. O valor do membro da matriz atualmente enumerado pode ser acessado chamando a função current.
• condition (obrigatório): O valor é comparado ao número de itens que atendeu à expressão de condição count.where. Uma condição numérica deve ser usada.

A função atual

A função current() só está disponível dentro da condição count.where. Retorna o valor do membro da matriz que está enumerado atualmente pela avaliação da expressão count.

Uso da value count

• current(<index name defined in count.name>). Por exemplo: current('arrayMember').
• current(). Permitido somente quando a expressão value count não é um filho de outra expressão count. Retorna o mesmo valor acima.

Se o valor retornado pela chamada for um objeto, os acessadores de propriedade terão suporte. Por exemplo: current('objectArrayMember').property.

Uso da field count

• current(<the array alias defined in count.field>). Por exemplo, current('Microsoft.Test/resource/enumeratedArray[*]').
• current(). Permitido somente quando a expressão field count não é um filho de outra expressão count. Retorna o mesmo valor acima.
• current(<alias of a property of the array member>). Por exemplo, current('Microsoft.Test/resource/enumeratedArray[*].property').

Exemplos de field count

Exemplo 1: verificar se uma matriz está vazia

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

Exemplo 2: verificar se apenas um membro da matriz atende à expressão de condição

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

Exemplo 3: verificar se, pelo menos, um membro da matriz atende à expressão de condição

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

Exemplo 4: verificar se todos os membros da matriz de objetos atendem à expressão de condição

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

Exemplo 5: Verificar se, pelo menos, um membro da matriz corresponde a várias propriedades na expressão de condição

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

Exemplo 6: use a função current() dentro das condições where para acessar o valor do membro da matriz atualmente enumerado em uma função de modelo. Essa condição verifica se uma rede virtual contém um prefixo de endereço que não está sob o intervalo 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
}

Exemplo 7: Use a função field() dentro das condições where para acessar o valor do membro da matriz atualmente enumerado. Essa condição verifica se uma rede virtual contém um prefixo de endereço que não está sob o intervalo 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
}

Exemplos de value count

Exemplo 1: Verifique se o nome do recurso corresponde a qualquer um dos padrões de nome determinados.

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

Exemplo 2: Verifique se o nome do recurso corresponde a qualquer um dos padrões de nome determinados. A função current() não especifica um nome de índice. O resultado é o mesmo do exemplo anterior.

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

Exemplo 3: Verifique se o nome do recurso corresponde a qualquer um dos padrões de nome fornecidos por um parâmetro de matriz.

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

Exemplo 4: Verifique se algum dos prefixos de endereço de rede virtual não está na lista de prefixos aprovados.

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

Exemplo 5: Verifique se todas as regras de NSG reservadas estão definidas em um NSG. As propriedades das regras de NSG reservadas são definidas em um parâmetro de matriz que contém objetos.

Valor do parâmetro:

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

Política:

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

Funções de política

As funções podem ser usadas para introduzir lógica adicional em uma regra de política. Eles são resolvidos dentro da regra de política de uma definição de política e em valores de parâmetro atribuídos às definições de política em uma iniciativa.

Todas as funções de modelo do Resource Manager estão disponíveis para uso em uma regra de política, exceto as seguintes funções e funções definidas pelo usuário:

• copyIndex()
• dateTimeAdd()
• dateTimeFromEpoch
• dateTimeToEpoch
• deployment()
• environment()
• extensionResourceId()
• lambda() Para obter mais informações, acesse lambda
• listAccountSas()
• listKeys()
• listSecrets()
• list*
• managementGroup()
• newGuid()
• pickZones()
• providers()
• reference()
• resourceId()
• subscriptionResourceId()
• tenantResourceId()
• tenant()
• variables()

A seguinte função está disponível para uso em uma regra de política, mas é diferente do uso em um modelo do Azure Resource Manager (modelo do ARM):

• utcNow(): Ao contrário de um modelo do ARM, esta propriedade pode ser usada fora do defaultValue.
  • Retorna uma cadeia de caracteres que é definida com a data e a hora atuais no formato DateTime Universal ISO 8601 yyyy-MM-ddTHH:mm:ss.fffffffZ.

As seguintes funções estão disponíveis apenas em regras de política:

• addDays(dateTime, numberOfDaysToAdd)

  • dateTime: string [Obrigatório] – Cadeia de caracteres no formato DateTime Universal ISO 8601 'aaaa-MM-ddTHH:mm:ss.FFFFFFFZ'
  • numberOfDaysToAdd: integer [Obrigatório] – Número de dias a serem adicionados

• field(fieldName)

  • fieldName: string [obrigatório] – O nome do field a ser recuperado
  • Retorna o valor desse campo do recurso que está sendo avaliado pela condição If.
  • field é principalmente para uso com auditIfNotExists e deployIfNotExists para referenciar campos no recurso que estão sendo avaliados. Um exemplo desse uso pode ser visto no exemplo DeployIfNotExists.

• requestContext().apiVersion

  • Retorna a versão da API da solicitação que disparou a avaliação da política (exemplo: 2021-09-01). Essa será a versão da API que foi usada na solicitação PUT/PATCH para avaliações na criação/atualização do recurso. A última versão da API é sempre usada durante a avaliação de conformidade nos recursos existentes.

• policy()

  • Retorna as informações a seguir sobre a política que está sendo avaliada. As propriedades podem ser acessadas do objeto retornado (exemplo: [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: string [Obrigatório] – Cadeia de caracteres que especifica um intervalo de endereços IP para verificar se o targetRange está contido nele.
  • targetRange: string [Obrigatório] – Cadeia de caracteres que especifica um intervalo de endereços IP a ser validado como incluído dentro de range.
  • Retorna um valor booleano para saber se o intervalo de endereços IP do range contém o intervalo de endereços IP do targetRange. Intervalos vazios ou combinação entre famílias de IP não são permitidos e resulta em falha de avaliação.

  Formatos com suporte:

  • Endereço IP único (exemplos: 10.0.0.0, 2001:0DB8::3:FFFE)
  • Intervalo CIDR (exemplos: 10.0.0.0/24, 2001:0DB8::/110)
  • Intervalo definido pelos endereços IP inicial e final (exemplos: 192.168.0.1-192.168.0.9, 2001:0DB8::-2001:0DB8::3:FFFF)

• current(indexName)

  • Função especial que só pode ser usada dentro de expressões count.

Exemplo de função de política

Este exemplo de regra de política usa a função de recurso resourceGroup para obter a propriedade name, combinada com a matriz concat e o objeto de função para criar uma condição like que impõe o nome do recurso para iniciar com o nome do grupo de recursos.

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

Limites da regra de política

Limites aplicados durante a criação

Os limites para a estrutura de regras de política são aplicados durante a criação ou atribuição de uma política. As tentativas de criar ou atribuir definições de política que excedem esses limites falharão.

Limites aplicados durante a avaliação

Limites para o tamanho de objetos que são processados por funções de política durante a avaliação da política. Esses limites nem sempre podem ser aplicados durante a criação, pois dependem do conteúdo avaliado. Por exemplo:

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

O comprimento da cadeia de caracteres criada pela função concat() depende do valor das propriedades no recurso avaliado.

Próximas etapas

• Para obter mais informações sobre a estrutura de definição de política, acesse noções básicas, parâmetros e alias.
• Para iniciativas, acesse a estrutura de definição da iniciativa.
• Examine os exemplos em Amostras do Azure Policy.
• Revisar Compreendendo os efeitos da política.
• Entenda como criar políticas de forma programática.
• Saiba como obter dados de conformidade.
• Saiba como corrigir recursos fora de conformidade.
• Veja o que é um grupo de gerenciamento com Organizar seus recursos com grupos de gerenciamento do Azure.