pulumi-azure-kotlin/com.pulumi.azure.compute.kotlin/ManagedDisk

ManagedDisk

class ManagedDisk : KotlinCustomResource

Manages a managed disk.

Example Usage

With Create Empty

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
const example = new azure.core.ResourceGroup("example", {
    name: "example-resources",
    location: "West Europe",
});
const exampleManagedDisk = new azure.compute.ManagedDisk("example", {
    name: "acctestmd",
    location: example.location,
    resourceGroupName: example.name,
    storageAccountType: "Standard_LRS",
    createOption: "Empty",
    diskSizeGb: 1,
    tags: {
        environment: "staging",
    },
});

import pulumi
import pulumi_azure as azure
example = azure.core.ResourceGroup("example",
    name="example-resources",
    location="West Europe")
example_managed_disk = azure.compute.ManagedDisk("example",
    name="acctestmd",
    location=example.location,
    resource_group_name=example.name,
    storage_account_type="Standard_LRS",
    create_option="Empty",
    disk_size_gb=1,
    tags={
        "environment": "staging",
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;
return await Deployment.RunAsync(() =>
{
    var example = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "example-resources",
        Location = "West Europe",
    });
    var exampleManagedDisk = new Azure.Compute.ManagedDisk("example", new()
    {
        Name = "acctestmd",
        Location = example.Location,
        ResourceGroupName = example.Name,
        StorageAccountType = "Standard_LRS",
        CreateOption = "Empty",
        DiskSizeGb = 1,
        Tags =
        {
            { "environment", "staging" },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/compute"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("example-resources"),
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewManagedDisk(ctx, "example", &compute.ManagedDiskArgs{
			Name:               pulumi.String("acctestmd"),
			Location:           example.Location,
			ResourceGroupName:  example.Name,
			StorageAccountType: pulumi.String("Standard_LRS"),
			CreateOption:       pulumi.String("Empty"),
			DiskSizeGb:         pulumi.Int(1),
			Tags: pulumi.StringMap{
				"environment": pulumi.String("staging"),
			},
		})
		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.compute.ManagedDisk;
import com.pulumi.azure.compute.ManagedDiskArgs;
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 example = new ResourceGroup("example", ResourceGroupArgs.builder()
            .name("example-resources")
            .location("West Europe")
            .build());
        var exampleManagedDisk = new ManagedDisk("exampleManagedDisk", ManagedDiskArgs.builder()
            .name("acctestmd")
            .location(example.location())
            .resourceGroupName(example.name())
            .storageAccountType("Standard_LRS")
            .createOption("Empty")
            .diskSizeGb(1)
            .tags(Map.of("environment", "staging"))
            .build());
    }
}

resources:
  example:
    type: azure:core:ResourceGroup
    properties:
      name: example-resources
      location: West Europe
  exampleManagedDisk:
    type: azure:compute:ManagedDisk
    name: example
    properties:
      name: acctestmd
      location: ${example.location}
      resourceGroupName: ${example.name}
      storageAccountType: Standard_LRS
      createOption: Empty
      diskSizeGb: '1'
      tags:
        environment: staging

With Create Copy

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
const example = new azure.core.ResourceGroup("example", {
    name: "example-resources",
    location: "West Europe",
});
const source = new azure.compute.ManagedDisk("source", {
    name: "acctestmd1",
    location: example.location,
    resourceGroupName: example.name,
    storageAccountType: "Standard_LRS",
    createOption: "Empty",
    diskSizeGb: 1,
    tags: {
        environment: "staging",
    },
});
const copy = new azure.compute.ManagedDisk("copy", {
    name: "acctestmd2",
    location: example.location,
    resourceGroupName: example.name,
    storageAccountType: "Standard_LRS",
    createOption: "Copy",
    sourceResourceId: source.id,
    diskSizeGb: 1,
    tags: {
        environment: "staging",
    },
});

import pulumi
import pulumi_azure as azure
example = azure.core.ResourceGroup("example",
    name="example-resources",
    location="West Europe")
source = azure.compute.ManagedDisk("source",
    name="acctestmd1",
    location=example.location,
    resource_group_name=example.name,
    storage_account_type="Standard_LRS",
    create_option="Empty",
    disk_size_gb=1,
    tags={
        "environment": "staging",
    })
copy = azure.compute.ManagedDisk("copy",
    name="acctestmd2",
    location=example.location,
    resource_group_name=example.name,
    storage_account_type="Standard_LRS",
    create_option="Copy",
    source_resource_id=source.id,
    disk_size_gb=1,
    tags={
        "environment": "staging",
    })

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;
return await Deployment.RunAsync(() =>
{
    var example = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "example-resources",
        Location = "West Europe",
    });
    var source = new Azure.Compute.ManagedDisk("source", new()
    {
        Name = "acctestmd1",
        Location = example.Location,
        ResourceGroupName = example.Name,
        StorageAccountType = "Standard_LRS",
        CreateOption = "Empty",
        DiskSizeGb = 1,
        Tags =
        {
            { "environment", "staging" },
        },
    });
    var copy = new Azure.Compute.ManagedDisk("copy", new()
    {
        Name = "acctestmd2",
        Location = example.Location,
        ResourceGroupName = example.Name,
        StorageAccountType = "Standard_LRS",
        CreateOption = "Copy",
        SourceResourceId = source.Id,
        DiskSizeGb = 1,
        Tags =
        {
            { "environment", "staging" },
        },
    });
});

package main
import (
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/compute"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("example-resources"),
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		source, err := compute.NewManagedDisk(ctx, "source", &compute.ManagedDiskArgs{
			Name:               pulumi.String("acctestmd1"),
			Location:           example.Location,
			ResourceGroupName:  example.Name,
			StorageAccountType: pulumi.String("Standard_LRS"),
			CreateOption:       pulumi.String("Empty"),
			DiskSizeGb:         pulumi.Int(1),
			Tags: pulumi.StringMap{
				"environment": pulumi.String("staging"),
			},
		})
		if err != nil {
			return err
		}
		_, err = compute.NewManagedDisk(ctx, "copy", &compute.ManagedDiskArgs{
			Name:               pulumi.String("acctestmd2"),
			Location:           example.Location,
			ResourceGroupName:  example.Name,
			StorageAccountType: pulumi.String("Standard_LRS"),
			CreateOption:       pulumi.String("Copy"),
			SourceResourceId:   source.ID(),
			DiskSizeGb:         pulumi.Int(1),
			Tags: pulumi.StringMap{
				"environment": pulumi.String("staging"),
			},
		})
		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.compute.ManagedDisk;
import com.pulumi.azure.compute.ManagedDiskArgs;
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 example = new ResourceGroup("example", ResourceGroupArgs.builder()
            .name("example-resources")
            .location("West Europe")
            .build());
        var source = new ManagedDisk("source", ManagedDiskArgs.builder()
            .name("acctestmd1")
            .location(example.location())
            .resourceGroupName(example.name())
            .storageAccountType("Standard_LRS")
            .createOption("Empty")
            .diskSizeGb(1)
            .tags(Map.of("environment", "staging"))
            .build());
        var copy = new ManagedDisk("copy", ManagedDiskArgs.builder()
            .name("acctestmd2")
            .location(example.location())
            .resourceGroupName(example.name())
            .storageAccountType("Standard_LRS")
            .createOption("Copy")
            .sourceResourceId(source.id())
            .diskSizeGb(1)
            .tags(Map.of("environment", "staging"))
            .build());
    }
}

