azure.blueprint.Assignment

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;

return await Deployment.RunAsync(() => 
{
    var current = Azure.Core.GetClientConfig.Invoke();

    var exampleSubscription = Azure.Core.GetSubscription.Invoke();

    var exampleDefinition = Azure.Blueprint.GetDefinition.Invoke(new()
    {
        Name = "exampleBlueprint",
        ScopeId = exampleSubscription.Apply(getSubscriptionResult => getSubscriptionResult.Id),
    });

    var examplePublishedVersion = Azure.Blueprint.GetPublishedVersion.Invoke(new()
    {
        ScopeId = exampleDefinition.Apply(getDefinitionResult => getDefinitionResult.ScopeId),
        BlueprintName = exampleDefinition.Apply(getDefinitionResult => getDefinitionResult.Name),
        Version = "v1.0.0",
    });

    var exampleResourceGroup = new Azure.Core.ResourceGroup("exampleResourceGroup", new()
    {
        Location = "West Europe",
        Tags = 
        {
            { "Environment", "example" },
        },
    });

    var exampleUserAssignedIdentity = new Azure.Authorization.UserAssignedIdentity("exampleUserAssignedIdentity", new()
    {
        ResourceGroupName = exampleResourceGroup.Name,
        Location = exampleResourceGroup.Location,
    });

    var @operator = new Azure.Authorization.Assignment("operator", new()
    {
        Scope = exampleSubscription.Apply(getSubscriptionResult => getSubscriptionResult.Id),
        RoleDefinitionName = "Blueprint Operator",
        PrincipalId = exampleUserAssignedIdentity.PrincipalId,
    });

    var owner = new Azure.Authorization.Assignment("owner", new()
    {
        Scope = exampleSubscription.Apply(getSubscriptionResult => getSubscriptionResult.Id),
        RoleDefinitionName = "Owner",
        PrincipalId = exampleUserAssignedIdentity.PrincipalId,
    });

    var exampleAssignment = new Azure.Blueprint.Assignment("exampleAssignment", new()
    {
        TargetSubscriptionId = exampleSubscription.Apply(getSubscriptionResult => getSubscriptionResult.Id),
        VersionId = examplePublishedVersion.Apply(getPublishedVersionResult => getPublishedVersionResult.Id),
        Location = exampleResourceGroup.Location,
        LockMode = "AllResourcesDoNotDelete",
        LockExcludePrincipals = new[]
        {
            current.Apply(getClientConfigResult => getClientConfigResult.ObjectId),
        },
        Identity = new Azure.Blueprint.Inputs.AssignmentIdentityArgs
        {
            Type = "UserAssigned",
            IdentityIds = new[]
            {
                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 = new[]
        {
            @operator,
            owner,
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/authorization"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/blueprint"
	"github.com/pulumi/pulumi-azure/sdk/v5/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(`    {
      "ResourceGroup": {
        "name": "exampleRG-bp"
      }
    }
`),
			ParameterValues: pulumi.String(`    {
      "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"]
      }
    }
`),
		}, pulumi.DependsOn([]pulumi.Resource{
			operator,
			owner,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.CoreFunctions;
import com.pulumi.azure.core.inputs.GetSubscriptionArgs;
import com.pulumi.azure.blueprint.BlueprintFunctions;
import com.pulumi.azure.blueprint.inputs.GetDefinitionArgs;
import com.pulumi.azure.blueprint.inputs.GetPublishedVersionArgs;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.authorization.UserAssignedIdentity;
import com.pulumi.azure.authorization.UserAssignedIdentityArgs;
import com.pulumi.azure.authorization.Assignment;
import com.pulumi.azure.authorization.AssignmentArgs;
import com.pulumi.azure.blueprint.Assignment;
import com.pulumi.azure.blueprint.AssignmentArgs;
import com.pulumi.azure.blueprint.inputs.AssignmentIdentityArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        final var current = CoreFunctions.getClientConfig();

        final var exampleSubscription = CoreFunctions.getSubscription();

        final var exampleDefinition = BlueprintFunctions.getDefinition(GetDefinitionArgs.builder()
            .name("exampleBlueprint")
            .scopeId(exampleSubscription.applyValue(getSubscriptionResult -> getSubscriptionResult.id()))
            .build());

        final var examplePublishedVersion = BlueprintFunctions.getPublishedVersion(GetPublishedVersionArgs.builder()
            .scopeId(exampleDefinition.applyValue(getDefinitionResult -> getDefinitionResult.scopeId()))
            .blueprintName(exampleDefinition.applyValue(getDefinitionResult -> getDefinitionResult.name()))
            .version("v1.0.0")
            .build());

        var exampleResourceGroup = new ResourceGroup("exampleResourceGroup", ResourceGroupArgs.builder()        
            .location("West Europe")
            .tags(Map.of("Environment", "example"))
            .build());

        var exampleUserAssignedIdentity = new UserAssignedIdentity("exampleUserAssignedIdentity", UserAssignedIdentityArgs.builder()        
            .resourceGroupName(exampleResourceGroup.name())
            .location(exampleResourceGroup.location())
            .build());

        var operator = new Assignment("operator", AssignmentArgs.builder()        
            .scope(exampleSubscription.applyValue(getSubscriptionResult -> getSubscriptionResult.id()))
            .roleDefinitionName("Blueprint Operator")
            .principalId(exampleUserAssignedIdentity.principalId())
            .build());

        var owner = new Assignment("owner", AssignmentArgs.builder()        
            .scope(exampleSubscription.applyValue(getSubscriptionResult -> getSubscriptionResult.id()))
            .roleDefinitionName("Owner")
            .principalId(exampleUserAssignedIdentity.principalId())
            .build());

        var exampleAssignment = new Assignment("exampleAssignment", AssignmentArgs.builder()        
            .targetSubscriptionId(exampleSubscription.applyValue(getSubscriptionResult -> getSubscriptionResult.id()))
            .versionId(examplePublishedVersion.applyValue(getPublishedVersionResult -> getPublishedVersionResult.id()))
            .location(exampleResourceGroup.location())
            .lockMode("AllResourcesDoNotDelete")
            .lockExcludePrincipals(current.applyValue(getClientConfigResult -> getClientConfigResult.objectId()))
            .identity(AssignmentIdentityArgs.builder()
                .type("UserAssigned")
                .identityIds(exampleUserAssignedIdentity.id())
                .build())
            .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"]
      }
    }
            """)
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    operator,
                    owner)
                .build());

    }
}

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,
        ]))

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,
    ],
});

resources:
  exampleResourceGroup:
    type: azure:core:ResourceGroup
    properties:
      location: West Europe
      tags:
        Environment: example
  exampleUserAssignedIdentity:
    type: azure:authorization:UserAssignedIdentity
    properties:
      resourceGroupName: ${exampleResourceGroup.name}
      location: ${exampleResourceGroup.location}
  operator:
    type: azure:authorization:Assignment
    properties:
      scope: ${exampleSubscription.id}
      roleDefinitionName: Blueprint Operator
      principalId: ${exampleUserAssignedIdentity.principalId}
  owner:
    type: azure:authorization:Assignment
    properties:
      scope: ${exampleSubscription.id}
      roleDefinitionName: Owner
      principalId: ${exampleUserAssignedIdentity.principalId}
  exampleAssignment:
    type: azure:blueprint:Assignment
    properties:
      targetSubscriptionId: ${exampleSubscription.id}
      versionId: ${examplePublishedVersion.id}
      location: ${exampleResourceGroup.location}
      lockMode: AllResourcesDoNotDelete
      lockExcludePrincipals:
        - ${current.objectId}
      identity:
        type: UserAssigned
        identityIds:
          - ${exampleUserAssignedIdentity.id}
      resourceGroups: |2
            {
              "ResourceGroup": {
                "name": "exampleRG-bp"
              }
            }
      parameterValues: |2
            {
              "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"]
              }
            }
    options:
      dependson:
        - ${operator}
        - ${owner}
variables:
  current:
    fn::invoke:
      Function: azure:core:getClientConfig
      Arguments: {}
  exampleSubscription:
    fn::invoke:
      Function: azure:core:getSubscription
      Arguments: {}
  exampleDefinition:
    fn::invoke:
      Function: azure:blueprint:getDefinition
      Arguments:
        name: exampleBlueprint
        scopeId: ${exampleSubscription.id}
  examplePublishedVersion:
    fn::invoke:
      Function: azure:blueprint:getPublishedVersion
      Arguments:
        scopeId: ${exampleDefinition.scopeId}
        blueprintName: ${exampleDefinition.name}
        version: v1.0.0