pulumi-azure-native-kotlin/com.pulumi.azurenative.compute.kotlin/DiskArgs

DiskArgs

data class DiskArgs(val burstingEnabled: Output<Boolean>? = null, val completionPercent: Output<Double>? = null, val creationData: Output<CreationDataArgs>? = null, val dataAccessAuthMode: Output<Either<String, DataAccessAuthMode>>? = null, val diskAccessId: Output<String>? = null, val diskIOPSReadOnly: Output<Double>? = null, val diskIOPSReadWrite: Output<Double>? = null, val diskMBpsReadOnly: Output<Double>? = null, val diskMBpsReadWrite: Output<Double>? = null, val diskName: Output<String>? = null, val diskSizeGB: Output<Int>? = null, val encryption: Output<EncryptionArgs>? = null, val encryptionSettingsCollection: Output<EncryptionSettingsCollectionArgs>? = null, val extendedLocation: Output<ExtendedLocationArgs>? = null, val hyperVGeneration: Output<Either<String, HyperVGeneration>>? = null, val location: Output<String>? = null, val maxShares: Output<Int>? = null, val networkAccessPolicy: Output<Either<String, NetworkAccessPolicy>>? = null, val optimizedForFrequentAttach: Output<Boolean>? = null, val osType: Output<OperatingSystemTypes>? = null, val publicNetworkAccess: Output<Either<String, PublicNetworkAccess>>? = null, val purchasePlan: Output<PurchasePlanArgs>? = null, val resourceGroupName: Output<String>? = null, val securityProfile: Output<DiskSecurityProfileArgs>? = null, val sku: Output<DiskSkuArgs>? = null, val supportedCapabilities: Output<SupportedCapabilitiesArgs>? = null, val supportsHibernation: Output<Boolean>? = null, val tags: Output<Map<String, String>>? = null, val tier: Output<String>? = null, val zones: Output<List<String>>? = null) : ConvertibleToJava<DiskArgs>

Disk resource. Azure REST API version: 2022-07-02. Prior API version in Azure Native 1.x: 2020-12-01. Other available API versions: 2016-04-30-preview, 2018-06-01, 2019-07-01, 2023-01-02, 2023-04-02.

Example Usage

Create a confidential VM supported disk encrypted with customer managed key

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "FromImage",
            ImageReference = new AzureNative.Compute.Inputs.ImageDiskReferenceArgs
            {
                Id = "/Subscriptions/{subscriptionId}/Providers/Microsoft.Compute/Locations/westus/Publishers/{publisher}/ArtifactTypes/VMImage/Offers/{offer}/Skus/{sku}/Versions/1.0.0",
            },
        },
        DiskName = "myDisk",
        Location = "West US",
        OsType = AzureNative.Compute.OperatingSystemTypes.Windows,
        ResourceGroupName = "myResourceGroup",
        SecurityProfile = new AzureNative.Compute.Inputs.DiskSecurityProfileArgs
        {
            SecureVMDiskEncryptionSetId = "/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}",
            SecurityType = "ConfidentialVM_DiskEncryptedWithCustomerKey",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: compute.CreationDataResponse{
				CreateOption: pulumi.String("FromImage"),
				ImageReference: &compute.ImageDiskReferenceArgs{
					Id: pulumi.String("/Subscriptions/{subscriptionId}/Providers/Microsoft.Compute/Locations/westus/Publishers/{publisher}/ArtifactTypes/VMImage/Offers/{offer}/Skus/{sku}/Versions/1.0.0"),
				},
			},
			DiskName:          pulumi.String("myDisk"),
			Location:          pulumi.String("West US"),
			OsType:            compute.OperatingSystemTypesWindows,
			ResourceGroupName: pulumi.String("myResourceGroup"),
			SecurityProfile: &compute.DiskSecurityProfileArgs{
				SecureVMDiskEncryptionSetId: pulumi.String("/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
				SecurityType:                pulumi.String("ConfidentialVM_DiskEncryptedWithCustomerKey"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.ofEntries(
                Map.entry("createOption", "FromImage"),
                Map.entry("imageReference", Map.of("id", "/Subscriptions/{subscriptionId}/Providers/Microsoft.Compute/Locations/westus/Publishers/{publisher}/ArtifactTypes/VMImage/Offers/{offer}/Skus/{sku}/Versions/1.0.0"))
            ))
            .diskName("myDisk")
            .location("West US")
            .osType("Windows")
            .resourceGroupName("myResourceGroup")
            .securityProfile(Map.ofEntries(
                Map.entry("secureVMDiskEncryptionSetId", "/subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{diskEncryptionSetName}"),
                Map.entry("securityType", "ConfidentialVM_DiskEncryptedWithCustomerKey")
            ))
            .build());
    }
}
Content copied to clipboard

