Azure Native v1 v1.104.0, Jul 6 23

These are the docs for Azure Native v1. We recommenend using the latest version, Azure Native v2.

Azure Native v1 v1.104.0 published on Thursday, Jul 6, 2023 by Pulumi

pulumi/pulumi-azure-native

azure-native.compute.Image

Explore with Pulumi AI

These are the docs for Azure Native v1. We recommenend using the latest version, Azure Native v2.

Azure Native v1 v1.104.0 published on Thursday, Jul 6, 2023 by Pulumi

pulumi/pulumi-azure-native

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,
            },
        },
    });

});

Coming soon!

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 (
	compute "github.com/pulumi/pulumi-azure-native-sdk/compute"
	"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}",
                },
                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,
            },
        },
    });

});

Coming soon!

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 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,
        },
    });

});

Coming soon!

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}",
                },
                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",
                },
            },
        },
    });

});

Coming soon!

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 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,
        },
    });

});

Coming soon!

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 (
	compute "github.com/pulumi/pulumi-azure-native-sdk/compute"
	"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 (
	compute "github.com/pulumi/pulumi-azure-native-sdk/compute"
	"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,
        },
    });

});

Coming soon!

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,
        },
    });

});

Coming soon!

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

Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

Constructor syntax

new Image(name: string, args: ImageArgs, opts?: CustomResourceOptions);

@overload
def Image(resource_name: str,
          args: ImageArgs,
          opts: Optional[ResourceOptions] = None)

