azure.blueprint.Assignment

using Pulumi;
using Azure = Pulumi.Azure;

class MyStack : Stack
{
    public MyStack()
    {
        var current = Output.Create(Azure.Core.GetClientConfig.InvokeAsync());
        var exampleSubscription = Output.Create(Azure.Core.GetSubscription.InvokeAsync());
        var exampleDefinition = exampleSubscription.Apply(exampleSubscription => Output.Create(Azure.Blueprint.GetDefinition.InvokeAsync(new Azure.Blueprint.GetDefinitionArgs
        {
            Name = "exampleBlueprint",
            ScopeId = exampleSubscription.Id,
        })));
        var examplePublishedVersion = Output.Tuple(exampleDefinition, exampleDefinition).Apply(values =>
        {
            var exampleDefinition = values.Item1;
            var exampleDefinition1 = values.Item2;
            return Output.Create(Azure.Blueprint.GetPublishedVersion.InvokeAsync(new Azure.Blueprint.GetPublishedVersionArgs
            {
                ScopeId = exampleDefinition.ScopeId,
                BlueprintName = exampleDefinition1.Name,
                Version = "v1.0.0",
            }));
        });
        var exampleResourceGroup = new Azure.Core.ResourceGroup("exampleResourceGroup", new Azure.Core.ResourceGroupArgs
        {
            Location = "West Europe",
            Tags = 
            {
                { "Environment", "example" },
            },
        });
        var exampleUserAssignedIdentity = new Azure.Authorization.UserAssignedIdentity("exampleUserAssignedIdentity", new Azure.Authorization.UserAssignedIdentityArgs
        {
            ResourceGroupName = exampleResourceGroup.Name,
            Location = exampleResourceGroup.Location,
        });
        var @operator = new Azure.Authorization.Assignment("operator", new Azure.Authorization.AssignmentArgs
        {
            Scope = exampleSubscription.Apply(exampleSubscription => exampleSubscription.Id),
            RoleDefinitionName = "Blueprint Operator",
            PrincipalId = exampleUserAssignedIdentity.PrincipalId,
        });
        var owner = new Azure.Authorization.Assignment("owner", new Azure.Authorization.AssignmentArgs
        {
            Scope = exampleSubscription.Apply(exampleSubscription => exampleSubscription.Id),
            RoleDefinitionName = "Owner",
            PrincipalId = exampleUserAssignedIdentity.PrincipalId,
        });
        var exampleAssignment = new Azure.Blueprint.Assignment("exampleAssignment", new Azure.Blueprint.AssignmentArgs
        {
            TargetSubscriptionId = exampleSubscription.Apply(exampleSubscription => exampleSubscription.Id),
            VersionId = examplePublishedVersion.Apply(examplePublishedVersion => examplePublishedVersion.Id),
            Location = exampleResourceGroup.Location,
            LockMode = "AllResourcesDoNotDelete",
            LockExcludePrincipals = 
            {
                current.Apply(current => current.ObjectId),
            },
            Identity = new Azure.Blueprint.Inputs.AssignmentIdentityArgs
            {
                Type = "UserAssigned",
                IdentityIds = 
                {
                    exampleUserAssignedIdentity.Id,
                },
            },
            ResourceGroups = @"    {
      ""ResourceGroup"": {
        ""name"": ""exampleRG-bp""
      }
    }
",
            ParameterValues = @"    {
      ""allowedlocationsforresourcegroups_listOfAllowedLocations"": {
        ""value"": [""westus"", ""westus2"", ""eastus"", ""centralus"", ""centraluseuap"", ""southcentralus"", ""northcentralus"", ""westcentralus"", ""eastus2"", ""eastus2euap"", ""brazilsouth"", ""brazilus"", ""northeurope"", ""westeurope"", ""eastasia"", ""southeastasia"", ""japanwest"", ""japaneast"", ""koreacentral"", ""koreasouth"", ""indiasouth"", ""indiawest"", ""indiacentral"", ""australiaeast"", ""australiasoutheast"", ""canadacentral"", ""canadaeast"", ""uknorth"", ""uksouth2"", ""uksouth"", ""ukwest"", ""francecentral"", ""francesouth"", ""australiacentral"", ""australiacentral2"", ""uaecentral"", ""uaenorth"", ""southafricanorth"", ""southafricawest"", ""switzerlandnorth"", ""switzerlandwest"", ""germanynorth"", ""germanywestcentral"", ""norwayeast"", ""norwaywest""]
      }
    }
",
        }, new CustomResourceOptions
        {
            DependsOn = 
            {
                @operator,
                owner,
            },
        });
    }

}

package main

