azure.compute.DiskPoolIscsiTarget

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

const exampleResourceGroup = new azure.core.ResourceGroup("example", {
    name: "example",
    location: "West Europe",
});
const exampleVirtualNetwork = new azure.network.VirtualNetwork("example", {
    name: "example-network",
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    addressSpaces: ["10.0.0.0/16"],
});
const exampleSubnet = new azure.network.Subnet("example", {
    name: "example-subnet",
    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("example", {
    name: "example-pool",
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    subnetId: exampleSubnet.id,
    zones: ["1"],
    skuName: "Basic_B1",
});
const exampleManagedDisk = new azure.compute.ManagedDisk("example", {
    name: "example-disk",
    resourceGroupName: exampleResourceGroup.name,
    location: exampleResourceGroup.location,
    createOption: "Empty",
    storageAccountType: "Premium_LRS",
    diskSizeGb: 4,
    maxShares: 2,
    zone: "1",
});
const example = 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(`example-${range.value}`, {
        principalId: example.then(example => example.id),
        roleDefinitionName: roles[range.value],
        scope: exampleManagedDisk.id,
    }));
}
const exampleDiskPoolManagedDiskAttachment = new azure.compute.DiskPoolManagedDiskAttachment("example", {
    diskPoolId: exampleDiskPool.id,
    managedDiskId: exampleManagedDisk.id,
});
const exampleDiskPoolIscsiTarget = new azure.compute.DiskPoolIscsiTarget("example", {
    name: "example",
    aclMode: "Dynamic",
    disksPoolId: exampleDiskPool.id,
    targetIqn: "iqn.2021-11.com.microsoft:test",
});

import pulumi
import pulumi_azure as azure
import pulumi_azuread as azuread

example_resource_group = azure.core.ResourceGroup("example",
    name="example",
    location="West Europe")
example_virtual_network = azure.network.VirtualNetwork("example",
    name="example-network",
    resource_group_name=example_resource_group.name,
    location=example_resource_group.location,
    address_spaces=["10.0.0.0/16"])
example_subnet = azure.network.Subnet("example",
    name="example-subnet",
    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("example",
    name="example-pool",
    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("example",
    name="example-disk",
    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 = 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"example-{range['value']}",
        principal_id=example.id,
        role_definition_name=roles[range["value"]],
        scope=example_managed_disk.id))
example_disk_pool_managed_disk_attachment = azure.compute.DiskPoolManagedDiskAttachment("example",
    disk_pool_id=example_disk_pool.id,
    managed_disk_id=example_managed_disk.id)
example_disk_pool_iscsi_target = azure.compute.DiskPoolIscsiTarget("example",
    name="example",
    acl_mode="Dynamic",
    disks_pool_id=example_disk_pool.id,
    target_iqn="iqn.2021-11.com.microsoft:test")

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, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("example"),
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleVirtualNetwork, err := network.NewVirtualNetwork(ctx, "example", &network.VirtualNetworkArgs{
			Name:              pulumi.String("example-network"),
			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, "example", &network.SubnetArgs{
			Name:               pulumi.String("example-subnet"),
			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, "example", &compute.DiskPoolArgs{
			Name:              pulumi.String("example-pool"),
			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, "example", &compute.ManagedDiskArgs{
			Name:               pulumi.String("example-disk"),
			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
		}
		example, 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("example-%v", key0), &authorization.AssignmentArgs{
				PrincipalId:        pulumi.String(example.Id),
				RoleDefinitionName: roles[val0],
				Scope:              exampleManagedDisk.ID(),
			})
			if err != nil {
				return err
			}
			exampleAssignment = append(exampleAssignment, __res)
		}
		_, err = compute.NewDiskPoolManagedDiskAttachment(ctx, "example", &compute.DiskPoolManagedDiskAttachmentArgs{
			DiskPoolId:    exampleDiskPool.ID(),
			ManagedDiskId: exampleManagedDisk.ID(),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewDiskPoolIscsiTarget(ctx, "example", &compute.DiskPoolIscsiTargetArgs{
			Name:        pulumi.String("example"),
			AclMode:     pulumi.String("Dynamic"),
			DisksPoolId: exampleDiskPool.ID(),
			TargetIqn:   pulumi.String("iqn.2021-11.com.microsoft:test"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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("example", new()
    {
        Name = "example",
        Location = "West Europe",
    });

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

    var exampleSubnet = new Azure.Network.Subnet("example", new()
    {
        Name = "example-subnet",
        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("example", new()
    {
        Name = "example-pool",
        ResourceGroupName = exampleResourceGroup.Name,
        Location = exampleResourceGroup.Location,
        SubnetId = exampleSubnet.Id,
        Zones = new[]
        {
            "1",
        },
        SkuName = "Basic_B1",
    });

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

    var example = 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($"example-{range.Value}", new()
        {
            PrincipalId = example.Apply(getServicePrincipalResult => getServicePrincipalResult.Id),
            RoleDefinitionName = roles[range.Value],
            Scope = exampleManagedDisk.Id,
        }));
    }
    var exampleDiskPoolManagedDiskAttachment = new Azure.Compute.DiskPoolManagedDiskAttachment("example", new()
    {
        DiskPoolId = exampleDiskPool.Id,
        ManagedDiskId = exampleManagedDisk.Id,
    });

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

});

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.codegen.internal.KeyedValue;
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()        
            .name("example")
            .location("West Europe")
            .build());

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

        var exampleSubnet = new Subnet("exampleSubnet", SubnetArgs.builder()        
            .name("example-subnet")
            .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()        
            .name("example-pool")
            .resourceGroupName(exampleResourceGroup.name())
            .location(exampleResourceGroup.location())
            .subnetId(exampleSubnet.id())
            .zones("1")
            .skuName("Basic_B1")
            .build());

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

        final var example = 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(example.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());

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

    }
}

var diskPoolIscsiTargetResource = new Azure.Compute.DiskPoolIscsiTarget("diskPoolIscsiTargetResource", new()
{
    AclMode = "string",
    DisksPoolId = "string",
    Name = "string",
    TargetIqn = "string",
});

example, err := compute.NewDiskPoolIscsiTarget(ctx, "diskPoolIscsiTargetResource", &compute.DiskPoolIscsiTargetArgs{
	AclMode:     pulumi.String("string"),
	DisksPoolId: pulumi.String("string"),
	Name:        pulumi.String("string"),
	TargetIqn:   pulumi.String("string"),
})

var diskPoolIscsiTargetResource = new DiskPoolIscsiTarget("diskPoolIscsiTargetResource", DiskPoolIscsiTargetArgs.builder()        
    .aclMode("string")
    .disksPoolId("string")
    .name("string")
    .targetIqn("string")
    .build());

disk_pool_iscsi_target_resource = azure.compute.DiskPoolIscsiTarget("diskPoolIscsiTargetResource",
    acl_mode="string",
    disks_pool_id="string",
    name="string",
    target_iqn="string")

const diskPoolIscsiTargetResource = new azure.compute.DiskPoolIscsiTarget("diskPoolIscsiTargetResource", {
    aclMode: "string",
    disksPoolId: "string",
    name: "string",
    targetIqn: "string",
});

type: azure:compute:DiskPoolIscsiTarget
properties:
    aclMode: string
    disksPoolId: string
    name: string
    targetIqn: string