Create a managed disk and associate with disk access resource.

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "Empty",
        },
        DiskAccessId = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskAccesses/{existing-diskAccess-name}",
        DiskName = "myDisk",
        DiskSizeGB = 200,
        Location = "West US",
        NetworkAccessPolicy = "AllowPrivate",
        ResourceGroupName = "myResourceGroup",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: &compute.CreationDataArgs{
				CreateOption: pulumi.String("Empty"),
			},
			DiskAccessId:        pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskAccesses/{existing-diskAccess-name}"),
			DiskName:            pulumi.String("myDisk"),
			DiskSizeGB:          pulumi.Int(200),
			Location:            pulumi.String("West US"),
			NetworkAccessPolicy: pulumi.String("AllowPrivate"),
			ResourceGroupName:   pulumi.String("myResourceGroup"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.of("createOption", "Empty"))
            .diskAccessId("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskAccesses/{existing-diskAccess-name}")
            .diskName("myDisk")
            .diskSizeGB(200)
            .location("West US")
            .networkAccessPolicy("AllowPrivate")
            .resourceGroupName("myResourceGroup")
            .build());
    }
}
Content copied to clipboard

Create a managed disk and associate with disk encryption set.

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "Empty",
        },
        DiskName = "myDisk",
        DiskSizeGB = 200,
        Encryption = new AzureNative.Compute.Inputs.EncryptionArgs
        {
            DiskEncryptionSetId = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
        },
        Location = "West US",
        ResourceGroupName = "myResourceGroup",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: &compute.CreationDataArgs{
				CreateOption: pulumi.String("Empty"),
			},
			DiskName:   pulumi.String("myDisk"),
			DiskSizeGB: pulumi.Int(200),
			Encryption: &compute.EncryptionArgs{
				DiskEncryptionSetId: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}"),
			},
			Location:          pulumi.String("West US"),
			ResourceGroupName: pulumi.String("myResourceGroup"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.of("createOption", "Empty"))
            .diskName("myDisk")
            .diskSizeGB(200)
            .encryption(Map.of("diskEncryptionSetId", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}"))
            .location("West US")
            .resourceGroupName("myResourceGroup")
            .build());
    }
}
Content copied to clipboard

Create a managed disk by copying a snapshot.

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "Copy",
            SourceResourceId = "subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot",
        },
        DiskName = "myDisk",
        Location = "West US",
        ResourceGroupName = "myResourceGroup",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: &compute.CreationDataArgs{
				CreateOption:     pulumi.String("Copy"),
				SourceResourceId: pulumi.String("subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot"),
			},
			DiskName:          pulumi.String("myDisk"),
			Location:          pulumi.String("West US"),
			ResourceGroupName: pulumi.String("myResourceGroup"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.ofEntries(
                Map.entry("createOption", "Copy"),
                Map.entry("sourceResourceId", "subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot")
            ))
            .diskName("myDisk")
            .location("West US")
            .resourceGroupName("myResourceGroup")
            .build());
    }
}
Content copied to clipboard

Create a managed disk by importing an unmanaged blob from a different subscription.

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "Import",
            SourceUri = "https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd",
            StorageAccountId = "subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Storage/storageAccounts/myStorageAccount",
        },
        DiskName = "myDisk",
        Location = "West US",
        ResourceGroupName = "myResourceGroup",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: &compute.CreationDataArgs{
				CreateOption:     pulumi.String("Import"),
				SourceUri:        pulumi.String("https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd"),
				StorageAccountId: pulumi.String("subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Storage/storageAccounts/myStorageAccount"),
			},
			DiskName:          pulumi.String("myDisk"),
			Location:          pulumi.String("West US"),
			ResourceGroupName: pulumi.String("myResourceGroup"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.ofEntries(
                Map.entry("createOption", "Import"),
                Map.entry("sourceUri", "https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd"),
                Map.entry("storageAccountId", "subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Storage/storageAccounts/myStorageAccount")
            ))
            .diskName("myDisk")
            .location("West US")
            .resourceGroupName("myResourceGroup")
            .build());
    }
}
Content copied to clipboard

Create a managed disk by importing an unmanaged blob from the same subscription.

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "Import",
            SourceUri = "https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd",
        },
        DiskName = "myDisk",
        Location = "West US",
        ResourceGroupName = "myResourceGroup",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: &compute.CreationDataArgs{
				CreateOption: pulumi.String("Import"),
				SourceUri:    pulumi.String("https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd"),
			},
			DiskName:          pulumi.String("myDisk"),
			Location:          pulumi.String("West US"),
			ResourceGroupName: pulumi.String("myResourceGroup"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.ofEntries(
                Map.entry("createOption", "Import"),
                Map.entry("sourceUri", "https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd")
            ))
            .diskName("myDisk")
            .location("West US")
            .resourceGroupName("myResourceGroup")
            .build());
    }
}
Content copied to clipboard

