azure.policy.Assignment

using Pulumi;
using Azure = Pulumi.Azure;

class MyStack : Stack
{
    public MyStack()
    {
        var exampleDefinition = new Azure.Policy.Definition("exampleDefinition", new Azure.Policy.DefinitionArgs
        {
            PolicyType = "Custom",
            Mode = "All",
            DisplayName = "my-policy-definition",
            PolicyRule = @"	{
    ""if"": {
      ""not"": {
        ""field"": ""location"",
        ""in"": ""[parameters('allowedLocations')]""
      }
    },
    ""then"": {
      ""effect"": ""audit""
    }
  }
",
            Parameters = @"	{
    ""allowedLocations"": {
      ""type"": ""Array"",
      ""metadata"": {
        ""description"": ""The list of allowed locations for resources."",
        ""displayName"": ""Allowed locations"",
        ""strongType"": ""location""
      }
    }
  }
",
        });
        var exampleResourceGroup = new Azure.Core.ResourceGroup("exampleResourceGroup", new Azure.Core.ResourceGroupArgs
        {
            Location = "West Europe",
        });
        var exampleAssignment = new Azure.Policy.Assignment("exampleAssignment", new Azure.Policy.AssignmentArgs
        {
            Scope = exampleResourceGroup.Id,
            PolicyDefinitionId = exampleDefinition.Id,
            Description = "Policy Assignment created via an Acceptance Test",
            DisplayName = "My Example Policy Assignment",
            Metadata = @"    {
    ""category"": ""General""
    }
",
            Parameters = @"{
  ""allowedLocations"": {
    ""value"": [ ""West Europe"" ]
  }
}
",
        });
    }

}

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/policy"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleDefinition, err := policy.NewDefinition(ctx, "exampleDefinition", &policy.DefinitionArgs{
			PolicyType:  pulumi.String("Custom"),
			Mode:        pulumi.String("All"),
			DisplayName: pulumi.String("my-policy-definition"),
			PolicyRule: pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v", "	{\n", "    \"if\": {\n", "      \"not\": {\n", "        \"field\": \"location\",\n", "        \"in\": \"[parameters('allowedLocations')]\"\n", "      }\n", "    },\n", "    \"then\": {\n", "      \"effect\": \"audit\"\n", "    }\n", "  }\n")),
			Parameters: pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v", "	{\n", "    \"allowedLocations\": {\n", "      \"type\": \"Array\",\n", "      \"metadata\": {\n", "        \"description\": \"The list of allowed locations for resources.\",\n", "        \"displayName\": \"Allowed locations\",\n", "        \"strongType\": \"location\"\n", "      }\n", "    }\n", "  }\n")),
		})
		if err != nil {
			return err
		}
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		_, err = policy.NewAssignment(ctx, "exampleAssignment", &policy.AssignmentArgs{
			Scope:              exampleResourceGroup.ID(),
			PolicyDefinitionId: exampleDefinition.ID(),
			Description:        pulumi.String("Policy Assignment created via an Acceptance Test"),
			DisplayName:        pulumi.String("My Example Policy Assignment"),
			Metadata:           pulumi.String(fmt.Sprintf("%v%v%v", "    {\n", "    \"category\": \"General\"\n", "    }\n")),
			Parameters:         pulumi.String(fmt.Sprintf("%v%v%v%v%v", "{\n", "  \"allowedLocations\": {\n", "    \"value\": [ \"West Europe\" ]\n", "  }\n", "}\n")),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";

const exampleDefinition = new azure.policy.Definition("exampleDefinition", {
    policyType: "Custom",
    mode: "All",
    displayName: "my-policy-definition",
    policyRule: `	{
    "if": {
      "not": {
        "field": "location",
        "in": "[parameters('allowedLocations')]"
      }
    },
    "then": {
      "effect": "audit"
    }
  }
`,
    parameters: `	{
    "allowedLocations": {
      "type": "Array",
      "metadata": {
        "description": "The list of allowed locations for resources.",
        "displayName": "Allowed locations",
        "strongType": "location"
      }
    }
  }
`,
});
const exampleResourceGroup = new azure.core.ResourceGroup("exampleResourceGroup", {location: "West Europe"});
const exampleAssignment = new azure.policy.Assignment("exampleAssignment", {
    scope: exampleResourceGroup.id,
    policyDefinitionId: exampleDefinition.id,
    description: "Policy Assignment created via an Acceptance Test",
    displayName: "My Example Policy Assignment",
    metadata: `    {
    "category": "General"
    }
`,
    parameters: `{
  "allowedLocations": {
    "value": [ "West Europe" ]
  }
}
`,
});

import pulumi
import pulumi_azure as azure

example_definition = azure.policy.Definition("exampleDefinition",
    policy_type="Custom",
    mode="All",
    display_name="my-policy-definition",
    policy_rule="""	{
    "if": {
      "not": {
        "field": "location",
        "in": "[parameters('allowedLocations')]"
      }
    },
    "then": {
      "effect": "audit"
    }
  }
""",
    parameters="""	{
    "allowedLocations": {
      "type": "Array",
      "metadata": {
        "description": "The list of allowed locations for resources.",
        "displayName": "Allowed locations",
        "strongType": "location"
      }
    }
  }
""")
example_resource_group = azure.core.ResourceGroup("exampleResourceGroup", location="West Europe")
example_assignment = azure.policy.Assignment("exampleAssignment",
    scope=example_resource_group.id,
    policy_definition_id=example_definition.id,
    description="Policy Assignment created via an Acceptance Test",
    display_name="My Example Policy Assignment",
    metadata="""    {
    "category": "General"
    }
""",
    parameters="""{
  "allowedLocations": {
    "value": [ "West Europe" ]
  }
}
""")