1. Packages
  2. Azure Native
  3. API Docs
  4. compute
  5. Image
This is the latest version of Azure Native. Use the Azure Native v1 docs if using the v1 version of this package.
Azure Native v2.29.0 published on Friday, Feb 16, 2024 by Pulumi

azure-native.compute.Image

Explore with Pulumi AI

azure-native logo
This is the latest version of Azure Native. Use the Azure Native v1 docs if using the v1 version of this package.
Azure Native v2.29.0 published on Friday, Feb 16, 2024 by Pulumi

    The source user image virtual hard disk. The virtual hard disk will be copied before being attached to the virtual machine. If SourceImage is provided, the destination virtual hard drive must not exist. Azure REST API version: 2023-03-01. Prior API version in Azure Native 1.x: 2020-12-01.

    Other available API versions: 2023-07-01, 2023-09-01.

    Example Usage

    Create a virtual machine image from a blob with DiskEncryptionSet resource.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var image = new AzureNative.Compute.Image("image", new()
        {
            ImageName = "myImage",
            Location = "West US",
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.ImageStorageProfileArgs
            {
                OsDisk = new AzureNative.Compute.Inputs.ImageOSDiskArgs
                {
                    BlobUri = "https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd",
                    DiskEncryptionSet = new AzureNative.Compute.Inputs.DiskEncryptionSetParametersArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                    },
                    OsState = AzureNative.Compute.OperatingSystemStateTypes.Generalized,
                    OsType = AzureNative.Compute.OperatingSystemTypes.Linux,
                },
            },
        });
    
    });
    
    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.NewImage(ctx, "image", &compute.ImageArgs{
    ImageName: pulumi.String("myImage"),
    Location: pulumi.String("West US"),
    ResourceGroupName: pulumi.String("myResourceGroup"),
    StorageProfile: compute.ImageStorageProfileResponse{
    OsDisk: interface{}{
    BlobUri: pulumi.String("https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd"),
    DiskEncryptionSet: &compute.DiskEncryptionSetParametersArgs{
    Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}"),
    },
    OsState: compute.OperatingSystemStateTypesGeneralized,
    OsType: compute.OperatingSystemTypesLinux,
    },
    },
    })
    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.azurenative.compute.Image;
    import com.pulumi.azurenative.compute.ImageArgs;
    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 image = new Image("image", ImageArgs.builder()        
                .imageName("myImage")
                .location("West US")
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.of("osDisk", Map.ofEntries(
                    Map.entry("blobUri", "https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd"),
                    Map.entry("diskEncryptionSet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}")),
                    Map.entry("osState", "Generalized"),
                    Map.entry("osType", "Linux")
                )))
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    image = azure_native.compute.Image("image",
        image_name="myImage",
        location="West US",
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.ImageStorageProfileResponseArgs(
            os_disk={
                "blobUri": "https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd",
                "diskEncryptionSet": azure_native.compute.DiskEncryptionSetParametersArgs(
                    id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                ),
                "osState": azure_native.compute.OperatingSystemStateTypes.GENERALIZED,
                "osType": azure_native.compute.OperatingSystemTypes.LINUX,
            },
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const image = new azure_native.compute.Image("image", {
        imageName: "myImage",
        location: "West US",
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            osDisk: {
                blobUri: "https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd",
                diskEncryptionSet: {
                    id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                },
                osState: azure_native.compute.OperatingSystemStateTypes.Generalized,
                osType: azure_native.compute.OperatingSystemTypes.Linux,
            },
        },
    });
    
    resources:
      image:
        type: azure-native:compute:Image
        properties:
          imageName: myImage
          location: West US
          resourceGroupName: myResourceGroup
          storageProfile:
            osDisk:
              blobUri: https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd
              diskEncryptionSet:
                id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}
              osState: Generalized
              osType: Linux
    

    Create a virtual machine image from a blob.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var image = new AzureNative.Compute.Image("image", new()
        {
            ImageName = "myImage",
            Location = "West US",
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.ImageStorageProfileArgs
            {
                OsDisk = new AzureNative.Compute.Inputs.ImageOSDiskArgs
                {
                    BlobUri = "https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd",
                    OsState = AzureNative.Compute.OperatingSystemStateTypes.Generalized,
                    OsType = AzureNative.Compute.OperatingSystemTypes.Linux,
                },
                ZoneResilient = true,
            },
        });
    
    });
    
    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.NewImage(ctx, "image", &compute.ImageArgs{
    			ImageName:         pulumi.String("myImage"),
    			Location:          pulumi.String("West US"),
    			ResourceGroupName: pulumi.String("myResourceGroup"),
    			StorageProfile: compute.ImageStorageProfileResponse{
    				OsDisk: &compute.ImageOSDiskArgs{
    					BlobUri: pulumi.String("https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd"),
    					OsState: compute.OperatingSystemStateTypesGeneralized,
    					OsType:  compute.OperatingSystemTypesLinux,
    				},
    				ZoneResilient: pulumi.Bool(true),
    			},
    		})
    		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.azurenative.compute.Image;
    import com.pulumi.azurenative.compute.ImageArgs;
    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 image = new Image("image", ImageArgs.builder()        
                .imageName("myImage")
                .location("West US")
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("blobUri", "https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd"),
                        Map.entry("osState", "Generalized"),
                        Map.entry("osType", "Linux")
                    )),
                    Map.entry("zoneResilient", true)
                ))
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    image = azure_native.compute.Image("image",
        image_name="myImage",
        location="West US",
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.ImageStorageProfileResponseArgs(
            os_disk=azure_native.compute.ImageOSDiskArgs(
                blob_uri="https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd",
                os_state=azure_native.compute.OperatingSystemStateTypes.GENERALIZED,
                os_type=azure_native.compute.OperatingSystemTypes.LINUX,
            ),
            zone_resilient=True,
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const image = new azure_native.compute.Image("image", {
        imageName: "myImage",
        location: "West US",
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            osDisk: {
                blobUri: "https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd",
                osState: azure_native.compute.OperatingSystemStateTypes.Generalized,
                osType: azure_native.compute.OperatingSystemTypes.Linux,
            },
            zoneResilient: true,
        },
    });
    
    resources:
      image:
        type: azure-native:compute:Image
        properties:
          imageName: myImage
          location: West US
          resourceGroupName: myResourceGroup
          storageProfile:
            osDisk:
              blobUri: https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd
              osState: Generalized
              osType: Linux
            zoneResilient: true
    

    Create a virtual machine image from a managed disk with DiskEncryptionSet resource.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var image = new AzureNative.Compute.Image("image", new()
        {
            ImageName = "myImage",
            Location = "West US",
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.ImageStorageProfileArgs
            {
                OsDisk = new AzureNative.Compute.Inputs.ImageOSDiskArgs
                {
                    DiskEncryptionSet = new AzureNative.Compute.Inputs.DiskEncryptionSetParametersArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                    },
                    OsState = AzureNative.Compute.OperatingSystemStateTypes.Generalized,
                    OsType = AzureNative.Compute.OperatingSystemTypes.Linux,
                    Snapshot = new AzureNative.Compute.Inputs.SubResourceArgs
                    {
                        Id = "subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot",
                    },
                },
            },
        });
    
    });
    
    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.NewImage(ctx, "image", &compute.ImageArgs{
    ImageName: pulumi.String("myImage"),
    Location: pulumi.String("West US"),
    ResourceGroupName: pulumi.String("myResourceGroup"),
    StorageProfile: compute.ImageStorageProfileResponse{
    OsDisk: interface{}{
    DiskEncryptionSet: &compute.DiskEncryptionSetParametersArgs{
    Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}"),
    },
    OsState: compute.OperatingSystemStateTypesGeneralized,
    OsType: compute.OperatingSystemTypesLinux,
    Snapshot: &compute.SubResourceArgs{
    Id: pulumi.String("subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot"),
    },
    },
    },
    })
    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.azurenative.compute.Image;
    import com.pulumi.azurenative.compute.ImageArgs;
    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 image = new Image("image", ImageArgs.builder()        
                .imageName("myImage")
                .location("West US")
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.of("osDisk", Map.ofEntries(
                    Map.entry("diskEncryptionSet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}")),
                    Map.entry("osState", "Generalized"),
                    Map.entry("osType", "Linux"),
                    Map.entry("snapshot", Map.of("id", "subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot"))
                )))
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    image = azure_native.compute.Image("image",
        image_name="myImage",
        location="West US",
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.ImageStorageProfileResponseArgs(
            os_disk={
                "diskEncryptionSet": azure_native.compute.DiskEncryptionSetParametersArgs(
                    id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                ),
                "osState": azure_native.compute.OperatingSystemStateTypes.GENERALIZED,
                "osType": azure_native.compute.OperatingSystemTypes.LINUX,
                "snapshot": azure_native.compute.SubResourceArgs(
                    id="subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot",
                ),
            },
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const image = new azure_native.compute.Image("image", {
        imageName: "myImage",
        location: "West US",
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            osDisk: {
                diskEncryptionSet: {
                    id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                },
                osState: azure_native.compute.OperatingSystemStateTypes.Generalized,
                osType: azure_native.compute.OperatingSystemTypes.Linux,
                snapshot: {
                    id: "subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot",
                },
            },
        },
    });
    
    resources:
      image:
        type: azure-native:compute:Image
        properties:
          imageName: myImage
          location: West US
          resourceGroupName: myResourceGroup
          storageProfile:
            osDisk:
              diskEncryptionSet:
                id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}
              osState: Generalized
              osType: Linux
              snapshot:
                id: subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot
    

    Create a virtual machine image from a managed disk.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var image = new AzureNative.Compute.Image("image", new()
        {
            ImageName = "myImage",
            Location = "West US",
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.ImageStorageProfileArgs
            {
                OsDisk = new AzureNative.Compute.Inputs.ImageOSDiskArgs
                {
                    ManagedDisk = new AzureNative.Compute.Inputs.SubResourceArgs
                    {
                        Id = "subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk",
                    },
                    OsState = AzureNative.Compute.OperatingSystemStateTypes.Generalized,
                    OsType = AzureNative.Compute.OperatingSystemTypes.Linux,
                },
                ZoneResilient = true,
            },
        });
    
    });
    
    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.NewImage(ctx, "image", &compute.ImageArgs{
    ImageName: pulumi.String("myImage"),
    Location: pulumi.String("West US"),
    ResourceGroupName: pulumi.String("myResourceGroup"),
    StorageProfile: compute.ImageStorageProfileResponse{
    OsDisk: interface{}{
    ManagedDisk: &compute.SubResourceArgs{
    Id: pulumi.String("subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk"),
    },
    OsState: compute.OperatingSystemStateTypesGeneralized,
    OsType: compute.OperatingSystemTypesLinux,
    },
    ZoneResilient: pulumi.Bool(true),
    },
    })
    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.azurenative.compute.Image;
    import com.pulumi.azurenative.compute.ImageArgs;
    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 image = new Image("image", ImageArgs.builder()        
                .imageName("myImage")
                .location("West US")
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("managedDisk", Map.of("id", "subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk")),
                        Map.entry("osState", "Generalized"),
                        Map.entry("osType", "Linux")
                    )),
                    Map.entry("zoneResilient", true)
                ))
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    image = azure_native.compute.Image("image",
        image_name="myImage",
        location="West US",
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.ImageStorageProfileResponseArgs(
            os_disk={
                "managedDisk": azure_native.compute.SubResourceArgs(
                    id="subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk",
                ),
                "osState": azure_native.compute.OperatingSystemStateTypes.GENERALIZED,
                "osType": azure_native.compute.OperatingSystemTypes.LINUX,
            },
            zone_resilient=True,
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const image = new azure_native.compute.Image("image", {
        imageName: "myImage",
        location: "West US",
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            osDisk: {
                managedDisk: {
                    id: "subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk",
                },
                osState: azure_native.compute.OperatingSystemStateTypes.Generalized,
                osType: azure_native.compute.OperatingSystemTypes.Linux,
            },
            zoneResilient: true,
        },
    });
    
    resources:
      image:
        type: azure-native:compute:Image
        properties:
          imageName: myImage
          location: West US
          resourceGroupName: myResourceGroup
          storageProfile:
            osDisk:
              managedDisk:
                id: subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk
              osState: Generalized
              osType: Linux
            zoneResilient: true
    

    Create a virtual machine image from a snapshot with DiskEncryptionSet resource.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var image = new AzureNative.Compute.Image("image", new()
        {
            ImageName = "myImage",
            Location = "West US",
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.ImageStorageProfileArgs
            {
                OsDisk = new AzureNative.Compute.Inputs.ImageOSDiskArgs
                {
                    DiskEncryptionSet = new AzureNative.Compute.Inputs.DiskEncryptionSetParametersArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                    },
                    ManagedDisk = new AzureNative.Compute.Inputs.SubResourceArgs
                    {
                        Id = "subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk",
                    },
                    OsState = AzureNative.Compute.OperatingSystemStateTypes.Generalized,
                    OsType = AzureNative.Compute.OperatingSystemTypes.Linux,
                },
            },
        });
    
    });
    
    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.NewImage(ctx, "image", &compute.ImageArgs{
    ImageName: pulumi.String("myImage"),
    Location: pulumi.String("West US"),
    ResourceGroupName: pulumi.String("myResourceGroup"),
    StorageProfile: compute.ImageStorageProfileResponse{
    OsDisk: interface{}{
    DiskEncryptionSet: &compute.DiskEncryptionSetParametersArgs{
    Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}"),
    },
    ManagedDisk: &compute.SubResourceArgs{
    Id: pulumi.String("subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk"),
    },
    OsState: compute.OperatingSystemStateTypesGeneralized,
    OsType: compute.OperatingSystemTypesLinux,
    },
    },
    })
    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.azurenative.compute.Image;
    import com.pulumi.azurenative.compute.ImageArgs;
    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 image = new Image("image", ImageArgs.builder()        
                .imageName("myImage")
                .location("West US")
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.of("osDisk", Map.ofEntries(
                    Map.entry("diskEncryptionSet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}")),
                    Map.entry("managedDisk", Map.of("id", "subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk")),
                    Map.entry("osState", "Generalized"),
                    Map.entry("osType", "Linux")
                )))
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    image = azure_native.compute.Image("image",
        image_name="myImage",
        location="West US",
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.ImageStorageProfileResponseArgs(
            os_disk={
                "diskEncryptionSet": azure_native.compute.DiskEncryptionSetParametersArgs(
                    id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                ),
                "managedDisk": azure_native.compute.SubResourceArgs(
                    id="subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk",
                ),
                "osState": azure_native.compute.OperatingSystemStateTypes.GENERALIZED,
                "osType": azure_native.compute.OperatingSystemTypes.LINUX,
            },
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const image = new azure_native.compute.Image("image", {
        imageName: "myImage",
        location: "West US",
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            osDisk: {
                diskEncryptionSet: {
                    id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                },
                managedDisk: {
                    id: "subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk",
                },
                osState: azure_native.compute.OperatingSystemStateTypes.Generalized,
                osType: azure_native.compute.OperatingSystemTypes.Linux,
            },
        },
    });
    
    resources:
      image:
        type: azure-native:compute:Image
        properties:
          imageName: myImage
          location: West US
          resourceGroupName: myResourceGroup
          storageProfile:
            osDisk:
              diskEncryptionSet:
                id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}
              managedDisk:
                id: subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk
              osState: Generalized
              osType: Linux
    

    Create a virtual machine image from a snapshot.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var image = new AzureNative.Compute.Image("image", new()
        {
            ImageName = "myImage",
            Location = "West US",
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.ImageStorageProfileArgs
            {
                OsDisk = new AzureNative.Compute.Inputs.ImageOSDiskArgs
                {
                    OsState = AzureNative.Compute.OperatingSystemStateTypes.Generalized,
                    OsType = AzureNative.Compute.OperatingSystemTypes.Linux,
                    Snapshot = new AzureNative.Compute.Inputs.SubResourceArgs
                    {
                        Id = "subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot",
                    },
                },
                ZoneResilient = false,
            },
        });
    
    });
    
    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.NewImage(ctx, "image", &compute.ImageArgs{
    ImageName: pulumi.String("myImage"),
    Location: pulumi.String("West US"),
    ResourceGroupName: pulumi.String("myResourceGroup"),
    StorageProfile: compute.ImageStorageProfileResponse{
    OsDisk: interface{}{
    OsState: compute.OperatingSystemStateTypesGeneralized,
    OsType: compute.OperatingSystemTypesLinux,
    Snapshot: &compute.SubResourceArgs{
    Id: pulumi.String("subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot"),
    },
    },
    ZoneResilient: pulumi.Bool(false),
    },
    })
    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.azurenative.compute.Image;
    import com.pulumi.azurenative.compute.ImageArgs;
    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 image = new Image("image", ImageArgs.builder()        
                .imageName("myImage")
                .location("West US")
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("osState", "Generalized"),
                        Map.entry("osType", "Linux"),
                        Map.entry("snapshot", Map.of("id", "subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot"))
                    )),
                    Map.entry("zoneResilient", false)
                ))
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    image = azure_native.compute.Image("image",
        image_name="myImage",
        location="West US",
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.ImageStorageProfileResponseArgs(
            os_disk={
                "osState": azure_native.compute.OperatingSystemStateTypes.GENERALIZED,
                "osType": azure_native.compute.OperatingSystemTypes.LINUX,
                "snapshot": azure_native.compute.SubResourceArgs(
                    id="subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot",
                ),
            },
            zone_resilient=False,
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const image = new azure_native.compute.Image("image", {
        imageName: "myImage",
        location: "West US",
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            osDisk: {
                osState: azure_native.compute.OperatingSystemStateTypes.Generalized,
                osType: azure_native.compute.OperatingSystemTypes.Linux,
                snapshot: {
                    id: "subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot",
                },
            },
            zoneResilient: false,
        },
    });
    
    resources:
      image:
        type: azure-native:compute:Image
        properties:
          imageName: myImage
          location: West US
          resourceGroupName: myResourceGroup
          storageProfile:
            osDisk:
              osState: Generalized
              osType: Linux
              snapshot:
                id: subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot
            zoneResilient: false
    

    Create a virtual machine image from an existing virtual machine.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var image = new AzureNative.Compute.Image("image", new()
        {
            ImageName = "myImage",
            Location = "West US",
            ResourceGroupName = "myResourceGroup",
            SourceVirtualMachine = new AzureNative.Compute.Inputs.SubResourceArgs
            {
                Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM",
            },
        });
    
    });
    
    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.NewImage(ctx, "image", &compute.ImageArgs{
    			ImageName:         pulumi.String("myImage"),
    			Location:          pulumi.String("West US"),
    			ResourceGroupName: pulumi.String("myResourceGroup"),
    			SourceVirtualMachine: &compute.SubResourceArgs{
    				Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM"),
    			},
    		})
    		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.azurenative.compute.Image;
    import com.pulumi.azurenative.compute.ImageArgs;
    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 image = new Image("image", ImageArgs.builder()        
                .imageName("myImage")
                .location("West US")
                .resourceGroupName("myResourceGroup")
                .sourceVirtualMachine(Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM"))
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    image = azure_native.compute.Image("image",
        image_name="myImage",
        location="West US",
        resource_group_name="myResourceGroup",
        source_virtual_machine=azure_native.compute.SubResourceArgs(
            id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM",
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const image = new azure_native.compute.Image("image", {
        imageName: "myImage",
        location: "West US",
        resourceGroupName: "myResourceGroup",
        sourceVirtualMachine: {
            id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM",
        },
    });
    
    resources:
      image:
        type: azure-native:compute:Image
        properties:
          imageName: myImage
          location: West US
          resourceGroupName: myResourceGroup
          sourceVirtualMachine:
            id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachines/myVM
    

    Create a virtual machine image that includes a data disk from a blob.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var image = new AzureNative.Compute.Image("image", new()
        {
            ImageName = "myImage",
            Location = "West US",
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.ImageStorageProfileArgs
            {
                DataDisks = new[]
                {
                    new AzureNative.Compute.Inputs.ImageDataDiskArgs
                    {
                        BlobUri = "https://mystorageaccount.blob.core.windows.net/dataimages/dataimage.vhd",
                        Lun = 1,
                    },
                },
                OsDisk = new AzureNative.Compute.Inputs.ImageOSDiskArgs
                {
                    BlobUri = "https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd",
                    OsState = AzureNative.Compute.OperatingSystemStateTypes.Generalized,
                    OsType = AzureNative.Compute.OperatingSystemTypes.Linux,
                },
                ZoneResilient = false,
            },
        });
    
    });
    
    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.NewImage(ctx, "image", &compute.ImageArgs{
    			ImageName:         pulumi.String("myImage"),
    			Location:          pulumi.String("West US"),
    			ResourceGroupName: pulumi.String("myResourceGroup"),
    			StorageProfile: compute.ImageStorageProfileResponse{
    				DataDisks: compute.ImageDataDiskArray{
    					&compute.ImageDataDiskArgs{
    						BlobUri: pulumi.String("https://mystorageaccount.blob.core.windows.net/dataimages/dataimage.vhd"),
    						Lun:     pulumi.Int(1),
    					},
    				},
    				OsDisk: &compute.ImageOSDiskArgs{
    					BlobUri: pulumi.String("https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd"),
    					OsState: compute.OperatingSystemStateTypesGeneralized,
    					OsType:  compute.OperatingSystemTypesLinux,
    				},
    				ZoneResilient: pulumi.Bool(false),
    			},
    		})
    		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.azurenative.compute.Image;
    import com.pulumi.azurenative.compute.ImageArgs;
    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 image = new Image("image", ImageArgs.builder()        
                .imageName("myImage")
                .location("West US")
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("dataDisks", Map.ofEntries(
                        Map.entry("blobUri", "https://mystorageaccount.blob.core.windows.net/dataimages/dataimage.vhd"),
                        Map.entry("lun", 1)
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("blobUri", "https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd"),
                        Map.entry("osState", "Generalized"),
                        Map.entry("osType", "Linux")
                    )),
                    Map.entry("zoneResilient", false)
                ))
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    image = azure_native.compute.Image("image",
        image_name="myImage",
        location="West US",
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.ImageStorageProfileResponseArgs(
            data_disks=[azure_native.compute.ImageDataDiskArgs(
                blob_uri="https://mystorageaccount.blob.core.windows.net/dataimages/dataimage.vhd",
                lun=1,
            )],
            os_disk=azure_native.compute.ImageOSDiskArgs(
                blob_uri="https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd",
                os_state=azure_native.compute.OperatingSystemStateTypes.GENERALIZED,
                os_type=azure_native.compute.OperatingSystemTypes.LINUX,
            ),
            zone_resilient=False,
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const image = new azure_native.compute.Image("image", {
        imageName: "myImage",
        location: "West US",
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            dataDisks: [{
                blobUri: "https://mystorageaccount.blob.core.windows.net/dataimages/dataimage.vhd",
                lun: 1,
            }],
            osDisk: {
                blobUri: "https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd",
                osState: azure_native.compute.OperatingSystemStateTypes.Generalized,
                osType: azure_native.compute.OperatingSystemTypes.Linux,
            },
            zoneResilient: false,
        },
    });
    
    resources:
      image:
        type: azure-native:compute:Image
        properties:
          imageName: myImage
          location: West US
          resourceGroupName: myResourceGroup
          storageProfile:
            dataDisks:
              - blobUri: https://mystorageaccount.blob.core.windows.net/dataimages/dataimage.vhd
                lun: 1
            osDisk:
              blobUri: https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd
              osState: Generalized
              osType: Linux
            zoneResilient: false
    

    Create a virtual machine image that includes a data disk from a managed disk.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var image = new AzureNative.Compute.Image("image", new()
        {
            ImageName = "myImage",
            Location = "West US",
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.ImageStorageProfileArgs
            {
                DataDisks = new[]
                {
                    new AzureNative.Compute.Inputs.ImageDataDiskArgs
                    {
                        Lun = 1,
                        ManagedDisk = new AzureNative.Compute.Inputs.SubResourceArgs
                        {
                            Id = "subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk2",
                        },
                    },
                },
                OsDisk = new AzureNative.Compute.Inputs.ImageOSDiskArgs
                {
                    ManagedDisk = new AzureNative.Compute.Inputs.SubResourceArgs
                    {
                        Id = "subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk",
                    },
                    OsState = AzureNative.Compute.OperatingSystemStateTypes.Generalized,
                    OsType = AzureNative.Compute.OperatingSystemTypes.Linux,
                },
                ZoneResilient = false,
            },
        });
    
    });
    
    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.NewImage(ctx, "image", &compute.ImageArgs{
    ImageName: pulumi.String("myImage"),
    Location: pulumi.String("West US"),
    ResourceGroupName: pulumi.String("myResourceGroup"),
    StorageProfile: compute.ImageStorageProfileResponse{
    DataDisks: compute.ImageDataDiskArray{
    interface{}{
    Lun: pulumi.Int(1),
    ManagedDisk: &compute.SubResourceArgs{
    Id: pulumi.String("subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk2"),
    },
    },
    },
    OsDisk: interface{}{
    ManagedDisk: &compute.SubResourceArgs{
    Id: pulumi.String("subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk"),
    },
    OsState: compute.OperatingSystemStateTypesGeneralized,
    OsType: compute.OperatingSystemTypesLinux,
    },
    ZoneResilient: pulumi.Bool(false),
    },
    })
    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.azurenative.compute.Image;
    import com.pulumi.azurenative.compute.ImageArgs;
    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 image = new Image("image", ImageArgs.builder()        
                .imageName("myImage")
                .location("West US")
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("dataDisks", Map.ofEntries(
                        Map.entry("lun", 1),
                        Map.entry("managedDisk", Map.of("id", "subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk2"))
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("managedDisk", Map.of("id", "subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk")),
                        Map.entry("osState", "Generalized"),
                        Map.entry("osType", "Linux")
                    )),
                    Map.entry("zoneResilient", false)
                ))
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    image = azure_native.compute.Image("image",
        image_name="myImage",
        location="West US",
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.ImageStorageProfileResponseArgs(
            data_disks=[{
                "lun": 1,
                "managedDisk": azure_native.compute.SubResourceArgs(
                    id="subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk2",
                ),
            }],
            os_disk={
                "managedDisk": azure_native.compute.SubResourceArgs(
                    id="subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk",
                ),
                "osState": azure_native.compute.OperatingSystemStateTypes.GENERALIZED,
                "osType": azure_native.compute.OperatingSystemTypes.LINUX,
            },
            zone_resilient=False,
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const image = new azure_native.compute.Image("image", {
        imageName: "myImage",
        location: "West US",
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            dataDisks: [{
                lun: 1,
                managedDisk: {
                    id: "subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk2",
                },
            }],
            osDisk: {
                managedDisk: {
                    id: "subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk",
                },
                osState: azure_native.compute.OperatingSystemStateTypes.Generalized,
                osType: azure_native.compute.OperatingSystemTypes.Linux,
            },
            zoneResilient: false,
        },
    });
    
    resources:
      image:
        type: azure-native:compute:Image
        properties:
          imageName: myImage
          location: West US
          resourceGroupName: myResourceGroup
          storageProfile:
            dataDisks:
              - lun: 1
                managedDisk:
                  id: subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk2
            osDisk:
              managedDisk:
                id: subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/myManagedDisk
              osState: Generalized
              osType: Linux
            zoneResilient: false
    

    Create a virtual machine image that includes a data disk from a snapshot.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var image = new AzureNative.Compute.Image("image", new()
        {
            ImageName = "myImage",
            Location = "West US",
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.ImageStorageProfileArgs
            {
                DataDisks = new[]
                {
                    new AzureNative.Compute.Inputs.ImageDataDiskArgs
                    {
                        Lun = 1,
                        Snapshot = new AzureNative.Compute.Inputs.SubResourceArgs
                        {
                            Id = "subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot2",
                        },
                    },
                },
                OsDisk = new AzureNative.Compute.Inputs.ImageOSDiskArgs
                {
                    OsState = AzureNative.Compute.OperatingSystemStateTypes.Generalized,
                    OsType = AzureNative.Compute.OperatingSystemTypes.Linux,
                    Snapshot = new AzureNative.Compute.Inputs.SubResourceArgs
                    {
                        Id = "subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot",
                    },
                },
                ZoneResilient = true,
            },
        });
    
    });
    
    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.NewImage(ctx, "image", &compute.ImageArgs{
    ImageName: pulumi.String("myImage"),
    Location: pulumi.String("West US"),
    ResourceGroupName: pulumi.String("myResourceGroup"),
    StorageProfile: compute.ImageStorageProfileResponse{
    DataDisks: compute.ImageDataDiskArray{
    interface{}{
    Lun: pulumi.Int(1),
    Snapshot: &compute.SubResourceArgs{
    Id: pulumi.String("subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot2"),
    },
    },
    },
    OsDisk: interface{}{
    OsState: compute.OperatingSystemStateTypesGeneralized,
    OsType: compute.OperatingSystemTypesLinux,
    Snapshot: &compute.SubResourceArgs{
    Id: pulumi.String("subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot"),
    },
    },
    ZoneResilient: pulumi.Bool(true),
    },
    })
    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.azurenative.compute.Image;
    import com.pulumi.azurenative.compute.ImageArgs;
    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 image = new Image("image", ImageArgs.builder()        
                .imageName("myImage")
                .location("West US")
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("dataDisks", Map.ofEntries(
                        Map.entry("lun", 1),
                        Map.entry("snapshot", Map.of("id", "subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot2"))
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("osState", "Generalized"),
                        Map.entry("osType", "Linux"),
                        Map.entry("snapshot", Map.of("id", "subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot"))
                    )),
                    Map.entry("zoneResilient", true)
                ))
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    image = azure_native.compute.Image("image",
        image_name="myImage",
        location="West US",
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.ImageStorageProfileResponseArgs(
            data_disks=[{
                "lun": 1,
                "snapshot": azure_native.compute.SubResourceArgs(
                    id="subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot2",
                ),
            }],
            os_disk={
                "osState": azure_native.compute.OperatingSystemStateTypes.GENERALIZED,
                "osType": azure_native.compute.OperatingSystemTypes.LINUX,
                "snapshot": azure_native.compute.SubResourceArgs(
                    id="subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot",
                ),
            },
            zone_resilient=True,
        ))
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const image = new azure_native.compute.Image("image", {
        imageName: "myImage",
        location: "West US",
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            dataDisks: [{
                lun: 1,
                snapshot: {
                    id: "subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot2",
                },
            }],
            osDisk: {
                osState: azure_native.compute.OperatingSystemStateTypes.Generalized,
                osType: azure_native.compute.OperatingSystemTypes.Linux,
                snapshot: {
                    id: "subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot",
                },
            },
            zoneResilient: true,
        },
    });
    
    resources:
      image:
        type: azure-native:compute:Image
        properties:
          imageName: myImage
          location: West US
          resourceGroupName: myResourceGroup
          storageProfile:
            dataDisks:
              - lun: 1
                snapshot:
                  id: subscriptions/{subscriptionId}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot2
            osDisk:
              osState: Generalized
              osType: Linux
              snapshot:
                id: subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/snapshots/mySnapshot
            zoneResilient: true
    

    Create Image Resource

    new Image(name: string, args: ImageArgs, opts?: CustomResourceOptions);
    @overload
    def Image(resource_name: str,
              opts: Optional[ResourceOptions] = None,
              extended_location: Optional[ExtendedLocationArgs] = None,
              hyper_v_generation: Optional[Union[str, HyperVGenerationTypes]] = None,
              image_name: Optional[str] = None,
              location: Optional[str] = None,
              resource_group_name: Optional[str] = None,
              source_virtual_machine: Optional[SubResourceArgs] = None,
              storage_profile: Optional[ImageStorageProfileArgs] = None,
              tags: Optional[Mapping[str, str]] = None)
    @overload
    def Image(resource_name: str,
              args: ImageArgs,
              opts: Optional[ResourceOptions] = None)
    func NewImage(ctx *Context, name string, args ImageArgs, opts ...ResourceOption) (*Image, error)
    public Image(string name, ImageArgs args, CustomResourceOptions? opts = null)
    public Image(String name, ImageArgs args)
    public Image(String name, ImageArgs args, CustomResourceOptions options)
    
    type: azure-native:compute:Image
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    
    name string
    The unique name of the resource.
    args ImageArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args ImageArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args ImageArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ImageArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ImageArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Image Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    The Image resource accepts the following input properties:

    ResourceGroupName string
    The name of the resource group.
    ExtendedLocation Pulumi.AzureNative.Compute.Inputs.ExtendedLocation
    The extended location of the Image.
    HyperVGeneration string | Pulumi.AzureNative.Compute.HyperVGenerationTypes
    Specifies the HyperVGenerationType of the VirtualMachine created from the image. From API Version 2019-03-01 if the image source is a blob, then we need the user to specify the value, if the source is managed resource like disk or snapshot, we may require the user to specify the property if we cannot deduce it from the source managed resource.
    ImageName string
    The name of the image.
    Location string
    Resource location
    SourceVirtualMachine Pulumi.AzureNative.Compute.Inputs.SubResource
    The source virtual machine from which Image is created.
    StorageProfile Pulumi.AzureNative.Compute.Inputs.ImageStorageProfile
    Specifies the storage settings for the virtual machine disks.
    Tags Dictionary<string, string>
    Resource tags
    ResourceGroupName string
    The name of the resource group.
    ExtendedLocation ExtendedLocationArgs
    The extended location of the Image.
    HyperVGeneration string | HyperVGenerationTypes
    Specifies the HyperVGenerationType of the VirtualMachine created from the image. From API Version 2019-03-01 if the image source is a blob, then we need the user to specify the value, if the source is managed resource like disk or snapshot, we may require the user to specify the property if we cannot deduce it from the source managed resource.
    ImageName string
    The name of the image.
    Location string
    Resource location
    SourceVirtualMachine SubResourceArgs
    The source virtual machine from which Image is created.
    StorageProfile ImageStorageProfileArgs
    Specifies the storage settings for the virtual machine disks.
    Tags map[string]string
    Resource tags
    resourceGroupName String
    The name of the resource group.
    extendedLocation ExtendedLocation
    The extended location of the Image.
    hyperVGeneration String | HyperVGenerationTypes
    Specifies the HyperVGenerationType of the VirtualMachine created from the image. From API Version 2019-03-01 if the image source is a blob, then we need the user to specify the value, if the source is managed resource like disk or snapshot, we may require the user to specify the property if we cannot deduce it from the source managed resource.
    imageName String
    The name of the image.
    location String
    Resource location
    sourceVirtualMachine SubResource
    The source virtual machine from which Image is created.
    storageProfile ImageStorageProfile
    Specifies the storage settings for the virtual machine disks.
    tags Map<String,String>
    Resource tags
    resourceGroupName string
    The name of the resource group.
    extendedLocation ExtendedLocation
    The extended location of the Image.
    hyperVGeneration string | HyperVGenerationTypes
    Specifies the HyperVGenerationType of the VirtualMachine created from the image. From API Version 2019-03-01 if the image source is a blob, then we need the user to specify the value, if the source is managed resource like disk or snapshot, we may require the user to specify the property if we cannot deduce it from the source managed resource.
    imageName string
    The name of the image.
    location string
    Resource location
    sourceVirtualMachine SubResource
    The source virtual machine from which Image is created.
    storageProfile ImageStorageProfile
    Specifies the storage settings for the virtual machine disks.
    tags {[key: string]: string}
    Resource tags
    resource_group_name str
    The name of the resource group.
    extended_location ExtendedLocationArgs
    The extended location of the Image.
    hyper_v_generation str | HyperVGenerationTypes
    Specifies the HyperVGenerationType of the VirtualMachine created from the image. From API Version 2019-03-01 if the image source is a blob, then we need the user to specify the value, if the source is managed resource like disk or snapshot, we may require the user to specify the property if we cannot deduce it from the source managed resource.
    image_name str
    The name of the image.
    location str
    Resource location
    source_virtual_machine SubResourceArgs
    The source virtual machine from which Image is created.
    storage_profile ImageStorageProfileArgs
    Specifies the storage settings for the virtual machine disks.
    tags Mapping[str, str]
    Resource tags
    resourceGroupName String
    The name of the resource group.
    extendedLocation Property Map
    The extended location of the Image.
    hyperVGeneration String | "V1" | "V2"
    Specifies the HyperVGenerationType of the VirtualMachine created from the image. From API Version 2019-03-01 if the image source is a blob, then we need the user to specify the value, if the source is managed resource like disk or snapshot, we may require the user to specify the property if we cannot deduce it from the source managed resource.
    imageName String
    The name of the image.
    location String
    Resource location
    sourceVirtualMachine Property Map
    The source virtual machine from which Image is created.
    storageProfile Property Map
    Specifies the storage settings for the virtual machine disks.
    tags Map<String>
    Resource tags

    Outputs

    All input properties are implicitly available as output properties. Additionally, the Image resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    Name string
    Resource name
    ProvisioningState string
    The provisioning state.
    Type string
    Resource type
    Id string
    The provider-assigned unique ID for this managed resource.
    Name string
    Resource name
    ProvisioningState string
    The provisioning state.
    Type string
    Resource type
    id String
    The provider-assigned unique ID for this managed resource.
    name String
    Resource name
    provisioningState String
    The provisioning state.
    type String
    Resource type
    id string
    The provider-assigned unique ID for this managed resource.
    name string
    Resource name
    provisioningState string
    The provisioning state.
    type string
    Resource type
    id str
    The provider-assigned unique ID for this managed resource.
    name str
    Resource name
    provisioning_state str
    The provisioning state.
    type str
    Resource type
    id String
    The provider-assigned unique ID for this managed resource.
    name String
    Resource name
    provisioningState String
    The provisioning state.
    type String
    Resource type

    Supporting Types

    CachingTypes, CachingTypesArgs

    None
    None
    ReadOnly
    ReadOnly
    ReadWrite
    ReadWrite
    CachingTypesNone
    None
    CachingTypesReadOnly
    ReadOnly
    CachingTypesReadWrite
    ReadWrite
    None
    None
    ReadOnly
    ReadOnly
    ReadWrite
    ReadWrite
    None
    None
    ReadOnly
    ReadOnly
    ReadWrite
    ReadWrite
    NONE
    None
    READ_ONLY
    ReadOnly
    READ_WRITE
    ReadWrite
    "None"
    None
    "ReadOnly"
    ReadOnly
    "ReadWrite"
    ReadWrite

    DiskEncryptionSetParameters, DiskEncryptionSetParametersArgs

    Id string
    Resource Id
    Id string
    Resource Id
    id String
    Resource Id
    id string
    Resource Id
    id str
    Resource Id
    id String
    Resource Id

    DiskEncryptionSetParametersResponse, DiskEncryptionSetParametersResponseArgs

    Id string
    Resource Id
    Id string
    Resource Id
    id String
    Resource Id
    id string
    Resource Id
    id str
    Resource Id
    id String
    Resource Id

    ExtendedLocation, ExtendedLocationArgs

    Name string
    The name of the extended location.
    Type string | Pulumi.AzureNative.Compute.ExtendedLocationTypes
    The type of the extended location.
    Name string
    The name of the extended location.
    Type string | ExtendedLocationTypes
    The type of the extended location.
    name String
    The name of the extended location.
    type String | ExtendedLocationTypes
    The type of the extended location.
    name string
    The name of the extended location.
    type string | ExtendedLocationTypes
    The type of the extended location.
    name str
    The name of the extended location.
    type str | ExtendedLocationTypes
    The type of the extended location.
    name String
    The name of the extended location.
    type String | "EdgeZone"
    The type of the extended location.

    ExtendedLocationResponse, ExtendedLocationResponseArgs

    Name string
    The name of the extended location.
    Type string
    The type of the extended location.
    Name string
    The name of the extended location.
    Type string
    The type of the extended location.
    name String
    The name of the extended location.
    type String
    The type of the extended location.
    name string
    The name of the extended location.
    type string
    The type of the extended location.
    name str
    The name of the extended location.
    type str
    The type of the extended location.
    name String
    The name of the extended location.
    type String
    The type of the extended location.

    ExtendedLocationTypes, ExtendedLocationTypesArgs

    EdgeZone
    EdgeZone
    ExtendedLocationTypesEdgeZone
    EdgeZone
    EdgeZone
    EdgeZone
    EdgeZone
    EdgeZone
    EDGE_ZONE
    EdgeZone
    "EdgeZone"
    EdgeZone

    HyperVGenerationTypes, HyperVGenerationTypesArgs

    V1
    V1
    V2
    V2
    HyperVGenerationTypesV1
    V1
    HyperVGenerationTypesV2
    V2
    V1
    V1
    V2
    V2
    V1
    V1
    V2
    V2
    V1
    V1
    V2
    V2
    "V1"
    V1
    "V2"
    V2

    ImageDataDisk, ImageDataDiskArgs

    Lun int
    Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
    BlobUri string
    The Virtual Hard Disk.
    Caching Pulumi.AzureNative.Compute.CachingTypes
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    DiskEncryptionSet Pulumi.AzureNative.Compute.Inputs.DiskEncryptionSetParameters
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    DiskSizeGB int
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    ManagedDisk Pulumi.AzureNative.Compute.Inputs.SubResource
    The managedDisk.
    Snapshot Pulumi.AzureNative.Compute.Inputs.SubResource
    The snapshot.
    StorageAccountType string | Pulumi.AzureNative.Compute.StorageAccountTypes
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
    Lun int
    Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
    BlobUri string
    The Virtual Hard Disk.
    Caching CachingTypes
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    DiskEncryptionSet DiskEncryptionSetParameters
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    DiskSizeGB int
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    ManagedDisk SubResource
    The managedDisk.
    Snapshot SubResource
    The snapshot.
    StorageAccountType string | StorageAccountTypes
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
    lun Integer
    Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
    blobUri String
    The Virtual Hard Disk.
    caching CachingTypes
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    diskEncryptionSet DiskEncryptionSetParameters
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    diskSizeGB Integer
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    managedDisk SubResource
    The managedDisk.
    snapshot SubResource
    The snapshot.
    storageAccountType String | StorageAccountTypes
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
    lun number
    Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
    blobUri string
    The Virtual Hard Disk.
    caching CachingTypes
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    diskEncryptionSet DiskEncryptionSetParameters
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    diskSizeGB number
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    managedDisk SubResource
    The managedDisk.
    snapshot SubResource
    The snapshot.
    storageAccountType string | StorageAccountTypes
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
    lun int
    Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
    blob_uri str
    The Virtual Hard Disk.
    caching CachingTypes
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    disk_encryption_set DiskEncryptionSetParameters
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    disk_size_gb int
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    managed_disk SubResource
    The managedDisk.
    snapshot SubResource
    The snapshot.
    storage_account_type str | StorageAccountTypes
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
    lun Number
    Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
    blobUri String
    The Virtual Hard Disk.
    caching "None" | "ReadOnly" | "ReadWrite"
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    diskEncryptionSet Property Map
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    diskSizeGB Number
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    managedDisk Property Map
    The managedDisk.
    snapshot Property Map
    The snapshot.
    storageAccountType String | "Standard_LRS" | "Premium_LRS" | "StandardSSD_LRS" | "UltraSSD_LRS" | "Premium_ZRS" | "StandardSSD_ZRS" | "PremiumV2_LRS"
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.

    ImageDataDiskResponse, ImageDataDiskResponseArgs

    Lun int
    Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
    BlobUri string
    The Virtual Hard Disk.
    Caching string
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    DiskEncryptionSet Pulumi.AzureNative.Compute.Inputs.DiskEncryptionSetParametersResponse
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    DiskSizeGB int
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    ManagedDisk Pulumi.AzureNative.Compute.Inputs.SubResourceResponse
    The managedDisk.
    Snapshot Pulumi.AzureNative.Compute.Inputs.SubResourceResponse
    The snapshot.
    StorageAccountType string
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
    Lun int
    Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
    BlobUri string
    The Virtual Hard Disk.
    Caching string
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    DiskEncryptionSet DiskEncryptionSetParametersResponse
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    DiskSizeGB int
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    ManagedDisk SubResourceResponse
    The managedDisk.
    Snapshot SubResourceResponse
    The snapshot.
    StorageAccountType string
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
    lun Integer
    Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
    blobUri String
    The Virtual Hard Disk.
    caching String
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    diskEncryptionSet DiskEncryptionSetParametersResponse
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    diskSizeGB Integer
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    managedDisk SubResourceResponse
    The managedDisk.
    snapshot SubResourceResponse
    The snapshot.
    storageAccountType String
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
    lun number
    Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
    blobUri string
    The Virtual Hard Disk.
    caching string
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    diskEncryptionSet DiskEncryptionSetParametersResponse
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    diskSizeGB number
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    managedDisk SubResourceResponse
    The managedDisk.
    snapshot SubResourceResponse
    The snapshot.
    storageAccountType string
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
    lun int
    Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
    blob_uri str
    The Virtual Hard Disk.
    caching str
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    disk_encryption_set DiskEncryptionSetParametersResponse
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    disk_size_gb int
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    managed_disk SubResourceResponse
    The managedDisk.
    snapshot SubResourceResponse
    The snapshot.
    storage_account_type str
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
    lun Number
    Specifies the logical unit number of the data disk. This value is used to identify data disks within the VM and therefore must be unique for each data disk attached to a VM.
    blobUri String
    The Virtual Hard Disk.
    caching String
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    diskEncryptionSet Property Map
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    diskSizeGB Number
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    managedDisk Property Map
    The managedDisk.
    snapshot Property Map
    The snapshot.
    storageAccountType String
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.

    ImageOSDisk, ImageOSDiskArgs

    OsState Pulumi.AzureNative.Compute.OperatingSystemStateTypes
    The OS State. For managed images, use Generalized.
    OsType Pulumi.AzureNative.Compute.OperatingSystemTypes
    This property allows you to specify the type of the OS that is included in the disk if creating a VM from a custom image. Possible values are: Windows, Linux.
    BlobUri string
    The Virtual Hard Disk.
    Caching Pulumi.AzureNative.Compute.CachingTypes
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    DiskEncryptionSet Pulumi.AzureNative.Compute.Inputs.DiskEncryptionSetParameters
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    DiskSizeGB int
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    ManagedDisk Pulumi.AzureNative.Compute.Inputs.SubResource
    The managedDisk.
    Snapshot Pulumi.AzureNative.Compute.Inputs.SubResource
    The snapshot.
    StorageAccountType string | Pulumi.AzureNative.Compute.StorageAccountTypes
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
    OsState OperatingSystemStateTypes
    The OS State. For managed images, use Generalized.
    OsType OperatingSystemTypes
    This property allows you to specify the type of the OS that is included in the disk if creating a VM from a custom image. Possible values are: Windows, Linux.
    BlobUri string
    The Virtual Hard Disk.
    Caching CachingTypes
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    DiskEncryptionSet DiskEncryptionSetParameters
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    DiskSizeGB int
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    ManagedDisk SubResource
    The managedDisk.
    Snapshot SubResource
    The snapshot.
    StorageAccountType string | StorageAccountTypes
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
    osState OperatingSystemStateTypes
    The OS State. For managed images, use Generalized.
    osType OperatingSystemTypes
    This property allows you to specify the type of the OS that is included in the disk if creating a VM from a custom image. Possible values are: Windows, Linux.
    blobUri String
    The Virtual Hard Disk.
    caching CachingTypes
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    diskEncryptionSet DiskEncryptionSetParameters
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    diskSizeGB Integer
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    managedDisk SubResource
    The managedDisk.
    snapshot SubResource
    The snapshot.
    storageAccountType String | StorageAccountTypes
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
    osState OperatingSystemStateTypes
    The OS State. For managed images, use Generalized.
    osType OperatingSystemTypes
    This property allows you to specify the type of the OS that is included in the disk if creating a VM from a custom image. Possible values are: Windows, Linux.
    blobUri string
    The Virtual Hard Disk.
    caching CachingTypes
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    diskEncryptionSet DiskEncryptionSetParameters
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    diskSizeGB number
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    managedDisk SubResource
    The managedDisk.
    snapshot SubResource
    The snapshot.
    storageAccountType string | StorageAccountTypes
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
    os_state OperatingSystemStateTypes
    The OS State. For managed images, use Generalized.
    os_type OperatingSystemTypes
    This property allows you to specify the type of the OS that is included in the disk if creating a VM from a custom image. Possible values are: Windows, Linux.
    blob_uri str
    The Virtual Hard Disk.
    caching CachingTypes
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    disk_encryption_set DiskEncryptionSetParameters
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    disk_size_gb int
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    managed_disk SubResource
    The managedDisk.
    snapshot SubResource
    The snapshot.
    storage_account_type str | StorageAccountTypes
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
    osState "Generalized" | "Specialized"
    The OS State. For managed images, use Generalized.
    osType "Windows" | "Linux"
    This property allows you to specify the type of the OS that is included in the disk if creating a VM from a custom image. Possible values are: Windows, Linux.
    blobUri String
    The Virtual Hard Disk.
    caching "None" | "ReadOnly" | "ReadWrite"
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    diskEncryptionSet Property Map
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    diskSizeGB Number
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    managedDisk Property Map
    The managedDisk.
    snapshot Property Map
    The snapshot.
    storageAccountType String | "Standard_LRS" | "Premium_LRS" | "StandardSSD_LRS" | "UltraSSD_LRS" | "Premium_ZRS" | "StandardSSD_ZRS" | "PremiumV2_LRS"
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.

    ImageOSDiskResponse, ImageOSDiskResponseArgs

    OsState string
    The OS State. For managed images, use Generalized.
    OsType string
    This property allows you to specify the type of the OS that is included in the disk if creating a VM from a custom image. Possible values are: Windows, Linux.
    BlobUri string
    The Virtual Hard Disk.
    Caching string
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    DiskEncryptionSet Pulumi.AzureNative.Compute.Inputs.DiskEncryptionSetParametersResponse
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    DiskSizeGB int
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    ManagedDisk Pulumi.AzureNative.Compute.Inputs.SubResourceResponse
    The managedDisk.
    Snapshot Pulumi.AzureNative.Compute.Inputs.SubResourceResponse
    The snapshot.
    StorageAccountType string
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
    OsState string
    The OS State. For managed images, use Generalized.
    OsType string
    This property allows you to specify the type of the OS that is included in the disk if creating a VM from a custom image. Possible values are: Windows, Linux.
    BlobUri string
    The Virtual Hard Disk.
    Caching string
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    DiskEncryptionSet DiskEncryptionSetParametersResponse
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    DiskSizeGB int
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    ManagedDisk SubResourceResponse
    The managedDisk.
    Snapshot SubResourceResponse
    The snapshot.
    StorageAccountType string
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
    osState String
    The OS State. For managed images, use Generalized.
    osType String
    This property allows you to specify the type of the OS that is included in the disk if creating a VM from a custom image. Possible values are: Windows, Linux.
    blobUri String
    The Virtual Hard Disk.
    caching String
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    diskEncryptionSet DiskEncryptionSetParametersResponse
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    diskSizeGB Integer
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    managedDisk SubResourceResponse
    The managedDisk.
    snapshot SubResourceResponse
    The snapshot.
    storageAccountType String
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
    osState string
    The OS State. For managed images, use Generalized.
    osType string
    This property allows you to specify the type of the OS that is included in the disk if creating a VM from a custom image. Possible values are: Windows, Linux.
    blobUri string
    The Virtual Hard Disk.
    caching string
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    diskEncryptionSet DiskEncryptionSetParametersResponse
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    diskSizeGB number
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    managedDisk SubResourceResponse
    The managedDisk.
    snapshot SubResourceResponse
    The snapshot.
    storageAccountType string
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
    os_state str
    The OS State. For managed images, use Generalized.
    os_type str
    This property allows you to specify the type of the OS that is included in the disk if creating a VM from a custom image. Possible values are: Windows, Linux.
    blob_uri str
    The Virtual Hard Disk.
    caching str
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    disk_encryption_set DiskEncryptionSetParametersResponse
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    disk_size_gb int
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    managed_disk SubResourceResponse
    The managedDisk.
    snapshot SubResourceResponse
    The snapshot.
    storage_account_type str
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.
    osState String
    The OS State. For managed images, use Generalized.
    osType String
    This property allows you to specify the type of the OS that is included in the disk if creating a VM from a custom image. Possible values are: Windows, Linux.
    blobUri String
    The Virtual Hard Disk.
    caching String
    Specifies the caching requirements. Possible values are: None, ReadOnly, ReadWrite. The default values are: None for Standard storage. ReadOnly for Premium storage.
    diskEncryptionSet Property Map
    Specifies the customer managed disk encryption set resource id for the managed image disk.
    diskSizeGB Number
    Specifies the size of empty data disks in gigabytes. This element can be used to overwrite the name of the disk in a virtual machine image. This value cannot be larger than 1023 GB.
    managedDisk Property Map
    The managedDisk.
    snapshot Property Map
    The snapshot.
    storageAccountType String
    Specifies the storage account type for the managed disk. NOTE: UltraSSD_LRS can only be used with data disks, it cannot be used with OS Disk.

    ImageStorageProfile, ImageStorageProfileArgs

    DataDisks List<Pulumi.AzureNative.Compute.Inputs.ImageDataDisk>
    Specifies the parameters that are used to add a data disk to a virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    OsDisk Pulumi.AzureNative.Compute.Inputs.ImageOSDisk
    Specifies information about the operating system disk used by the virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    ZoneResilient bool
    Specifies whether an image is zone resilient or not. Default is false. Zone resilient images can be created only in regions that provide Zone Redundant Storage (ZRS).
    DataDisks []ImageDataDisk
    Specifies the parameters that are used to add a data disk to a virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    OsDisk ImageOSDisk
    Specifies information about the operating system disk used by the virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    ZoneResilient bool
    Specifies whether an image is zone resilient or not. Default is false. Zone resilient images can be created only in regions that provide Zone Redundant Storage (ZRS).
    dataDisks List<ImageDataDisk>
    Specifies the parameters that are used to add a data disk to a virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    osDisk ImageOSDisk
    Specifies information about the operating system disk used by the virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    zoneResilient Boolean
    Specifies whether an image is zone resilient or not. Default is false. Zone resilient images can be created only in regions that provide Zone Redundant Storage (ZRS).
    dataDisks ImageDataDisk[]
    Specifies the parameters that are used to add a data disk to a virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    osDisk ImageOSDisk
    Specifies information about the operating system disk used by the virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    zoneResilient boolean
    Specifies whether an image is zone resilient or not. Default is false. Zone resilient images can be created only in regions that provide Zone Redundant Storage (ZRS).
    data_disks Sequence[ImageDataDisk]
    Specifies the parameters that are used to add a data disk to a virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    os_disk ImageOSDisk
    Specifies information about the operating system disk used by the virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    zone_resilient bool
    Specifies whether an image is zone resilient or not. Default is false. Zone resilient images can be created only in regions that provide Zone Redundant Storage (ZRS).
    dataDisks List<Property Map>
    Specifies the parameters that are used to add a data disk to a virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    osDisk Property Map
    Specifies information about the operating system disk used by the virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    zoneResilient Boolean
    Specifies whether an image is zone resilient or not. Default is false. Zone resilient images can be created only in regions that provide Zone Redundant Storage (ZRS).

    ImageStorageProfileResponse, ImageStorageProfileResponseArgs

    DataDisks List<Pulumi.AzureNative.Compute.Inputs.ImageDataDiskResponse>
    Specifies the parameters that are used to add a data disk to a virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    OsDisk Pulumi.AzureNative.Compute.Inputs.ImageOSDiskResponse
    Specifies information about the operating system disk used by the virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    ZoneResilient bool
    Specifies whether an image is zone resilient or not. Default is false. Zone resilient images can be created only in regions that provide Zone Redundant Storage (ZRS).
    DataDisks []ImageDataDiskResponse
    Specifies the parameters that are used to add a data disk to a virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    OsDisk ImageOSDiskResponse
    Specifies information about the operating system disk used by the virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    ZoneResilient bool
    Specifies whether an image is zone resilient or not. Default is false. Zone resilient images can be created only in regions that provide Zone Redundant Storage (ZRS).
    dataDisks List<ImageDataDiskResponse>
    Specifies the parameters that are used to add a data disk to a virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    osDisk ImageOSDiskResponse
    Specifies information about the operating system disk used by the virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    zoneResilient Boolean
    Specifies whether an image is zone resilient or not. Default is false. Zone resilient images can be created only in regions that provide Zone Redundant Storage (ZRS).
    dataDisks ImageDataDiskResponse[]
    Specifies the parameters that are used to add a data disk to a virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    osDisk ImageOSDiskResponse
    Specifies information about the operating system disk used by the virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    zoneResilient boolean
    Specifies whether an image is zone resilient or not. Default is false. Zone resilient images can be created only in regions that provide Zone Redundant Storage (ZRS).
    data_disks Sequence[ImageDataDiskResponse]
    Specifies the parameters that are used to add a data disk to a virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    os_disk ImageOSDiskResponse
    Specifies information about the operating system disk used by the virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    zone_resilient bool
    Specifies whether an image is zone resilient or not. Default is false. Zone resilient images can be created only in regions that provide Zone Redundant Storage (ZRS).
    dataDisks List<Property Map>
    Specifies the parameters that are used to add a data disk to a virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    osDisk Property Map
    Specifies information about the operating system disk used by the virtual machine. For more information about disks, see About disks and VHDs for Azure virtual machines.
    zoneResilient Boolean
    Specifies whether an image is zone resilient or not. Default is false. Zone resilient images can be created only in regions that provide Zone Redundant Storage (ZRS).

    OperatingSystemStateTypes, OperatingSystemStateTypesArgs

    Generalized
    GeneralizedGeneralized image. Needs to be provisioned during deployment time.
    Specialized
    SpecializedSpecialized image. Contains already provisioned OS Disk.
    OperatingSystemStateTypesGeneralized
    GeneralizedGeneralized image. Needs to be provisioned during deployment time.
    OperatingSystemStateTypesSpecialized
    SpecializedSpecialized image. Contains already provisioned OS Disk.
    Generalized
    GeneralizedGeneralized image. Needs to be provisioned during deployment time.
    Specialized
    SpecializedSpecialized image. Contains already provisioned OS Disk.
    Generalized
    GeneralizedGeneralized image. Needs to be provisioned during deployment time.
    Specialized
    SpecializedSpecialized image. Contains already provisioned OS Disk.
    GENERALIZED
    GeneralizedGeneralized image. Needs to be provisioned during deployment time.
    SPECIALIZED
    SpecializedSpecialized image. Contains already provisioned OS Disk.
    "Generalized"
    GeneralizedGeneralized image. Needs to be provisioned during deployment time.
    "Specialized"
    SpecializedSpecialized image. Contains already provisioned OS Disk.

    OperatingSystemTypes, OperatingSystemTypesArgs

    Windows
    Windows
    Linux
    Linux
    OperatingSystemTypesWindows
    Windows
    OperatingSystemTypesLinux
    Linux
    Windows
    Windows
    Linux
    Linux
    Windows
    Windows
    Linux
    Linux
    WINDOWS
    Windows
    LINUX
    Linux
    "Windows"
    Windows
    "Linux"
    Linux

    StorageAccountTypes, StorageAccountTypesArgs

    Standard_LRS
    Standard_LRS
    Premium_LRS
    Premium_LRS
    StandardSSD_LRS
    StandardSSD_LRS
    UltraSSD_LRS
    UltraSSD_LRS
    Premium_ZRS
    Premium_ZRS
    StandardSSD_ZRS
    StandardSSD_ZRS
    PremiumV2_LRS
    PremiumV2_LRS
    StorageAccountTypes_Standard_LRS
    Standard_LRS
    StorageAccountTypes_Premium_LRS
    Premium_LRS
    StorageAccountTypes_StandardSSD_LRS
    StandardSSD_LRS
    StorageAccountTypes_UltraSSD_LRS
    UltraSSD_LRS
    StorageAccountTypes_Premium_ZRS
    Premium_ZRS
    StorageAccountTypes_StandardSSD_ZRS
    StandardSSD_ZRS
    StorageAccountTypes_PremiumV2_LRS
    PremiumV2_LRS
    Standard_LRS
    Standard_LRS
    Premium_LRS
    Premium_LRS
    StandardSSD_LRS
    StandardSSD_LRS
    UltraSSD_LRS
    UltraSSD_LRS
    Premium_ZRS
    Premium_ZRS
    StandardSSD_ZRS
    StandardSSD_ZRS
    PremiumV2_LRS
    PremiumV2_LRS
    Standard_LRS
    Standard_LRS
    Premium_LRS
    Premium_LRS
    StandardSSD_LRS
    StandardSSD_LRS
    UltraSSD_LRS
    UltraSSD_LRS
    Premium_ZRS
    Premium_ZRS
    StandardSSD_ZRS
    StandardSSD_ZRS
    PremiumV2_LRS
    PremiumV2_LRS
    STANDARD_LRS
    Standard_LRS
    PREMIUM_LRS
    Premium_LRS
    STANDARD_SS_D_LRS
    StandardSSD_LRS
    ULTRA_SS_D_LRS
    UltraSSD_LRS
    PREMIUM_ZRS
    Premium_ZRS
    STANDARD_SS_D_ZRS
    StandardSSD_ZRS
    PREMIUM_V2_LRS
    PremiumV2_LRS
    "Standard_LRS"
    Standard_LRS
    "Premium_LRS"
    Premium_LRS
    "StandardSSD_LRS"
    StandardSSD_LRS
    "UltraSSD_LRS"
    UltraSSD_LRS
    "Premium_ZRS"
    Premium_ZRS
    "StandardSSD_ZRS"
    StandardSSD_ZRS
    "PremiumV2_LRS"
    PremiumV2_LRS

    SubResource, SubResourceArgs

    Id string
    Sub-resource ID. Both absolute resource ID and a relative resource ID are accepted. An absolute ID starts with /subscriptions/ and contains the entire ID of the parent resource and the ID of the sub-resource in the end. A relative ID replaces the ID of the parent resource with a token '$self', followed by the sub-resource ID itself. Example of a relative ID: $self/frontEndConfigurations/my-frontend.
    Id string
    Sub-resource ID. Both absolute resource ID and a relative resource ID are accepted. An absolute ID starts with /subscriptions/ and contains the entire ID of the parent resource and the ID of the sub-resource in the end. A relative ID replaces the ID of the parent resource with a token '$self', followed by the sub-resource ID itself. Example of a relative ID: $self/frontEndConfigurations/my-frontend.
    id String
    Sub-resource ID. Both absolute resource ID and a relative resource ID are accepted. An absolute ID starts with /subscriptions/ and contains the entire ID of the parent resource and the ID of the sub-resource in the end. A relative ID replaces the ID of the parent resource with a token '$self', followed by the sub-resource ID itself. Example of a relative ID: $self/frontEndConfigurations/my-frontend.
    id string
    Sub-resource ID. Both absolute resource ID and a relative resource ID are accepted. An absolute ID starts with /subscriptions/ and contains the entire ID of the parent resource and the ID of the sub-resource in the end. A relative ID replaces the ID of the parent resource with a token '$self', followed by the sub-resource ID itself. Example of a relative ID: $self/frontEndConfigurations/my-frontend.
    id str
    Sub-resource ID. Both absolute resource ID and a relative resource ID are accepted. An absolute ID starts with /subscriptions/ and contains the entire ID of the parent resource and the ID of the sub-resource in the end. A relative ID replaces the ID of the parent resource with a token '$self', followed by the sub-resource ID itself. Example of a relative ID: $self/frontEndConfigurations/my-frontend.
    id String
    Sub-resource ID. Both absolute resource ID and a relative resource ID are accepted. An absolute ID starts with /subscriptions/ and contains the entire ID of the parent resource and the ID of the sub-resource in the end. A relative ID replaces the ID of the parent resource with a token '$self', followed by the sub-resource ID itself. Example of a relative ID: $self/frontEndConfigurations/my-frontend.

    SubResourceResponse, SubResourceResponseArgs

    Id string
    Resource Id
    Id string
    Resource Id
    id String
    Resource Id
    id string
    Resource Id
    id str
    Resource Id
    id String
    Resource Id

    Import

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

    $ pulumi import azure-native:compute:Image myImage /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Compute/images/{imageName} 
    

    Package Details

    Repository
    Azure Native pulumi/pulumi-azure-native
    License
    Apache-2.0
    azure-native logo
    This is the latest version of Azure Native. Use the Azure Native v1 docs if using the v1 version of this package.
    Azure Native v2.29.0 published on Friday, Feb 16, 2024 by Pulumi