Create a managed disk from ImportSecure create option

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "ImportSecure",
            SecurityDataUri = "https://mystorageaccount.blob.core.windows.net/osimages/vmgs.vhd",
            SourceUri = "https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd",
            StorageAccountId = "subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Storage/storageAccounts/myStorageAccount",
        },
        DiskName = "myDisk",
        Location = "West US",
        OsType = AzureNative.Compute.OperatingSystemTypes.Windows,
        ResourceGroupName = "myResourceGroup",
        SecurityProfile = new AzureNative.Compute.Inputs.DiskSecurityProfileArgs
        {
            SecurityType = "ConfidentialVM_VMGuestStateOnlyEncryptedWithPlatformKey",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: &compute.CreationDataArgs{
				CreateOption:     pulumi.String("ImportSecure"),
				SecurityDataUri:  pulumi.String("https://mystorageaccount.blob.core.windows.net/osimages/vmgs.vhd"),
				SourceUri:        pulumi.String("https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd"),
				StorageAccountId: pulumi.String("subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Storage/storageAccounts/myStorageAccount"),
			},
			DiskName:          pulumi.String("myDisk"),
			Location:          pulumi.String("West US"),
			OsType:            compute.OperatingSystemTypesWindows,
			ResourceGroupName: pulumi.String("myResourceGroup"),
			SecurityProfile: &compute.DiskSecurityProfileArgs{
				SecurityType: pulumi.String("ConfidentialVM_VMGuestStateOnlyEncryptedWithPlatformKey"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.ofEntries(
                Map.entry("createOption", "ImportSecure"),
                Map.entry("securityDataUri", "https://mystorageaccount.blob.core.windows.net/osimages/vmgs.vhd"),
                Map.entry("sourceUri", "https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd"),
                Map.entry("storageAccountId", "subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Storage/storageAccounts/myStorageAccount")
            ))
            .diskName("myDisk")
            .location("West US")
            .osType("Windows")
            .resourceGroupName("myResourceGroup")
            .securityProfile(Map.of("securityType", "ConfidentialVM_VMGuestStateOnlyEncryptedWithPlatformKey"))
            .build());
    }
}
Content copied to clipboard

Create a managed disk from UploadPreparedSecure create option

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "UploadPreparedSecure",
            UploadSizeBytes = 10737418752,
        },
        DiskName = "myDisk",
        Location = "West US",
        OsType = AzureNative.Compute.OperatingSystemTypes.Windows,
        ResourceGroupName = "myResourceGroup",
        SecurityProfile = new AzureNative.Compute.Inputs.DiskSecurityProfileArgs
        {
            SecurityType = "TrustedLaunch",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: &compute.CreationDataArgs{
				CreateOption:    pulumi.String("UploadPreparedSecure"),
				UploadSizeBytes: pulumi.Float64(10737418752),
			},
			DiskName:          pulumi.String("myDisk"),
			Location:          pulumi.String("West US"),
			OsType:            compute.OperatingSystemTypesWindows,
			ResourceGroupName: pulumi.String("myResourceGroup"),
			SecurityProfile: &compute.DiskSecurityProfileArgs{
				SecurityType: pulumi.String("TrustedLaunch"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.ofEntries(
                Map.entry("createOption", "UploadPreparedSecure"),
                Map.entry("uploadSizeBytes", 10737418752)
            ))
            .diskName("myDisk")
            .location("West US")
            .osType("Windows")
            .resourceGroupName("myResourceGroup")
            .securityProfile(Map.of("securityType", "TrustedLaunch"))
            .build());
    }
}
Content copied to clipboard

Create a managed disk from a platform image.

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "FromImage",
            ImageReference = new AzureNative.Compute.Inputs.ImageDiskReferenceArgs
            {
                Id = "/Subscriptions/{subscriptionId}/Providers/Microsoft.Compute/Locations/westus/Publishers/{publisher}/ArtifactTypes/VMImage/Offers/{offer}/Skus/{sku}/Versions/1.0.0",
            },
        },
        DiskName = "myDisk",
        Location = "West US",
        OsType = AzureNative.Compute.OperatingSystemTypes.Windows,
        ResourceGroupName = "myResourceGroup",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: compute.CreationDataResponse{
				CreateOption: pulumi.String("FromImage"),
				ImageReference: &compute.ImageDiskReferenceArgs{
					Id: pulumi.String("/Subscriptions/{subscriptionId}/Providers/Microsoft.Compute/Locations/westus/Publishers/{publisher}/ArtifactTypes/VMImage/Offers/{offer}/Skus/{sku}/Versions/1.0.0"),
				},
			},
			DiskName:          pulumi.String("myDisk"),
			Location:          pulumi.String("West US"),
			OsType:            compute.OperatingSystemTypesWindows,
			ResourceGroupName: pulumi.String("myResourceGroup"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.ofEntries(
                Map.entry("createOption", "FromImage"),
                Map.entry("imageReference", Map.of("id", "/Subscriptions/{subscriptionId}/Providers/Microsoft.Compute/Locations/westus/Publishers/{publisher}/ArtifactTypes/VMImage/Offers/{offer}/Skus/{sku}/Versions/1.0.0"))
            ))
            .diskName("myDisk")
            .location("West US")
            .osType("Windows")
            .resourceGroupName("myResourceGroup")
            .build());
    }
}
Content copied to clipboard