resources:
  example:
    type: azure:core:ResourceGroup
    properties:
      name: example-resources
      location: West Europe
  source:
    type: azure:compute:ManagedDisk
    properties:
      name: acctestmd1
      location: ${example.location}
      resourceGroupName: ${example.name}
      storageAccountType: Standard_LRS
      createOption: Empty
      diskSizeGb: '1'
      tags:
        environment: staging
  copy:
    type: azure:compute:ManagedDisk
    properties:
      name: acctestmd2
      location: ${example.location}
      resourceGroupName: ${example.name}
      storageAccountType: Standard_LRS
      createOption: Copy
      sourceResourceId: ${source.id}
      diskSizeGb: '1'
      tags:
        environment: staging

Import

Managed Disks can be imported using the resource id, e.g.

$ pulumi import azure:compute/managedDisk:ManagedDisk example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.Compute/disks/manageddisk1

Properties

createOption

val createOption: Output<String>

The method to use when creating the managed disk. Changing this forces a new resource to be created. Possible values include:

diskAccessId

val diskAccessId: Output<String>?

The ID of the disk access resource for using private endpoints on disks.

diskEncryptionSetId

val diskEncryptionSetId: Output<String>?

The ID of a Disk Encryption Set which should be used to encrypt this Managed Disk. Conflicts with secure_vm_disk_encryption_set_id.

diskIopsReadOnly

val diskIopsReadOnly: Output<Int>

The number of IOPS allowed across all VMs mounting the shared disk as read-only; only settable for UltraSSD disks and PremiumV2 disks with shared disk enabled. One operation can transfer between 4k and 256k bytes.

diskIopsReadWrite

val diskIopsReadWrite: Output<Int>

The number of IOPS allowed for this disk; only settable for UltraSSD disks and PremiumV2 disks. One operation can transfer between 4k and 256k bytes.

diskMbpsReadOnly

val diskMbpsReadOnly: Output<Int>

The bandwidth allowed across all VMs mounting the shared disk as read-only; only settable for UltraSSD disks and PremiumV2 disks with shared disk enabled. MBps means millions of bytes per second.

diskMbpsReadWrite

val diskMbpsReadWrite: Output<Int>

