Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Packages
  2. Azure Native v1
  3. API Docs
  4. compute
  5. Image
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

azure-native-v1 logo
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

    The source user image virtual hard disk. The virtual hard disk will be copied before being attached to the virtual machine. If SourceImage is provided, the destination virtual hard drive must not exist. API Version: 2020-12-01.

    Example Usage

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

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;

return await Deployment.RunAsync(() => 
{
    var image = new AzureNative.Compute.Image("image", new()
    {
        ImageName = "myImage",
        Location = "West US",
        ResourceGroupName = "myResourceGroup",
        StorageProfile = new AzureNative.Compute.Inputs.ImageStorageProfileArgs
        {
            OsDisk = new AzureNative.Compute.Inputs.ImageOSDiskArgs
            {
                BlobUri = "https://mystorageaccount.blob.core.windows.net/osimages/osimage.vhd",
                DiskEncryptionSet = new AzureNative.Compute.Inputs.DiskEncryptionSetParametersArgs
                {
                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                },
                OsState = AzureNative.Compute.OperatingSystemStateTypes.Generalized,
                OsType = AzureNative.Compute.OperatingSystemTypes.Linux,
            },
        },
    });

});

    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

    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
    azure-native-v1 logo
    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