Create a managed disk from an Azure Compute Gallery community image.

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "FromImage",
            GalleryImageReference = new AzureNative.Compute.Inputs.ImageDiskReferenceArgs
            {
                CommunityGalleryImageId = "/CommunityGalleries/{communityGalleryPublicGalleryName}/Images/{imageName}/Versions/1.0.0",
            },
        },
        DiskName = "myDisk",
        Location = "West US",
        OsType = AzureNative.Compute.OperatingSystemTypes.Windows,
        ResourceGroupName = "myResourceGroup",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: compute.CreationDataResponse{
				CreateOption: pulumi.String("FromImage"),
				GalleryImageReference: &compute.ImageDiskReferenceArgs{
					CommunityGalleryImageId: pulumi.String("/CommunityGalleries/{communityGalleryPublicGalleryName}/Images/{imageName}/Versions/1.0.0"),
				},
			},
			DiskName:          pulumi.String("myDisk"),
			Location:          pulumi.String("West US"),
			OsType:            compute.OperatingSystemTypesWindows,
			ResourceGroupName: pulumi.String("myResourceGroup"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.ofEntries(
                Map.entry("createOption", "FromImage"),
                Map.entry("galleryImageReference", Map.of("communityGalleryImageId", "/CommunityGalleries/{communityGalleryPublicGalleryName}/Images/{imageName}/Versions/1.0.0"))
            ))
            .diskName("myDisk")
            .location("West US")
            .osType("Windows")
            .resourceGroupName("myResourceGroup")
            .build());
    }
}
Content copied to clipboard

Create a managed disk from an Azure Compute Gallery direct shared image.

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "FromImage",
            GalleryImageReference = new AzureNative.Compute.Inputs.ImageDiskReferenceArgs
            {
                SharedGalleryImageId = "/SharedGalleries/{sharedGalleryUniqueName}/Images/{imageName}/Versions/1.0.0",
            },
        },
        DiskName = "myDisk",
        Location = "West US",
        OsType = AzureNative.Compute.OperatingSystemTypes.Windows,
        ResourceGroupName = "myResourceGroup",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: compute.CreationDataResponse{
				CreateOption: pulumi.String("FromImage"),
				GalleryImageReference: &compute.ImageDiskReferenceArgs{
					SharedGalleryImageId: pulumi.String("/SharedGalleries/{sharedGalleryUniqueName}/Images/{imageName}/Versions/1.0.0"),
				},
			},
			DiskName:          pulumi.String("myDisk"),
			Location:          pulumi.String("West US"),
			OsType:            compute.OperatingSystemTypesWindows,
			ResourceGroupName: pulumi.String("myResourceGroup"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.ofEntries(
                Map.entry("createOption", "FromImage"),
                Map.entry("galleryImageReference", Map.of("sharedGalleryImageId", "/SharedGalleries/{sharedGalleryUniqueName}/Images/{imageName}/Versions/1.0.0"))
            ))
            .diskName("myDisk")
            .location("West US")
            .osType("Windows")
            .resourceGroupName("myResourceGroup")
            .build());
    }
}
Content copied to clipboard

Create a managed disk from an Azure Compute Gallery image.

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "FromImage",
            GalleryImageReference = new AzureNative.Compute.Inputs.ImageDiskReferenceArgs
            {
                Id = "/Subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/Providers/Microsoft.Compute/Galleries/{galleryName}/Images/{imageName}/Versions/1.0.0",
            },
        },
        DiskName = "myDisk",
        Location = "West US",
        OsType = AzureNative.Compute.OperatingSystemTypes.Windows,
        ResourceGroupName = "myResourceGroup",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: compute.CreationDataResponse{
				CreateOption: pulumi.String("FromImage"),
				GalleryImageReference: &compute.ImageDiskReferenceArgs{
					Id: pulumi.String("/Subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/Providers/Microsoft.Compute/Galleries/{galleryName}/Images/{imageName}/Versions/1.0.0"),
				},
			},
			DiskName:          pulumi.String("myDisk"),
			Location:          pulumi.String("West US"),
			OsType:            compute.OperatingSystemTypesWindows,
			ResourceGroupName: pulumi.String("myResourceGroup"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.ofEntries(
                Map.entry("createOption", "FromImage"),
                Map.entry("galleryImageReference", Map.of("id", "/Subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/Providers/Microsoft.Compute/Galleries/{galleryName}/Images/{imageName}/Versions/1.0.0"))
            ))
            .diskName("myDisk")
            .location("West US")
            .osType("Windows")
            .resourceGroupName("myResourceGroup")
            .build());
    }
}
Content copied to clipboard

Create a managed disk from an existing managed disk in the same or different subscription.

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "Copy",
            SourceResourceId = "subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk1",
        },
        DiskName = "myDisk2",
        Location = "West US",
        ResourceGroupName = "myResourceGroup",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: &compute.CreationDataArgs{
				CreateOption:     pulumi.String("Copy"),
				SourceResourceId: pulumi.String("subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk1"),
			},
			DiskName:          pulumi.String("myDisk2"),
			Location:          pulumi.String("West US"),
			ResourceGroupName: pulumi.String("myResourceGroup"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.ofEntries(
                Map.entry("createOption", "Copy"),
                Map.entry("sourceResourceId", "subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myDisk1")
            ))
            .diskName("myDisk2")
            .location("West US")
            .resourceGroupName("myResourceGroup")
            .build());
    }
}
Content copied to clipboard

