azure.compute.DiskPoolIscsiTargetLun

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

return await Deployment.RunAsync(() => 
{
    var exampleResourceGroup = new Azure.Core.ResourceGroup("exampleResourceGroup", new()
    {
        Location = "West Europe",
    });

    var exampleVirtualNetwork = new Azure.Network.VirtualNetwork("exampleVirtualNetwork", new()
    {
        ResourceGroupName = exampleResourceGroup.Name,
        Location = exampleResourceGroup.Location,
        AddressSpaces = new[]
        {
            "10.0.0.0/16",
        },
    });

    var exampleSubnet = new Azure.Network.Subnet("exampleSubnet", new()
    {
        ResourceGroupName = exampleResourceGroup.Name,
        VirtualNetworkName = exampleVirtualNetwork.Name,
        AddressPrefixes = new[]
        {
            "10.0.0.0/24",
        },
        Delegations = new[]
        {
            new Azure.Network.Inputs.SubnetDelegationArgs
            {
                Name = "diskspool",
                ServiceDelegation = new Azure.Network.Inputs.SubnetDelegationServiceDelegationArgs
                {
                    Actions = new[]
                    {
                        "Microsoft.Network/virtualNetworks/read",
                    },
                    Name = "Microsoft.StoragePool/diskPools",
                },
            },
        },
    });

    var exampleDiskPool = new Azure.Compute.DiskPool("exampleDiskPool", new()
    {
        ResourceGroupName = exampleResourceGroup.Name,
        Location = exampleResourceGroup.Location,
        SubnetId = exampleSubnet.Id,
        Zones = new[]
        {
            "1",
        },
        SkuName = "Basic_B1",
    });

    var exampleManagedDisk = new Azure.Compute.ManagedDisk("exampleManagedDisk", new()
    {
        ResourceGroupName = exampleResourceGroup.Name,
        Location = exampleResourceGroup.Location,
        CreateOption = "Empty",
        StorageAccountType = "Premium_LRS",
        DiskSizeGb = 4,
        MaxShares = 2,
        Zone = "1",
    });

    var exampleServicePrincipal = AzureAD.GetServicePrincipal.Invoke(new()
    {
        DisplayName = "StoragePool Resource Provider",
    });

    var roles = new[]
    {
        "Disk Pool Operator",
        "Virtual Machine Contributor",
    };

    var exampleAssignment = new List<Azure.Authorization.Assignment>();
    for (var rangeIndex = 0; rangeIndex < roles.Length; rangeIndex++)
    {
        var range = new { Value = rangeIndex };
        exampleAssignment.Add(new Azure.Authorization.Assignment($"exampleAssignment-{range.Value}", new()
        {
            PrincipalId = exampleServicePrincipal.Apply(getServicePrincipalResult => getServicePrincipalResult.Id),
            RoleDefinitionName = roles[range.Value],
            Scope = exampleManagedDisk.Id,
        }));
    }
    var exampleDiskPoolManagedDiskAttachment = new Azure.Compute.DiskPoolManagedDiskAttachment("exampleDiskPoolManagedDiskAttachment", new()
    {
        DiskPoolId = exampleDiskPool.Id,
        ManagedDiskId = exampleManagedDisk.Id,
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            exampleAssignment,
        },
    });

    var exampleDiskPoolIscsiTarget = new Azure.Compute.DiskPoolIscsiTarget("exampleDiskPoolIscsiTarget", new()
    {
        AclMode = "Dynamic",
        DisksPoolId = exampleDiskPool.Id,
        TargetIqn = "iqn.2021-11.com.microsoft:test",
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            exampleDiskPoolManagedDiskAttachment,
        },
    });

    var exampleDiskPoolIscsiTargetLun = new Azure.Compute.DiskPoolIscsiTargetLun("exampleDiskPoolIscsiTargetLun", new()
    {
        IscsiTargetId = exampleDiskPoolIscsiTarget.Id,
        DiskPoolManagedDiskAttachmentId = exampleDiskPoolManagedDiskAttachment.Id,
    });

});

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/authorization"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/compute"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/network"
	"github.com/pulumi/pulumi-azuread/sdk/v5/go/azuread"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleVirtualNetwork, err := network.NewVirtualNetwork(ctx, "exampleVirtualNetwork", &network.VirtualNetworkArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			AddressSpaces: pulumi.StringArray{
				pulumi.String("10.0.0.0/16"),
			},
		})
		if err != nil {
			return err
		}
		exampleSubnet, err := network.NewSubnet(ctx, "exampleSubnet", &network.SubnetArgs{
			ResourceGroupName:  exampleResourceGroup.Name,
			VirtualNetworkName: exampleVirtualNetwork.Name,
			AddressPrefixes: pulumi.StringArray{
				pulumi.String("10.0.0.0/24"),
			},
			Delegations: network.SubnetDelegationArray{
				&network.SubnetDelegationArgs{
					Name: pulumi.String("diskspool"),
					ServiceDelegation: &network.SubnetDelegationServiceDelegationArgs{
						Actions: pulumi.StringArray{
							pulumi.String("Microsoft.Network/virtualNetworks/read"),
						},
						Name: pulumi.String("Microsoft.StoragePool/diskPools"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		exampleDiskPool, err := compute.NewDiskPool(ctx, "exampleDiskPool", &compute.DiskPoolArgs{
			ResourceGroupName: exampleResourceGroup.Name,
			Location:          exampleResourceGroup.Location,
			SubnetId:          exampleSubnet.ID(),
			Zones: pulumi.StringArray{
				pulumi.String("1"),
			},
			SkuName: pulumi.String("Basic_B1"),
		})
		if err != nil {
			return err
		}
		exampleManagedDisk, err := compute.NewManagedDisk(ctx, "exampleManagedDisk", &compute.ManagedDiskArgs{
			ResourceGroupName:  exampleResourceGroup.Name,
			Location:           exampleResourceGroup.Location,
			CreateOption:       pulumi.String("Empty"),
			StorageAccountType: pulumi.String("Premium_LRS"),
			DiskSizeGb:         pulumi.Int(4),
			MaxShares:          pulumi.Int(2),
			Zone:               pulumi.String("1"),
		})
		if err != nil {
			return err
		}
		exampleServicePrincipal, err := azuread.LookupServicePrincipal(ctx, &azuread.LookupServicePrincipalArgs{
			DisplayName: pulumi.StringRef("StoragePool Resource Provider"),
		}, nil)
		if err != nil {
			return err
		}
		roles := []string{
			"Disk Pool Operator",
			"Virtual Machine Contributor",
		}
		var exampleAssignment []*authorization.Assignment
		for index := 0; index < len(roles); index++ {
			key0 := index
			val0 := index
			__res, err := authorization.NewAssignment(ctx, fmt.Sprintf("exampleAssignment-%v", key0), &authorization.AssignmentArgs{
				PrincipalId:        *pulumi.String(exampleServicePrincipal.Id),
				RoleDefinitionName: roles[val0],
				Scope:              exampleManagedDisk.ID(),
			})
			if err != nil {
				return err
			}
			exampleAssignment = append(exampleAssignment, __res)
		}
		exampleDiskPoolManagedDiskAttachment, err := compute.NewDiskPoolManagedDiskAttachment(ctx, "exampleDiskPoolManagedDiskAttachment", &compute.DiskPoolManagedDiskAttachmentArgs{
			DiskPoolId:    exampleDiskPool.ID(),
			ManagedDiskId: exampleManagedDisk.ID(),
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleAssignment,
		}))
		if err != nil {
			return err
		}
		exampleDiskPoolIscsiTarget, err := compute.NewDiskPoolIscsiTarget(ctx, "exampleDiskPoolIscsiTarget", &compute.DiskPoolIscsiTargetArgs{
			AclMode:     pulumi.String("Dynamic"),
			DisksPoolId: exampleDiskPool.ID(),
			TargetIqn:   pulumi.String("iqn.2021-11.com.microsoft:test"),
		}, pulumi.DependsOn([]pulumi.Resource{
			exampleDiskPoolManagedDiskAttachment,
		}))
		if err != nil {
			return err
		}
		_, err = compute.NewDiskPoolIscsiTargetLun(ctx, "exampleDiskPoolIscsiTargetLun", &compute.DiskPoolIscsiTargetLunArgs{
			IscsiTargetId:                   exampleDiskPoolIscsiTarget.ID(),
			DiskPoolManagedDiskAttachmentId: exampleDiskPoolManagedDiskAttachment.ID(),
		})
		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.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.network.VirtualNetwork;
import com.pulumi.azure.network.VirtualNetworkArgs;
import com.pulumi.azure.network.Subnet;
import com.pulumi.azure.network.SubnetArgs;
import com.pulumi.azure.network.inputs.SubnetDelegationArgs;
import com.pulumi.azure.network.inputs.SubnetDelegationServiceDelegationArgs;
import com.pulumi.azure.compute.DiskPool;
import com.pulumi.azure.compute.DiskPoolArgs;
import com.pulumi.azure.compute.ManagedDisk;
import com.pulumi.azure.compute.ManagedDiskArgs;
import com.pulumi.azuread.AzureadFunctions;
import com.pulumi.azuread.inputs.GetServicePrincipalArgs;
import com.pulumi.azure.authorization.Assignment;
import com.pulumi.azure.authorization.AssignmentArgs;
import com.pulumi.azure.compute.DiskPoolManagedDiskAttachment;
import com.pulumi.azure.compute.DiskPoolManagedDiskAttachmentArgs;
import com.pulumi.azure.compute.DiskPoolIscsiTarget;
import com.pulumi.azure.compute.DiskPoolIscsiTargetArgs;
import com.pulumi.azure.compute.DiskPoolIscsiTargetLun;
import com.pulumi.azure.compute.DiskPoolIscsiTargetLunArgs;
import com.pulumi.codegen.internal.KeyedValue;
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) {
        var exampleResourceGroup = new ResourceGroup("exampleResourceGroup", ResourceGroupArgs.builder()        
            .location("West Europe")
            .build());

        var exampleVirtualNetwork = new VirtualNetwork("exampleVirtualNetwork", VirtualNetworkArgs.builder()        
            .resourceGroupName(exampleResourceGroup.name())
            .location(exampleResourceGroup.location())
            .addressSpaces("10.0.0.0/16")
            .build());

        var exampleSubnet = new Subnet("exampleSubnet", SubnetArgs.builder()        
            .resourceGroupName(exampleResourceGroup.name())
            .virtualNetworkName(exampleVirtualNetwork.name())
            .addressPrefixes("10.0.0.0/24")
            .delegations(SubnetDelegationArgs.builder()
                .name("diskspool")
                .serviceDelegation(SubnetDelegationServiceDelegationArgs.builder()
                    .actions("Microsoft.Network/virtualNetworks/read")
                    .name("Microsoft.StoragePool/diskPools")
                    .build())
                .build())
            .build());

        var exampleDiskPool = new DiskPool("exampleDiskPool", DiskPoolArgs.builder()        
            .resourceGroupName(exampleResourceGroup.name())
            .location(exampleResourceGroup.location())
            .subnetId(exampleSubnet.id())
            .zones("1")
            .skuName("Basic_B1")
            .build());

        var exampleManagedDisk = new ManagedDisk("exampleManagedDisk", ManagedDiskArgs.builder()        
            .resourceGroupName(exampleResourceGroup.name())
            .location(exampleResourceGroup.location())
            .createOption("Empty")
            .storageAccountType("Premium_LRS")
            .diskSizeGb(4)
            .maxShares(2)
            .zone("1")
            .build());

        final var exampleServicePrincipal = AzureadFunctions.getServicePrincipal(GetServicePrincipalArgs.builder()
            .displayName("StoragePool Resource Provider")
            .build());

        final var roles =         
            "Disk Pool Operator",
            "Virtual Machine Contributor";

        for (var i = 0; i < roles.length(); i++) {
            new Assignment("exampleAssignment-" + i, AssignmentArgs.builder()            
                .principalId(exampleServicePrincipal.applyValue(getServicePrincipalResult -> getServicePrincipalResult.id()))
                .roleDefinitionName(roles[range.value()])
                .scope(exampleManagedDisk.id())
                .build());

        
}
        var exampleDiskPoolManagedDiskAttachment = new DiskPoolManagedDiskAttachment("exampleDiskPoolManagedDiskAttachment", DiskPoolManagedDiskAttachmentArgs.builder()        
            .diskPoolId(exampleDiskPool.id())
            .managedDiskId(exampleManagedDisk.id())
            .build(), CustomResourceOptions.builder()
                .dependsOn(exampleAssignment)
                .build());

        var exampleDiskPoolIscsiTarget = new DiskPoolIscsiTarget("exampleDiskPoolIscsiTarget", DiskPoolIscsiTargetArgs.builder()        
            .aclMode("Dynamic")
            .disksPoolId(exampleDiskPool.id())
            .targetIqn("iqn.2021-11.com.microsoft:test")
            .build(), CustomResourceOptions.builder()
                .dependsOn(exampleDiskPoolManagedDiskAttachment)
                .build());

        var exampleDiskPoolIscsiTargetLun = new DiskPoolIscsiTargetLun("exampleDiskPoolIscsiTargetLun", DiskPoolIscsiTargetLunArgs.builder()        
            .iscsiTargetId(exampleDiskPoolIscsiTarget.id())
            .diskPoolManagedDiskAttachmentId(exampleDiskPoolManagedDiskAttachment.id())
            .build());

    }
}

import pulumi
import pulumi_azure as azure
import pulumi_azuread as azuread

example_resource_group = azure.core.ResourceGroup("exampleResourceGroup", location="West Europe")
example_virtual_network = azure.network.VirtualNetwork("exampleVirtualNetwork",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    address_spaces=["10.0.0.0/16"])
example_subnet = azure.network.Subnet("exampleSubnet",
    resource_group_name=example_resource_group.name,
    virtual_network_name=example_virtual_network.name,
    address_prefixes=["10.0.0.0/24"],
    delegations=[azure.network.SubnetDelegationArgs(
        name="diskspool",
        service_delegation=azure.network.SubnetDelegationServiceDelegationArgs(
            actions=["Microsoft.Network/virtualNetworks/read"],
            name="Microsoft.StoragePool/diskPools",
        ),
    )])
example_disk_pool = azure.compute.DiskPool("exampleDiskPool",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    subnet_id=example_subnet.id,
    zones=["1"],
    sku_name="Basic_B1")
example_managed_disk = azure.compute.ManagedDisk("exampleManagedDisk",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    create_option="Empty",
    storage_account_type="Premium_LRS",
    disk_size_gb=4,
    max_shares=2,
    zone="1")
example_service_principal = azuread.get_service_principal(display_name="StoragePool Resource Provider")
roles = [
    "Disk Pool Operator",
    "Virtual Machine Contributor",
]
example_assignment = []
for range in [{"value": i} for i in range(0, len(roles))]:
    example_assignment.append(azure.authorization.Assignment(f"exampleAssignment-{range['value']}",
        principal_id=example_service_principal.id,
        role_definition_name=roles[range["value"]],
        scope=example_managed_disk.id))
example_disk_pool_managed_disk_attachment = azure.compute.DiskPoolManagedDiskAttachment("exampleDiskPoolManagedDiskAttachment",
    disk_pool_id=example_disk_pool.id,
    managed_disk_id=example_managed_disk.id,
    opts=pulumi.ResourceOptions(depends_on=[example_assignment]))
example_disk_pool_iscsi_target = azure.compute.DiskPoolIscsiTarget("exampleDiskPoolIscsiTarget",
    acl_mode="Dynamic",
    disks_pool_id=example_disk_pool.id,
    target_iqn="iqn.2021-11.com.microsoft:test",
    opts=pulumi.ResourceOptions(depends_on=[example_disk_pool_managed_disk_attachment]))
example_disk_pool_iscsi_target_lun = azure.compute.DiskPoolIscsiTargetLun("exampleDiskPoolIscsiTargetLun",
    iscsi_target_id=example_disk_pool_iscsi_target.id,
    disk_pool_managed_disk_attachment_id=example_disk_pool_managed_disk_attachment.id)

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

const exampleResourceGroup = new azure.core.ResourceGroup("exampleResourceGroup", {location: "West Europe"});
const exampleVirtualNetwork = new azure.network.VirtualNetwork("exampleVirtualNetwork", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    addressSpaces: ["10.0.0.0/16"],
});
const exampleSubnet = new azure.network.Subnet("exampleSubnet", {
    resourceGroupName: exampleResourceGroup.name,
    virtualNetworkName: exampleVirtualNetwork.name,
    addressPrefixes: ["10.0.0.0/24"],
    delegations: [{
        name: "diskspool",
        serviceDelegation: {
            actions: ["Microsoft.Network/virtualNetworks/read"],
            name: "Microsoft.StoragePool/diskPools",
        },
    }],
});
const exampleDiskPool = new azure.compute.DiskPool("exampleDiskPool", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    subnetId: exampleSubnet.id,
    zones: ["1"],
    skuName: "Basic_B1",
});
const exampleManagedDisk = new azure.compute.ManagedDisk("exampleManagedDisk", {
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    createOption: "Empty",
    storageAccountType: "Premium_LRS",
    diskSizeGb: 4,
    maxShares: 2,
    zone: "1",
});
const exampleServicePrincipal = azuread.getServicePrincipal({
    displayName: "StoragePool Resource Provider",
});
const roles = [
    "Disk Pool Operator",
    "Virtual Machine Contributor",
];
const exampleAssignment: azure.authorization.Assignment[] = [];
for (const range = {value: 0}; range.value < roles.length; range.value++) {
    exampleAssignment.push(new azure.authorization.Assignment(`exampleAssignment-${range.value}`, {
        principalId: exampleServicePrincipal.then(exampleServicePrincipal => exampleServicePrincipal.id),
        roleDefinitionName: roles[range.value],
        scope: exampleManagedDisk.id,
    }));
}
const exampleDiskPoolManagedDiskAttachment = new azure.compute.DiskPoolManagedDiskAttachment("exampleDiskPoolManagedDiskAttachment", {
    diskPoolId: exampleDiskPool.id,
    managedDiskId: exampleManagedDisk.id,
}, {
    dependsOn: [exampleAssignment],
});
const exampleDiskPoolIscsiTarget = new azure.compute.DiskPoolIscsiTarget("exampleDiskPoolIscsiTarget", {
    aclMode: "Dynamic",
    disksPoolId: exampleDiskPool.id,
    targetIqn: "iqn.2021-11.com.microsoft:test",
}, {
    dependsOn: [exampleDiskPoolManagedDiskAttachment],
});
const exampleDiskPoolIscsiTargetLun = new azure.compute.DiskPoolIscsiTargetLun("exampleDiskPoolIscsiTargetLun", {
    iscsiTargetId: exampleDiskPoolIscsiTarget.id,
    diskPoolManagedDiskAttachmentId: exampleDiskPoolManagedDiskAttachment.id,
});