import (
	"fmt"

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		current, err := core.GetClientConfig(ctx, nil, nil)
		if err != nil {
			return err
		}
		exampleSubscription, err := core.LookupSubscription(ctx, nil, nil)
		if err != nil {
			return err
		}
		exampleDefinition, err := blueprint.GetDefinition(ctx, &blueprint.GetDefinitionArgs{
			Name:    "exampleBlueprint",
			ScopeId: exampleSubscription.Id,
		}, nil)
		if err != nil {
			return err
		}
		examplePublishedVersion, err := blueprint.GetPublishedVersion(ctx, &blueprint.GetPublishedVersionArgs{
			ScopeId:       exampleDefinition.ScopeId,
			BlueprintName: exampleDefinition.Name,
			Version:       "v1.0.0",
		}, nil)
		if err != nil {
			return err
		}
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West Europe"),
			Tags: pulumi.StringMap{
				"Environment": pulumi.String("example"),
			},
		})
		if err != nil {
			return err
		}
		exampleUserAssignedIdentity, err := authorization.NewUserAssignedIdentity(ctx, "exampleUserAssignedIdentity", &authorization.UserAssignedIdentityArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
		})
		if err != nil {
			return err
		}
		operator, err := authorization.NewAssignment(ctx, "operator", &authorization.AssignmentArgs{
			Scope:              pulumi.String(exampleSubscription.Id),
			RoleDefinitionName: pulumi.String("Blueprint Operator"),
			PrincipalId:        exampleUserAssignedIdentity.PrincipalId,
		})
		if err != nil {
			return err
		}
		owner, err := authorization.NewAssignment(ctx, "owner", &authorization.AssignmentArgs{
			Scope:              pulumi.String(exampleSubscription.Id),
			RoleDefinitionName: pulumi.String("Owner"),
			PrincipalId:        exampleUserAssignedIdentity.PrincipalId,
		})
		if err != nil {
			return err
		}
		_, err = blueprint.NewAssignment(ctx, "exampleAssignment", &blueprint.AssignmentArgs{
			TargetSubscriptionId: pulumi.String(exampleSubscription.Id),
			VersionId:            pulumi.String(examplePublishedVersion.Id),
			Location:             exampleResourceGroup.Location,
			LockMode:             pulumi.String("AllResourcesDoNotDelete"),
			LockExcludePrincipals: pulumi.StringArray{
				pulumi.String(current.ObjectId),
			},
			Identity: &blueprint.AssignmentIdentityArgs{
				Type: pulumi.String("UserAssigned"),
				IdentityIds: pulumi.StringArray{
					exampleUserAssignedIdentity.ID(),
				},
			},
			ResourceGroups:  pulumi.String(fmt.Sprintf("%v%v%v%v%v", "    {\n", "      \"ResourceGroup\": {\n", "        \"name\": \"exampleRG-bp\"\n", "      }\n", "    }\n")),
			ParameterValues: pulumi.String(fmt.Sprintf("%v%v%v%v%v", "    {\n", "      \"allowedlocationsforresourcegroups_listOfAllowedLocations\": {\n", "        \"value\": [\"westus\", \"westus2\", \"eastus\", \"centralus\", \"centraluseuap\", \"southcentralus\", \"northcentralus\", \"westcentralus\", \"eastus2\", \"eastus2euap\", \"brazilsouth\", \"brazilus\", \"northeurope\", \"westeurope\", \"eastasia\", \"southeastasia\", \"japanwest\", \"japaneast\", \"koreacentral\", \"koreasouth\", \"indiasouth\", \"indiawest\", \"indiacentral\", \"australiaeast\", \"australiasoutheast\", \"canadacentral\", \"canadaeast\", \"uknorth\", \"uksouth2\", \"uksouth\", \"ukwest\", \"francecentral\", \"francesouth\", \"australiacentral\", \"australiacentral2\", \"uaecentral\", \"uaenorth\", \"southafricanorth\", \"southafricawest\", \"switzerlandnorth\", \"switzerlandwest\", \"germanynorth\", \"germanywestcentral\", \"norwayeast\", \"norwaywest\"]\n", "      }\n", "    }\n")),
		}, pulumi.DependsOn([]pulumi.Resource{
			operator,
			owner,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

const current = azure.core.getClientConfig({});
const exampleSubscription = azure.core.getSubscription({});
const exampleDefinition = exampleSubscription.then(exampleSubscription => azure.blueprint.getDefinition({
    name: "exampleBlueprint",
    scopeId: exampleSubscription.id,
}));
const examplePublishedVersion = Promise.all([exampleDefinition, exampleDefinition]).then(([exampleDefinition, exampleDefinition1]) => azure.blueprint.getPublishedVersion({
    scopeId: exampleDefinition.scopeId,
    blueprintName: exampleDefinition1.name,
    version: "v1.0.0",
}));
const exampleResourceGroup = new azure.core.ResourceGroup("exampleResourceGroup", {
    location: "West Europe",
    tags: {
        Environment: "example",
    },
});
const exampleUserAssignedIdentity = new azure.authorization.UserAssignedIdentity("exampleUserAssignedIdentity", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
});
const operator = new azure.authorization.Assignment("operator", {
    scope: exampleSubscription.then(exampleSubscription => exampleSubscription.id),
    roleDefinitionName: "Blueprint Operator",
    principalId: exampleUserAssignedIdentity.principalId,
});
const owner = new azure.authorization.Assignment("owner", {
    scope: exampleSubscription.then(exampleSubscription => exampleSubscription.id),
    roleDefinitionName: "Owner",
    principalId: exampleUserAssignedIdentity.principalId,
});
const exampleAssignment = new azure.blueprint.Assignment("exampleAssignment", {
    targetSubscriptionId: exampleSubscription.then(exampleSubscription => exampleSubscription.id),
    versionId: examplePublishedVersion.then(examplePublishedVersion => examplePublishedVersion.id),
    location: exampleResourceGroup.location,
    lockMode: "AllResourcesDoNotDelete",
    lockExcludePrincipals: [current.then(current => current.objectId)],
    identity: {
        type: "UserAssigned",
        identityIds: [exampleUserAssignedIdentity.id],
    },
    resourceGroups: `    {
      "ResourceGroup": {
        "name": "exampleRG-bp"
      }
    }
`,
    parameterValues: `    {
      "allowedlocationsforresourcegroups_listOfAllowedLocations": {
        "value": ["westus", "westus2", "eastus", "centralus", "centraluseuap", "southcentralus", "northcentralus", "westcentralus", "eastus2", "eastus2euap", "brazilsouth", "brazilus", "northeurope", "westeurope", "eastasia", "southeastasia", "japanwest", "japaneast", "koreacentral", "koreasouth", "indiasouth", "indiawest", "indiacentral", "australiaeast", "australiasoutheast", "canadacentral", "canadaeast", "uknorth", "uksouth2", "uksouth", "ukwest", "francecentral", "francesouth", "australiacentral", "australiacentral2", "uaecentral", "uaenorth", "southafricanorth", "southafricawest", "switzerlandnorth", "switzerlandwest", "germanynorth", "germanywestcentral", "norwayeast", "norwaywest"]
      }
    }
`,
}, {
    dependsOn: [
        operator,
        owner,
    ],
});

import pulumi
import pulumi_azure as azure

current = azure.core.get_client_config()
example_subscription = azure.core.get_subscription()
example_definition = azure.blueprint.get_definition(name="exampleBlueprint",
    scope_id=example_subscription.id)
example_published_version = azure.blueprint.get_published_version(scope_id=example_definition.scope_id,
    blueprint_name=example_definition.name,
    version="v1.0.0")
example_resource_group = azure.core.ResourceGroup("exampleResourceGroup",
    location="West Europe",
    tags={
        "Environment": "example",
    })
example_user_assigned_identity = azure.authorization.UserAssignedIdentity("exampleUserAssignedIdentity",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location)
operator = azure.authorization.Assignment("operator",
    scope=example_subscription.id,
    role_definition_name="Blueprint Operator",
    principal_id=example_user_assigned_identity.principal_id)
owner = azure.authorization.Assignment("owner",
    scope=example_subscription.id,
    role_definition_name="Owner",
    principal_id=example_user_assigned_identity.principal_id)
example_assignment = azure.blueprint.Assignment("exampleAssignment",
    target_subscription_id=example_subscription.id,
    version_id=example_published_version.id,
    location=example_resource_group.location,
    lock_mode="AllResourcesDoNotDelete",
    lock_exclude_principals=[current.object_id],
    identity=azure.blueprint.AssignmentIdentityArgs(
        type="UserAssigned",
        identity_ids=[example_user_assigned_identity.id],
    ),
    resource_groups="""    {
      "ResourceGroup": {
        "name": "exampleRG-bp"
      }
    }
""",
    parameter_values="""    {
      "allowedlocationsforresourcegroups_listOfAllowedLocations": {
        "value": ["westus", "westus2", "eastus", "centralus", "centraluseuap", "southcentralus", "northcentralus", "westcentralus", "eastus2", "eastus2euap", "brazilsouth", "brazilus", "northeurope", "westeurope", "eastasia", "southeastasia", "japanwest", "japaneast", "koreacentral", "koreasouth", "indiasouth", "indiawest", "indiacentral", "australiaeast", "australiasoutheast", "canadacentral", "canadaeast", "uknorth", "uksouth2", "uksouth", "ukwest", "francecentral", "francesouth", "australiacentral", "australiacentral2", "uaecentral", "uaenorth", "southafricanorth", "southafricawest", "switzerlandnorth", "switzerlandwest", "germanynorth", "germanywestcentral", "norwayeast", "norwaywest"]
      }
    }
""",
    opts=pulumi.ResourceOptions(depends_on=[
            operator,
            owner,
        ]))