Create a managed disk with dataAccessAuthMode

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "Empty",
        },
        DataAccessAuthMode = "AzureActiveDirectory",
        DiskName = "myDisk",
        DiskSizeGB = 200,
        Location = "West US",
        ResourceGroupName = "myResourceGroup",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: &compute.CreationDataArgs{
				CreateOption: pulumi.String("Empty"),
			},
			DataAccessAuthMode: pulumi.String("AzureActiveDirectory"),
			DiskName:           pulumi.String("myDisk"),
			DiskSizeGB:         pulumi.Int(200),
			Location:           pulumi.String("West US"),
			ResourceGroupName:  pulumi.String("myResourceGroup"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.of("createOption", "Empty"))
            .dataAccessAuthMode("AzureActiveDirectory")
            .diskName("myDisk")
            .diskSizeGB(200)
            .location("West US")
            .resourceGroupName("myResourceGroup")
            .build());
    }
}
Content copied to clipboard

Create a managed disk with optimizedForFrequentAttach.

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "Empty",
        },
        DiskName = "myDisk",
        DiskSizeGB = 200,
        Location = "West US",
        OptimizedForFrequentAttach = true,
        ResourceGroupName = "myResourceGroup",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: &compute.CreationDataArgs{
				CreateOption: pulumi.String("Empty"),
			},
			DiskName:                   pulumi.String("myDisk"),
			DiskSizeGB:                 pulumi.Int(200),
			Location:                   pulumi.String("West US"),
			OptimizedForFrequentAttach: pulumi.Bool(true),
			ResourceGroupName:          pulumi.String("myResourceGroup"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.of("createOption", "Empty"))
            .diskName("myDisk")
            .diskSizeGB(200)
            .location("West US")
            .optimizedForFrequentAttach(true)
            .resourceGroupName("myResourceGroup")
            .build());
    }
}
Content copied to clipboard

Create a managed disk with performancePlus.

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "Upload",
            PerformancePlus = true,
        },
        DiskName = "myDisk",
        Location = "West US",
        ResourceGroupName = "myResourceGroup",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: &compute.CreationDataArgs{
				CreateOption:    pulumi.String("Upload"),
				PerformancePlus: pulumi.Bool(true),
			},
			DiskName:          pulumi.String("myDisk"),
			Location:          pulumi.String("West US"),
			ResourceGroupName: pulumi.String("myResourceGroup"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.ofEntries(
                Map.entry("createOption", "Upload"),
                Map.entry("performancePlus", true)
            ))
            .diskName("myDisk")
            .location("West US")
            .resourceGroupName("myResourceGroup")
            .build());
    }
}
Content copied to clipboard

Create a managed disk with premium v2 account type.

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "Empty",
        },
        DiskIOPSReadWrite = 125,
        DiskMBpsReadWrite = 3000,
        DiskName = "myPremiumV2Disk",
        DiskSizeGB = 200,
        Location = "West US",
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.DiskSkuArgs
        {
            Name = "PremiumV2_LRS",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: &compute.CreationDataArgs{
				CreateOption: pulumi.String("Empty"),
			},
			DiskIOPSReadWrite: pulumi.Float64(125),
			DiskMBpsReadWrite: pulumi.Float64(3000),
			DiskName:          pulumi.String("myPremiumV2Disk"),
			DiskSizeGB:        pulumi.Int(200),
			Location:          pulumi.String("West US"),
			ResourceGroupName: pulumi.String("myResourceGroup"),
			Sku: &compute.DiskSkuArgs{
				Name: pulumi.String("PremiumV2_LRS"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.of("createOption", "Empty"))
            .diskIOPSReadWrite(125)
            .diskMBpsReadWrite(3000)
            .diskName("myPremiumV2Disk")
            .diskSizeGB(200)
            .location("West US")
            .resourceGroupName("myResourceGroup")
            .sku(Map.of("name", "PremiumV2_LRS"))
            .build());
    }
}
Content copied to clipboard

Create a managed disk with security profile

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "FromImage",
            ImageReference = new AzureNative.Compute.Inputs.ImageDiskReferenceArgs
            {
                Id = "/Subscriptions/{subscriptionId}/Providers/Microsoft.Compute/Locations/uswest/Publishers/Microsoft/ArtifactTypes/VMImage/Offers/{offer}",
            },
        },
        DiskName = "myDisk",
        Location = "North Central US",
        OsType = AzureNative.Compute.OperatingSystemTypes.Windows,
        ResourceGroupName = "myResourceGroup",
        SecurityProfile = new AzureNative.Compute.Inputs.DiskSecurityProfileArgs
        {
            SecurityType = "TrustedLaunch",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: compute.CreationDataResponse{
				CreateOption: pulumi.String("FromImage"),
				ImageReference: &compute.ImageDiskReferenceArgs{
					Id: pulumi.String("/Subscriptions/{subscriptionId}/Providers/Microsoft.Compute/Locations/uswest/Publishers/Microsoft/ArtifactTypes/VMImage/Offers/{offer}"),
				},
			},
			DiskName:          pulumi.String("myDisk"),
			Location:          pulumi.String("North Central US"),
			OsType:            compute.OperatingSystemTypesWindows,
			ResourceGroupName: pulumi.String("myResourceGroup"),
			SecurityProfile: &compute.DiskSecurityProfileArgs{
				SecurityType: pulumi.String("TrustedLaunch"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.ofEntries(
                Map.entry("createOption", "FromImage"),
                Map.entry("imageReference", Map.of("id", "/Subscriptions/{subscriptionId}/Providers/Microsoft.Compute/Locations/uswest/Publishers/Microsoft/ArtifactTypes/VMImage/Offers/{offer}"))
            ))
            .diskName("myDisk")
            .location("North Central US")
            .osType("Windows")
            .resourceGroupName("myResourceGroup")
            .securityProfile(Map.of("securityType", "TrustedLaunch"))
            .build());
    }
}
Content copied to clipboard