The bandwidth allowed for this disk; only settable for UltraSSD disks and PremiumV2 disks. MBps means millions of bytes per second.

diskSizeGb

val diskSizeGb: Output<Int>

edgeZone

val edgeZone: Output<String>?

Specifies the Edge Zone within the Azure Region where this Managed Disk should exist. Changing this forces a new Managed Disk to be created.

encryptionSettings

val encryptionSettings: Output<ManagedDiskEncryptionSettings>?

A encryption_settings block as defined below.

galleryImageReferenceId

val galleryImageReferenceId: Output<String>?

ID of a Gallery Image Version to copy when create_option is FromImage. This field cannot be specified if image_reference_id is specified. Changing this forces a new resource to be created.

hyperVGeneration

val hyperVGeneration: Output<String>?

The HyperV Generation of the Disk when the source of an Import or Copy operation targets a source that contains an operating system. Possible values are V1 and V2. For ImportSecure it must be set to V2. Changing this forces a new resource to be created.

val id: Output<String>

imageReferenceId

val imageReferenceId: Output<String>?

ID of an existing platform/marketplace disk image to copy when create_option is FromImage. This field cannot be specified if gallery_image_reference_id is specified. Changing this forces a new resource to be created.

location

val location: Output<String>

Specified the supported Azure location where the resource exists. Changing this forces a new resource to be created.

logicalSectorSize

val logicalSectorSize: Output<Int>

Logical Sector Size. Possible values are: 512 and 4096. Defaults to 4096. Changing this forces a new resource to be created.

maxShares

val maxShares: Output<Int>

The maximum number of VMs that can attach to the disk at the same time. Value greater than one indicates a disk that can be mounted on multiple VMs at the same time.

name

val name: Output<String>

Specifies the name of the Managed Disk. Changing this forces a new resource to be created.

networkAccessPolicy

val networkAccessPolicy: Output<String>?

Policy for accessing the disk via network. Allowed values are AllowAll, AllowPrivate, and DenyAll.

onDemandBurstingEnabled

val onDemandBurstingEnabled: Output<Boolean>?

Specifies if On-Demand Bursting is enabled for the Managed Disk.

optimizedFrequentAttachEnabled

val optimizedFrequentAttachEnabled: Output<Boolean>?

Specifies whether this Managed Disk should be optimized for frequent disk attachments (where a disk is attached/detached more than 5 times in a day). Defaults to false.

osType

val osType: Output<String>?

Specify a value when the source of an Import, ImportSecure or Copy operation targets a source that contains an operating system. Valid values are Linux or Windows.

performancePlusEnabled

val performancePlusEnabled: Output<Boolean>?

Specifies whether Performance Plus is enabled for this Managed Disk. Defaults to false. Changing this forces a new resource to be created.

publicNetworkAccessEnabled

val publicNetworkAccessEnabled: Output<Boolean>?

Whether it is allowed to access the disk via public network. Defaults to true. For more information on managed disks, such as sizing options and pricing, please check out the Azure Documentation.

pulumiChildResources

val pulumiChildResources: Set<KotlinResource>

pulumiResourceName

val pulumiResourceName: String

pulumiResourceType

val pulumiResourceType: String

resourceGroupName

val resourceGroupName: Output<String>

The name of the Resource Group where the Managed Disk should exist. Changing this forces a new resource to be created.

secureVmDiskEncryptionSetId

val secureVmDiskEncryptionSetId: Output<String>?

The ID of the Disk Encryption Set which should be used to Encrypt this OS Disk when the Virtual Machine is a Confidential VM. Conflicts with disk_encryption_set_id. Changing this forces a new resource to be created.

securityType

val securityType: Output<String>?

Security Type of the Managed Disk when it is used for a Confidential VM. Possible values are ConfidentialVM_VMGuestStateOnlyEncryptedWithPlatformKey, ConfidentialVM_DiskEncryptedWithPlatformKey and ConfidentialVM_DiskEncryptedWithCustomerKey. Changing this forces a new resource to be created.

sourceResourceId

val sourceResourceId: Output<String>?

The ID of an existing Managed Disk or Snapshot to copy when create_option is Copy or the recovery point to restore when create_option is Restore. Changing this forces a new resource to be created.

sourceUri

val sourceUri: Output<String>

URI to a valid VHD file to be used when create_option is Import or ImportSecure. Changing this forces a new resource to be created.

storageAccountId

val storageAccountId: Output<String>?

The ID of the Storage Account where the source_uri is located. Required when create_option is set to Import or ImportSecure. Changing this forces a new resource to be created.

storageAccountType

val storageAccountType: Output<String>

The type of storage to use for the managed disk. Possible values are Standard_LRS, StandardSSD_ZRS, Premium_LRS, PremiumV2_LRS, Premium_ZRS, StandardSSD_LRS or UltraSSD_LRS.