@overload
def Image(resource_name: str,
          opts: Optional[ResourceOptions] = None,
          resource_group_name: Optional[str] = None,
          extended_location: Optional[ExtendedLocationArgs] = None,
          hyper_v_generation: Optional[Union[str, HyperVGenerationTypes]] = None,
          image_name: Optional[str] = None,
          location: Optional[str] = None,
          source_virtual_machine: Optional[SubResourceArgs] = None,
          storage_profile: Optional[ImageStorageProfileArgs] = None,
          tags: Optional[Mapping[str, str]] = 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.

Parameters

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.

Constructor example

The following reference example uses placeholder values for all input properties.

var azure_nativeImageResource = new AzureNative.Compute.Image("azure-nativeImageResource", new()
{
    ResourceGroupName = "string",
    ExtendedLocation = 
    {
        { "name", "string" },
        { "type", "string" },
    },
    HyperVGeneration = "string",
    ImageName = "string",
    Location = "string",
    SourceVirtualMachine = 
    {
        { "id", "string" },
    },
    StorageProfile = 
    {
        { "dataDisks", new[]
        {
            
            {
                { "lun", 0 },
                { "blobUri", "string" },
                { "caching", "None" },
                { "diskEncryptionSet", 
                {
                    { "id", "string" },
                } },
                { "diskSizeGB", 0 },
                { "managedDisk", 
                {
                    { "id", "string" },
                } },
                { "snapshot", 
                {
                    { "id", "string" },
                } },
                { "storageAccountType", "string" },
            },
        } },
        { "osDisk", 
        {
            { "osState", "Generalized" },
            { "osType", "Windows" },
            { "blobUri", "string" },
            { "caching", "None" },
            { "diskEncryptionSet", 
            {
                { "id", "string" },
            } },
            { "diskSizeGB", 0 },
            { "managedDisk", 
            {
                { "id", "string" },
            } },
            { "snapshot", 
            {
                { "id", "string" },
            } },
            { "storageAccountType", "string" },
        } },
        { "zoneResilient", false },
    },
    Tags = 
    {
        { "string", "string" },
    },
});

example, err := compute.NewImage(ctx, "azure-nativeImageResource", &compute.ImageArgs{
	ResourceGroupName: "string",
	ExtendedLocation: map[string]interface{}{
		"name": "string",
		"type": "string",
	},
	HyperVGeneration: "string",
	ImageName:        "string",
	Location:         "string",
	SourceVirtualMachine: map[string]interface{}{
		"id": "string",
	},
	StorageProfile: map[string]interface{}{
		"dataDisks": []map[string]interface{}{
			map[string]interface{}{
				"lun":     0,
				"blobUri": "string",
				"caching": "None",
				"diskEncryptionSet": map[string]interface{}{
					"id": "string",
				},
				"diskSizeGB": 0,
				"managedDisk": map[string]interface{}{
					"id": "string",
				},
				"snapshot": map[string]interface{}{
					"id": "string",
				},
				"storageAccountType": "string",
			},
		},
		"osDisk": map[string]interface{}{
			"osState": "Generalized",
			"osType":  "Windows",
			"blobUri": "string",
			"caching": "None",
			"diskEncryptionSet": map[string]interface{}{
				"id": "string",
			},
			"diskSizeGB": 0,
			"managedDisk": map[string]interface{}{
				"id": "string",
			},
			"snapshot": map[string]interface{}{
				"id": "string",
			},
			"storageAccountType": "string",
		},
		"zoneResilient": false,
	},
	Tags: map[string]interface{}{
		"string": "string",
	},
})

var azure_nativeImageResource = new Image("azure-nativeImageResource", ImageArgs.builder()
    .resourceGroupName("string")
    .extendedLocation(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
    .hyperVGeneration("string")
    .imageName("string")
    .location("string")
    .sourceVirtualMachine(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
    .storageProfile(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
    .tags(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
    .build());

azure_native_image_resource = azure_native.compute.Image("azure-nativeImageResource",
    resource_group_name=string,
    extended_location={
        name: string,
        type: string,
    },
    hyper_v_generation=string,
    image_name=string,
    location=string,
    source_virtual_machine={
        id: string,
    },
    storage_profile={
        dataDisks: [{
            lun: 0,
            blobUri: string,
            caching: None,
            diskEncryptionSet: {
                id: string,
            },
            diskSizeGB: 0,
            managedDisk: {
                id: string,
            },
            snapshot: {
                id: string,
            },
            storageAccountType: string,
        }],
        osDisk: {
            osState: Generalized,
            osType: Windows,
            blobUri: string,
            caching: None,
            diskEncryptionSet: {
                id: string,
            },
            diskSizeGB: 0,
            managedDisk: {
                id: string,
            },
            snapshot: {
                id: string,
            },
            storageAccountType: string,
        },
        zoneResilient: False,
    },
    tags={
        string: string,
    })

const azure_nativeImageResource = new azure_native.compute.Image("azure-nativeImageResource", {
    resourceGroupName: "string",
    extendedLocation: {
        name: "string",
        type: "string",
    },
    hyperVGeneration: "string",
    imageName: "string",
    location: "string",
    sourceVirtualMachine: {
        id: "string",
    },
    storageProfile: {
        dataDisks: [{
            lun: 0,
            blobUri: "string",
            caching: "None",
            diskEncryptionSet: {
                id: "string",
            },
            diskSizeGB: 0,
            managedDisk: {
                id: "string",
            },
            snapshot: {
                id: "string",
            },
            storageAccountType: "string",
        }],
        osDisk: {
            osState: "Generalized",
            osType: "Windows",
            blobUri: "string",
            caching: "None",
            diskEncryptionSet: {
                id: "string",
            },
            diskSizeGB: 0,
            managedDisk: {
                id: "string",
            },
            snapshot: {
                id: "string",
            },
            storageAccountType: "string",
        },
        zoneResilient: false,
    },
    tags: {
        string: "string",
    },
});

type: azure-native:compute:Image
properties:
    extendedLocation:
        name: string
        type: string
    hyperVGeneration: string
    imageName: string
    location: string
    resourceGroupName: string
    sourceVirtualMachine:
        id: string
    storageProfile:
        dataDisks:
            - blobUri: string
              caching: None
              diskEncryptionSet:
                id: string
              diskSizeGB: 0
              lun: 0
              managedDisk:
                id: string
              snapshot:
                id: string
              storageAccountType: string
        osDisk:
            blobUri: string
            caching: None
            diskEncryptionSet:
                id: string
            diskSizeGB: 0
            managedDisk:
                id: string
            osState: Generalized
            osType: Windows
            snapshot:
                id: string
            storageAccountType: string
        zoneResilient: false
    tags:
        string: string

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

In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

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 Default: 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 Default: 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 Default: 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 Default: 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 Default: 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 Default: 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": 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 Default: 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 Default: 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 Default: 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 Default: 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 Default: 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 Default: 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.
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 Default: 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.
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 Default: 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.
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 Default: 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.
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 Default: 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.
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 Default: 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.
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 Default: 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": 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.
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 Default: 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.
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 Default: 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.
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 Default: 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.
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 Default: 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.
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 Default: 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.
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 Default: 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

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

Standard_LRS: Standard_LRS
Premium_LRS: Premium_LRS
StandardSSD_LRS: StandardSSD_LRS
UltraSSD_LRS: UltraSSD_LRS
Premium_ZRS: Premium_ZRS
StandardSSD_ZRS: StandardSSD_ZRS

Standard_LRS: Standard_LRS
Premium_LRS: Premium_LRS
StandardSSD_LRS: StandardSSD_LRS
UltraSSD_LRS: UltraSSD_LRS
Premium_ZRS: Premium_ZRS
StandardSSD_ZRS: StandardSSD_ZRS

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

"Standard_LRS": Standard_LRS
"Premium_LRS": Premium_LRS
"StandardSSD_LRS": StandardSSD_LRS
"UltraSSD_LRS": UltraSSD_LRS
"Premium_ZRS": Premium_ZRS
"StandardSSD_ZRS": StandardSSD_ZRS

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/{subscription-id}/resourceGroups/disk/providers/Microsoft.Compute/images/myImage

To learn more about importing existing cloud resources, see Importing resources.

Package Details

Repository: azure-native-v1 pulumi/pulumi-azure-native
License: Apache-2.0

These are the docs for Azure Native v1. We recommenend using the latest version, Azure Native v2.

Azure Native v1 v1.104.0 published on Thursday, Jul 6, 2023 by Pulumi

pulumi/pulumi-azure-native

azure-native.compute.Image

On this page

On this page

Example Usage

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

Create a virtual machine image from a blob.

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

Create a virtual machine image from a managed disk.

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

Create a virtual machine image from a snapshot.

Create a virtual machine image from an existing virtual machine.

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

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

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

Create Image Resource

Constructor syntax

Parameters

Constructor example

Image Resource Properties

Inputs

Outputs

Supporting Types

CachingTypes, CachingTypesArgs

DiskEncryptionSetParameters, DiskEncryptionSetParametersArgs

DiskEncryptionSetParametersResponse, DiskEncryptionSetParametersResponseArgs

ExtendedLocation, ExtendedLocationArgs

ExtendedLocationResponse, ExtendedLocationResponseArgs

ExtendedLocationTypes, ExtendedLocationTypesArgs

HyperVGenerationTypes, HyperVGenerationTypesArgs

ImageDataDisk, ImageDataDiskArgs

ImageDataDiskResponse, ImageDataDiskResponseArgs

ImageOSDisk, ImageOSDiskArgs

ImageOSDiskResponse, ImageOSDiskResponseArgs

ImageStorageProfile, ImageStorageProfileArgs

ImageStorageProfileResponse, ImageStorageProfileResponseArgs

OperatingSystemStateTypes, OperatingSystemStateTypesArgs

OperatingSystemTypes, OperatingSystemTypesArgs

StorageAccountTypes, StorageAccountTypesArgs

SubResource, SubResourceArgs

SubResourceResponse, SubResourceResponseArgs

Import

Package Details

On this page

On this page