Create a managed disk with ssd zrs account type.

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "Empty",
        },
        DiskName = "myDisk",
        DiskSizeGB = 200,
        Location = "West US",
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.DiskSkuArgs
        {
            Name = "Premium_ZRS",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: &compute.CreationDataArgs{
				CreateOption: pulumi.String("Empty"),
			},
			DiskName:          pulumi.String("myDisk"),
			DiskSizeGB:        pulumi.Int(200),
			Location:          pulumi.String("West US"),
			ResourceGroupName: pulumi.String("myResourceGroup"),
			Sku: &compute.DiskSkuArgs{
				Name: pulumi.String("Premium_ZRS"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.of("createOption", "Empty"))
            .diskName("myDisk")
            .diskSizeGB(200)
            .location("West US")
            .resourceGroupName("myResourceGroup")
            .sku(Map.of("name", "Premium_ZRS"))
            .build());
    }
}
Content copied to clipboard

Create a managed disk with ultra account type with readOnly property set.

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "Empty",
            LogicalSectorSize = 4096,
        },
        DiskIOPSReadWrite = 125,
        DiskMBpsReadWrite = 3000,
        DiskName = "myUltraReadOnlyDisk",
        DiskSizeGB = 200,
        Encryption = new AzureNative.Compute.Inputs.EncryptionArgs
        {
            Type = "EncryptionAtRestWithPlatformKey",
        },
        Location = "West US",
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.DiskSkuArgs
        {
            Name = "UltraSSD_LRS",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: &compute.CreationDataArgs{
				CreateOption:      pulumi.String("Empty"),
				LogicalSectorSize: pulumi.Int(4096),
			},
			DiskIOPSReadWrite: pulumi.Float64(125),
			DiskMBpsReadWrite: pulumi.Float64(3000),
			DiskName:          pulumi.String("myUltraReadOnlyDisk"),
			DiskSizeGB:        pulumi.Int(200),
			Encryption: &compute.EncryptionArgs{
				Type: pulumi.String("EncryptionAtRestWithPlatformKey"),
			},
			Location:          pulumi.String("West US"),
			ResourceGroupName: pulumi.String("myResourceGroup"),
			Sku: &compute.DiskSkuArgs{
				Name: pulumi.String("UltraSSD_LRS"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.ofEntries(
                Map.entry("createOption", "Empty"),
                Map.entry("logicalSectorSize", 4096)
            ))
            .diskIOPSReadWrite(125)
            .diskMBpsReadWrite(3000)
            .diskName("myUltraReadOnlyDisk")
            .diskSizeGB(200)
            .encryption(Map.of("type", "EncryptionAtRestWithPlatformKey"))
            .location("West US")
            .resourceGroupName("myResourceGroup")
            .sku(Map.of("name", "UltraSSD_LRS"))
            .build());
    }
}
Content copied to clipboard

Create a managed upload disk.

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "Upload",
            UploadSizeBytes = 10737418752,
        },
        DiskName = "myDisk",
        Location = "West US",
        ResourceGroupName = "myResourceGroup",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: &compute.CreationDataArgs{
				CreateOption:    pulumi.String("Upload"),
				UploadSizeBytes: pulumi.Float64(10737418752),
			},
			DiskName:          pulumi.String("myDisk"),
			Location:          pulumi.String("West US"),
			ResourceGroupName: pulumi.String("myResourceGroup"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.ofEntries(
                Map.entry("createOption", "Upload"),
                Map.entry("uploadSizeBytes", 10737418752)
            ))
            .diskName("myDisk")
            .location("West US")
            .resourceGroupName("myResourceGroup")
            .build());
    }
}
Content copied to clipboard

