azure.compute.DiskPoolIscsiTarget

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

class MyStack : Stack
{
    public MyStack()
    {
        var exampleResourceGroup = new Azure.Core.ResourceGroup("exampleResourceGroup", new Azure.Core.ResourceGroupArgs
        {
            Location = "West Europe",
        });
        var exampleVirtualNetwork = new Azure.Network.VirtualNetwork("exampleVirtualNetwork", new Azure.Network.VirtualNetworkArgs
        {
            ResourceGroupName = exampleResourceGroup.Name,
            Location = exampleResourceGroup.Location,
            AddressSpaces = 
            {
                "10.0.0.0/16",
            },
        });
        var exampleSubnet = new Azure.Network.Subnet("exampleSubnet", new Azure.Network.SubnetArgs
        {
            ResourceGroupName = exampleResourceGroup.Name,
            VirtualNetworkName = exampleVirtualNetwork.Name,
            AddressPrefixes = 
            {
                "10.0.0.0/24",
            },
            Delegations = 
            {
                new Azure.Network.Inputs.SubnetDelegationArgs
                {
                    Name = "diskspool",
                    ServiceDelegation = new Azure.Network.Inputs.SubnetDelegationServiceDelegationArgs
                    {
                        Actions = 
                        {
                            "Microsoft.Network/virtualNetworks/read",
                        },
                        Name = "Microsoft.StoragePool/diskPools",
                    },
                },
            },
        });
        var exampleDiskPool = new Azure.Compute.DiskPool("exampleDiskPool", new Azure.Compute.DiskPoolArgs
        {
            ResourceGroupName = exampleResourceGroup.Name,
            Location = exampleResourceGroup.Location,
            SubnetId = exampleSubnet.Id,
            Zones = 
            {
                "1",
            },
            SkuName = "Basic_B1",
        });
        var exampleManagedDisk = new Azure.Compute.ManagedDisk("exampleManagedDisk", new Azure.Compute.ManagedDiskArgs
        {
            ResourceGroupName = exampleResourceGroup.Name,
            Location = exampleResourceGroup.Location,
            CreateOption = "Empty",
            StorageAccountType = "Premium_LRS",
            DiskSizeGb = 4,
            MaxShares = 2,
            Zones = 
            {
                "1",
            },
        });
        var exampleServicePrincipal = Output.Create(AzureAD.GetServicePrincipal.InvokeAsync(new AzureAD.GetServicePrincipalArgs
        {
            DisplayName = "StoragePool Resource Provider",
        }));
        var roles = 
        {
            "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 Azure.Authorization.AssignmentArgs
            {
                PrincipalId = exampleServicePrincipal.Apply(exampleServicePrincipal => exampleServicePrincipal.Id),
                RoleDefinitionName = roles[range.Value],
                Scope = exampleManagedDisk.Id,
            }));
        }
        var exampleDiskPoolManagedDiskAttachment = new Azure.Compute.DiskPoolManagedDiskAttachment("exampleDiskPoolManagedDiskAttachment", new Azure.Compute.DiskPoolManagedDiskAttachmentArgs
        {
            DiskPoolId = exampleDiskPool.Id,
            ManagedDiskId = exampleManagedDisk.Id,
        }, new CustomResourceOptions
        {
            DependsOn = 
            {
                exampleAssignment,
            },
        });
        var exampleDiskPoolIscsiTarget = new Azure.Compute.DiskPoolIscsiTarget("exampleDiskPoolIscsiTarget", new Azure.Compute.DiskPoolIscsiTargetArgs
        {
            AclMode = "Dynamic",
            DisksPoolId = exampleDiskPool.Id,
            TargetIqn = "iqn.2021-11.com.microsoft:test",
        }, new CustomResourceOptions
        {
            DependsOn = 
            {
                exampleDiskPoolManagedDiskAttachment,
            },
        });
    }

}

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,
    zones: ["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],
});

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,
    zones=["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]))