Create an empty managed disk in extended location.

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "Empty",
        },
        DiskName = "myDisk",
        DiskSizeGB = 200,
        ExtendedLocation = new AzureNative.Compute.Inputs.ExtendedLocationArgs
        {
            Name = "{edge-zone-id}",
            Type = "EdgeZone",
        },
        Location = "West US",
        ResourceGroupName = "myResourceGroup",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: &compute.CreationDataArgs{
				CreateOption: pulumi.String("Empty"),
			},
			DiskName:   pulumi.String("myDisk"),
			DiskSizeGB: pulumi.Int(200),
			ExtendedLocation: &compute.ExtendedLocationArgs{
				Name: pulumi.String("{edge-zone-id}"),
				Type: pulumi.String("EdgeZone"),
			},
			Location:          pulumi.String("West US"),
			ResourceGroupName: pulumi.String("myResourceGroup"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.of("createOption", "Empty"))
            .diskName("myDisk")
            .diskSizeGB(200)
            .extendedLocation(Map.ofEntries(
                Map.entry("name", "{edge-zone-id}"),
                Map.entry("type", "EdgeZone")
            ))
            .location("West US")
            .resourceGroupName("myResourceGroup")
            .build());
    }
}
Content copied to clipboard

Create an empty managed disk.

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "Empty",
        },
        DiskName = "myDisk",
        DiskSizeGB = 200,
        Location = "West US",
        ResourceGroupName = "myResourceGroup",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: &compute.CreationDataArgs{
				CreateOption: pulumi.String("Empty"),
			},
			DiskName:          pulumi.String("myDisk"),
			DiskSizeGB:        pulumi.Int(200),
			Location:          pulumi.String("West US"),
			ResourceGroupName: pulumi.String("myResourceGroup"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.of("createOption", "Empty"))
            .diskName("myDisk")
            .diskSizeGB(200)
            .location("West US")
            .resourceGroupName("myResourceGroup")
            .build());
    }
}
Content copied to clipboard

Create an ultra managed disk with logicalSectorSize 512E

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var disk = new AzureNative.Compute.Disk("disk", new()
    {
        CreationData = new AzureNative.Compute.Inputs.CreationDataArgs
        {
            CreateOption = "Empty",
            LogicalSectorSize = 512,
        },
        DiskName = "myDisk",
        DiskSizeGB = 200,
        Location = "West US",
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.DiskSkuArgs
        {
            Name = "UltraSSD_LRS",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "disk", &compute.DiskArgs{
			CreationData: &compute.CreationDataArgs{
				CreateOption:      pulumi.String("Empty"),
				LogicalSectorSize: pulumi.Int(512),
			},
			DiskName:          pulumi.String("myDisk"),
			DiskSizeGB:        pulumi.Int(200),
			Location:          pulumi.String("West US"),
			ResourceGroupName: pulumi.String("myResourceGroup"),
			Sku: &compute.DiskSkuArgs{
				Name: pulumi.String("UltraSSD_LRS"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.Disk;
import com.pulumi.azurenative.compute.DiskArgs;
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 disk = new Disk("disk", DiskArgs.builder()
            .creationData(Map.ofEntries(
                Map.entry("createOption", "Empty"),
                Map.entry("logicalSectorSize", 512)
            ))
            .diskName("myDisk")
            .diskSizeGB(200)
            .location("West US")
            .resourceGroupName("myResourceGroup")
            .sku(Map.of("name", "UltraSSD_LRS"))
            .build());
    }
}
Content copied to clipboard

Import

An existing resource can be imported using its type token, name, and identifier, e.g.

$ pulumi import azure-native:compute:Disk myDisk /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/disks/{diskName}
Content copied to clipboard

Constructors

Link copied to clipboard
fun DiskArgs(burstingEnabled: Output<Boolean>? = null, completionPercent: Output<Double>? = null, creationData: Output<CreationDataArgs>? = null, dataAccessAuthMode: Output<Either<String, DataAccessAuthMode>>? = null, diskAccessId: Output<String>? = null, diskIOPSReadOnly: Output<Double>? = null, diskIOPSReadWrite: Output<Double>? = null, diskMBpsReadOnly: Output<Double>? = null, diskMBpsReadWrite: Output<Double>? = null, diskName: Output<String>? = null, diskSizeGB: Output<Int>? = null, encryption: Output<EncryptionArgs>? = null, encryptionSettingsCollection: Output<EncryptionSettingsCollectionArgs>? = null, extendedLocation: Output<ExtendedLocationArgs>? = null, hyperVGeneration: Output<Either<String, HyperVGeneration>>? = null, location: Output<String>? = null, maxShares: Output<Int>? = null, networkAccessPolicy: Output<Either<String, NetworkAccessPolicy>>? = null, optimizedForFrequentAttach: Output<Boolean>? = null, osType: Output<OperatingSystemTypes>? = null, publicNetworkAccess: Output<Either<String, PublicNetworkAccess>>? = null, purchasePlan: Output<PurchasePlanArgs>? = null, resourceGroupName: Output<String>? = null, securityProfile: Output<DiskSecurityProfileArgs>? = null, sku: Output<DiskSkuArgs>? = null, supportedCapabilities: Output<SupportedCapabilitiesArgs>? = null, supportsHibernation: Output<Boolean>? = null, tags: Output<Map<String, String>>? = null, tier: Output<String>? = null, zones: Output<List<String>>? = null)

Functions

Link copied to clipboard
open override fun toJava(): DiskArgs

Properties

Link copied to clipboard
val burstingEnabled: Output<Boolean>? = null

Set to true to enable bursting beyond the provisioned performance target of the disk. Bursting is disabled by default. Does not apply to Ultra disks.

Link copied to clipboard
val completionPercent: Output<Double>? = null

Percentage complete for the background copy when a resource is created via the CopyStart operation.

Link copied to clipboard
val creationData: Output<CreationDataArgs>? = null

Disk source information. CreationData information cannot be changed after the disk has been created.

Link copied to clipboard
val dataAccessAuthMode: Output<Either<String, DataAccessAuthMode>>? = null

Additional authentication requirements when exporting or uploading to a disk or snapshot.

Link copied to clipboard
val diskAccessId: Output<String>? = null

ARM id of the DiskAccess resource for using private endpoints on disks.

Link copied to clipboard
val diskIOPSReadOnly: Output<Double>? = null

The total number of IOPS that will be allowed across all VMs mounting the shared disk as ReadOnly. One operation can transfer between 4k and 256k bytes.

Link copied to clipboard
val diskIOPSReadWrite: Output<Double>? = null

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

Link copied to clipboard
val diskMBpsReadOnly: Output<Double>? = null

The total throughput (MBps) that will be allowed across all VMs mounting the shared disk as ReadOnly. MBps means millions of bytes per second - MB here uses the ISO notation, of powers of 10.

Link copied to clipboard
val diskMBpsReadWrite: Output<Double>? = null

The bandwidth allowed for this disk; only settable for UltraSSD disks. MBps means millions of bytes per second - MB here uses the ISO notation, of powers of 10.

Link copied to clipboard
val diskName: Output<String>? = null

The name of the managed disk that is being created. The name can't be changed after the disk is created. Supported characters for the name are a-z, A-Z, 0-9, _ and -. The maximum name length is 80 characters.

Link copied to clipboard
val diskSizeGB: Output<Int>? = null

If creationData.createOption is Empty, this field is mandatory and it indicates the size of the disk to create. If this field is present for updates or creation with other options, it indicates a resize. Resizes are only allowed if the disk is not attached to a running VM, and can only increase the disk's size.

Link copied to clipboard
val encryption: Output<EncryptionArgs>? = null

Encryption property can be used to encrypt data at rest with customer managed keys or platform managed keys.

Link copied to clipboard
val encryptionSettingsCollection: Output<EncryptionSettingsCollectionArgs>? = null

Encryption settings collection used for Azure Disk Encryption, can contain multiple encryption settings per disk or snapshot.

Link copied to clipboard
val extendedLocation: Output<ExtendedLocationArgs>? = null

The extended location where the disk will be created. Extended location cannot be changed.

Link copied to clipboard
val hyperVGeneration: Output<Either<String, HyperVGeneration>>? = null

The hypervisor generation of the Virtual Machine. Applicable to OS disks only.

Link copied to clipboard
val location: Output<String>? = null

Resource location

Link copied to clipboard
val maxShares: Output<Int>? = null

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.

Link copied to clipboard
val networkAccessPolicy: Output<Either<String, NetworkAccessPolicy>>? = null

Policy for accessing the disk via network.

Link copied to clipboard
val optimizedForFrequentAttach: Output<Boolean>? = null

Setting this property to true improves reliability and performance of data disks that are frequently (more than 5 times a day) by detached from one virtual machine and attached to another. This property should not be set for disks that are not detached and attached frequently as it causes the disks to not align with the fault domain of the virtual machine.

Link copied to clipboard
val osType: Output<OperatingSystemTypes>? = null

The Operating System type.

Link copied to clipboard
val publicNetworkAccess: Output<Either<String, PublicNetworkAccess>>? = null

Policy for controlling export on the disk.

Link copied to clipboard
val purchasePlan: Output<PurchasePlanArgs>? = null

Purchase plan information for the the image from which the OS disk was created. E.g. - {name: 2019-Datacenter, publisher: MicrosoftWindowsServer, product: WindowsServer}

Link copied to clipboard
val resourceGroupName: Output<String>? = null

The name of the resource group.

Link copied to clipboard
val securityProfile: Output<DiskSecurityProfileArgs>? = null

Contains the security related information for the resource.

Link copied to clipboard
val sku: Output<DiskSkuArgs>? = null

The disks sku name. Can be Standard_LRS, Premium_LRS, StandardSSD_LRS, UltraSSD_LRS, Premium_ZRS, StandardSSD_ZRS, or PremiumV2_LRS.

Link copied to clipboard
val supportedCapabilities: Output<SupportedCapabilitiesArgs>? = null

List of supported capabilities for the image from which the OS disk was created.

Link copied to clipboard
val supportsHibernation: Output<Boolean>? = null

Indicates the OS on a disk supports hibernation.

Link copied to clipboard
val tags: Output<Map<String, String>>? = null

Resource tags

Link copied to clipboard
val tier: Output<String>? = null

Performance tier of the disk (e.g, P4, S10) as described here: https://azure.microsoft.com/en-us/pricing/details/managed-disks/. Does not apply to Ultra disks.

Link copied to clipboard
val zones: Output<List<String>>? = null

The Logical zone list for Disk.