1. Packages
  2. Azure Native
  3. API Docs
  4. compute
  5. VirtualMachine
Azure Native v1.103.0 published on Friday, Jun 2, 2023 by Pulumi

azure-native.compute.VirtualMachine

Explore with Pulumi AI

azure-native logo
Azure Native v1.103.0 published on Friday, Jun 2, 2023 by Pulumi

    Describes a Virtual Machine. API Version: 2021-03-01.

    Example Usage

    Create a Linux vm with a patch setting assessmentMode of ImageDefault.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D2s_v3",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
                LinuxConfiguration = new AzureNative.Compute.Inputs.LinuxConfigurationArgs
                {
                    PatchSettings = new AzureNative.Compute.Inputs.LinuxPatchSettingsArgs
                    {
                        AssessmentMode = "ImageDefault",
                    },
                    ProvisionVMAgent = true,
                },
            },
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "UbuntuServer",
                    Publisher = "Canonical",
                    Sku = "16.04-LTS",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        StorageAccountType = "Premium_LRS",
                    },
                    Name = "myVMosdisk",
                },
            },
            VmName = "myVM",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .hardwareProfile(Map.of("vmSize", "Standard_D2s_v3"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM"),
                    Map.entry("linuxConfiguration", Map.ofEntries(
                        Map.entry("patchSettings", Map.of("assessmentMode", "ImageDefault")),
                        Map.entry("provisionVMAgent", true)
                    ))
                ))
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("imageReference", Map.ofEntries(
                        Map.entry("offer", "UbuntuServer"),
                        Map.entry("publisher", "Canonical"),
                        Map.entry("sku", "16.04-LTS"),
                        Map.entry("version", "latest")
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadWrite"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
                        Map.entry("name", "myVMosdisk")
                    ))
                ))
                .vmName("myVM")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D2s_v3",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileResponseArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
            linux_configuration={
                "patchSettings": azure_native.compute.LinuxPatchSettingsArgs(
                    assessment_mode="ImageDefault",
                ),
                "provisionVMAgent": True,
            },
        ),
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            image_reference=azure_native.compute.ImageReferenceArgs(
                offer="UbuntuServer",
                publisher="Canonical",
                sku="16.04-LTS",
                version="latest",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.ManagedDiskParametersArgs(
                    storage_account_type="Premium_LRS",
                ),
                "name": "myVMosdisk",
            },
        ),
        vm_name="myVM")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        hardwareProfile: {
            vmSize: "Standard_D2s_v3",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
            linuxConfiguration: {
                patchSettings: {
                    assessmentMode: "ImageDefault",
                },
                provisionVMAgent: true,
            },
        },
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            imageReference: {
                offer: "UbuntuServer",
                publisher: "Canonical",
                sku: "16.04-LTS",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Premium_LRS",
                },
                name: "myVMosdisk",
            },
        },
        vmName: "myVM",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          hardwareProfile:
            vmSize: Standard_D2s_v3
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
            linuxConfiguration:
              patchSettings:
                assessmentMode: ImageDefault
              provisionVMAgent: true
          resourceGroupName: myResourceGroup
          storageProfile:
            imageReference:
              offer: UbuntuServer
              publisher: Canonical
              sku: 16.04-LTS
              version: latest
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              managedDisk:
                storageAccountType: Premium_LRS
              name: myVMosdisk
          vmName: myVM
    

    Create a Linux vm with a patch setting patchMode of ImageDefault.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D2s_v3",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
                LinuxConfiguration = new AzureNative.Compute.Inputs.LinuxConfigurationArgs
                {
                    PatchSettings = new AzureNative.Compute.Inputs.LinuxPatchSettingsArgs
                    {
                        PatchMode = "ImageDefault",
                    },
                    ProvisionVMAgent = true,
                },
            },
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "UbuntuServer",
                    Publisher = "Canonical",
                    Sku = "16.04-LTS",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        StorageAccountType = "Premium_LRS",
                    },
                    Name = "myVMosdisk",
                },
            },
            VmName = "myVM",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .hardwareProfile(Map.of("vmSize", "Standard_D2s_v3"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM"),
                    Map.entry("linuxConfiguration", Map.ofEntries(
                        Map.entry("patchSettings", Map.of("patchMode", "ImageDefault")),
                        Map.entry("provisionVMAgent", true)
                    ))
                ))
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("imageReference", Map.ofEntries(
                        Map.entry("offer", "UbuntuServer"),
                        Map.entry("publisher", "Canonical"),
                        Map.entry("sku", "16.04-LTS"),
                        Map.entry("version", "latest")
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadWrite"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
                        Map.entry("name", "myVMosdisk")
                    ))
                ))
                .vmName("myVM")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D2s_v3",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileResponseArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
            linux_configuration={
                "patchSettings": azure_native.compute.LinuxPatchSettingsArgs(
                    patch_mode="ImageDefault",
                ),
                "provisionVMAgent": True,
            },
        ),
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            image_reference=azure_native.compute.ImageReferenceArgs(
                offer="UbuntuServer",
                publisher="Canonical",
                sku="16.04-LTS",
                version="latest",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.ManagedDiskParametersArgs(
                    storage_account_type="Premium_LRS",
                ),
                "name": "myVMosdisk",
            },
        ),
        vm_name="myVM")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        hardwareProfile: {
            vmSize: "Standard_D2s_v3",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
            linuxConfiguration: {
                patchSettings: {
                    patchMode: "ImageDefault",
                },
                provisionVMAgent: true,
            },
        },
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            imageReference: {
                offer: "UbuntuServer",
                publisher: "Canonical",
                sku: "16.04-LTS",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Premium_LRS",
                },
                name: "myVMosdisk",
            },
        },
        vmName: "myVM",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          hardwareProfile:
            vmSize: Standard_D2s_v3
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
            linuxConfiguration:
              patchSettings:
                patchMode: ImageDefault
              provisionVMAgent: true
          resourceGroupName: myResourceGroup
          storageProfile:
            imageReference:
              offer: UbuntuServer
              publisher: Canonical
              sku: 16.04-LTS
              version: latest
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              managedDisk:
                storageAccountType: Premium_LRS
              name: myVMosdisk
          vmName: myVM
    

    Create a Linux vm with a patch settings patchMode and assessmentMode set to AutomaticByPlatform.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D2s_v3",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
                LinuxConfiguration = new AzureNative.Compute.Inputs.LinuxConfigurationArgs
                {
                    PatchSettings = new AzureNative.Compute.Inputs.LinuxPatchSettingsArgs
                    {
                        AssessmentMode = "AutomaticByPlatform",
                        PatchMode = "AutomaticByPlatform",
                    },
                    ProvisionVMAgent = true,
                },
            },
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "UbuntuServer",
                    Publisher = "Canonical",
                    Sku = "16.04-LTS",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        StorageAccountType = "Premium_LRS",
                    },
                    Name = "myVMosdisk",
                },
            },
            VmName = "myVM",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .hardwareProfile(Map.of("vmSize", "Standard_D2s_v3"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM"),
                    Map.entry("linuxConfiguration", Map.ofEntries(
                        Map.entry("patchSettings", Map.ofEntries(
                            Map.entry("assessmentMode", "AutomaticByPlatform"),
                            Map.entry("patchMode", "AutomaticByPlatform")
                        )),
                        Map.entry("provisionVMAgent", true)
                    ))
                ))
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("imageReference", Map.ofEntries(
                        Map.entry("offer", "UbuntuServer"),
                        Map.entry("publisher", "Canonical"),
                        Map.entry("sku", "16.04-LTS"),
                        Map.entry("version", "latest")
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadWrite"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
                        Map.entry("name", "myVMosdisk")
                    ))
                ))
                .vmName("myVM")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D2s_v3",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileResponseArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
            linux_configuration={
                "patchSettings": azure_native.compute.LinuxPatchSettingsArgs(
                    assessment_mode="AutomaticByPlatform",
                    patch_mode="AutomaticByPlatform",
                ),
                "provisionVMAgent": True,
            },
        ),
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            image_reference=azure_native.compute.ImageReferenceArgs(
                offer="UbuntuServer",
                publisher="Canonical",
                sku="16.04-LTS",
                version="latest",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.ManagedDiskParametersArgs(
                    storage_account_type="Premium_LRS",
                ),
                "name": "myVMosdisk",
            },
        ),
        vm_name="myVM")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        hardwareProfile: {
            vmSize: "Standard_D2s_v3",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
            linuxConfiguration: {
                patchSettings: {
                    assessmentMode: "AutomaticByPlatform",
                    patchMode: "AutomaticByPlatform",
                },
                provisionVMAgent: true,
            },
        },
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            imageReference: {
                offer: "UbuntuServer",
                publisher: "Canonical",
                sku: "16.04-LTS",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Premium_LRS",
                },
                name: "myVMosdisk",
            },
        },
        vmName: "myVM",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          hardwareProfile:
            vmSize: Standard_D2s_v3
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
            linuxConfiguration:
              patchSettings:
                assessmentMode: AutomaticByPlatform
                patchMode: AutomaticByPlatform
              provisionVMAgent: true
          resourceGroupName: myResourceGroup
          storageProfile:
            imageReference:
              offer: UbuntuServer
              publisher: Canonical
              sku: 16.04-LTS
              version: latest
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              managedDisk:
                storageAccountType: Premium_LRS
              name: myVMosdisk
          vmName: myVM
    

    Create a VM with Uefi Settings of secureBoot and vTPM.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D2s_v3",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
            },
            ResourceGroupName = "myResourceGroup",
            SecurityProfile = new AzureNative.Compute.Inputs.SecurityProfileArgs
            {
                SecurityType = "TrustedLaunch",
                UefiSettings = new AzureNative.Compute.Inputs.UefiSettingsArgs
                {
                    SecureBootEnabled = true,
                    VTpmEnabled = true,
                },
            },
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "windowsserver-gen2preview-preview",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "windows10-tvm",
                    Version = "18363.592.2001092016",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadOnly,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        StorageAccountType = "StandardSSD_LRS",
                    },
                    Name = "myVMosdisk",
                },
            },
            VmName = "myVM",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .hardwareProfile(Map.of("vmSize", "Standard_D2s_v3"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM")
                ))
                .resourceGroupName("myResourceGroup")
                .securityProfile(Map.ofEntries(
                    Map.entry("securityType", "TrustedLaunch"),
                    Map.entry("uefiSettings", Map.ofEntries(
                        Map.entry("secureBootEnabled", true),
                        Map.entry("vTpmEnabled", true)
                    ))
                ))
                .storageProfile(Map.ofEntries(
                    Map.entry("imageReference", Map.ofEntries(
                        Map.entry("offer", "windowsserver-gen2preview-preview"),
                        Map.entry("publisher", "MicrosoftWindowsServer"),
                        Map.entry("sku", "windows10-tvm"),
                        Map.entry("version", "18363.592.2001092016")
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadOnly"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.of("storageAccountType", "StandardSSD_LRS")),
                        Map.entry("name", "myVMosdisk")
                    ))
                ))
                .vmName("myVM")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D2s_v3",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
        ),
        resource_group_name="myResourceGroup",
        security_profile=azure_native.compute.SecurityProfileResponseArgs(
            security_type="TrustedLaunch",
            uefi_settings=azure_native.compute.UefiSettingsArgs(
                secure_boot_enabled=True,
                v_tpm_enabled=True,
            ),
        ),
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            image_reference=azure_native.compute.ImageReferenceArgs(
                offer="windowsserver-gen2preview-preview",
                publisher="MicrosoftWindowsServer",
                sku="windows10-tvm",
                version="18363.592.2001092016",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_ONLY,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.ManagedDiskParametersArgs(
                    storage_account_type="StandardSSD_LRS",
                ),
                "name": "myVMosdisk",
            },
        ),
        vm_name="myVM")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        hardwareProfile: {
            vmSize: "Standard_D2s_v3",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
        },
        resourceGroupName: "myResourceGroup",
        securityProfile: {
            securityType: "TrustedLaunch",
            uefiSettings: {
                secureBootEnabled: true,
                vTpmEnabled: true,
            },
        },
        storageProfile: {
            imageReference: {
                offer: "windowsserver-gen2preview-preview",
                publisher: "MicrosoftWindowsServer",
                sku: "windows10-tvm",
                version: "18363.592.2001092016",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadOnly,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "StandardSSD_LRS",
                },
                name: "myVMosdisk",
            },
        },
        vmName: "myVM",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          hardwareProfile:
            vmSize: Standard_D2s_v3
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
          resourceGroupName: myResourceGroup
          securityProfile:
            securityType: TrustedLaunch
            uefiSettings:
              secureBootEnabled: true
              vTpmEnabled: true
          storageProfile:
            imageReference:
              offer: windowsserver-gen2preview-preview
              publisher: MicrosoftWindowsServer
              sku: windows10-tvm
              version: 18363.592.2001092016
            osDisk:
              caching: ReadOnly
              createOption: FromImage
              managedDisk:
                storageAccountType: StandardSSD_LRS
              name: myVMosdisk
          vmName: myVM
    

    Create a VM with UserData

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            DiagnosticsProfile = new AzureNative.Compute.Inputs.DiagnosticsProfileArgs
            {
                BootDiagnostics = new AzureNative.Compute.Inputs.BootDiagnosticsArgs
                {
                    Enabled = true,
                    StorageUri = "http://{existing-storage-account-name}.blob.core.windows.net",
                },
            },
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D1_v2",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "{vm-name}",
            },
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "WindowsServer",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "2016-Datacenter",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                    Name = "vmOSdisk",
                },
            },
            UserData = "RXhhbXBsZSBVc2VyRGF0YQ==",
            VmName = "{vm-name}",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .diagnosticsProfile(Map.of("bootDiagnostics", Map.ofEntries(
                    Map.entry("enabled", true),
                    Map.entry("storageUri", "http://{existing-storage-account-name}.blob.core.windows.net")
                )))
                .hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "{vm-name}")
                ))
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("imageReference", Map.ofEntries(
                        Map.entry("offer", "WindowsServer"),
                        Map.entry("publisher", "MicrosoftWindowsServer"),
                        Map.entry("sku", "2016-Datacenter"),
                        Map.entry("version", "latest")
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadWrite"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
                        Map.entry("name", "vmOSdisk")
                    ))
                ))
                .userData("RXhhbXBsZSBVc2VyRGF0YQ==")
                .vmName("{vm-name}")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        diagnostics_profile=azure_native.compute.DiagnosticsProfileResponseArgs(
            boot_diagnostics=azure_native.compute.BootDiagnosticsArgs(
                enabled=True,
                storage_uri="http://{existing-storage-account-name}.blob.core.windows.net",
            ),
        ),
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D1_v2",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="{vm-name}",
        ),
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            image_reference=azure_native.compute.ImageReferenceArgs(
                offer="WindowsServer",
                publisher="MicrosoftWindowsServer",
                sku="2016-Datacenter",
                version="latest",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.ManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
                "name": "vmOSdisk",
            },
        ),
        user_data="RXhhbXBsZSBVc2VyRGF0YQ==",
        vm_name="{vm-name}")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        diagnosticsProfile: {
            bootDiagnostics: {
                enabled: true,
                storageUri: "http://{existing-storage-account-name}.blob.core.windows.net",
            },
        },
        hardwareProfile: {
            vmSize: "Standard_D1_v2",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "{vm-name}",
        },
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            imageReference: {
                offer: "WindowsServer",
                publisher: "MicrosoftWindowsServer",
                sku: "2016-Datacenter",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Standard_LRS",
                },
                name: "vmOSdisk",
            },
        },
        userData: "RXhhbXBsZSBVc2VyRGF0YQ==",
        vmName: "{vm-name}",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          diagnosticsProfile:
            bootDiagnostics:
              enabled: true
              storageUri: http://{existing-storage-account-name}.blob.core.windows.net
          hardwareProfile:
            vmSize: Standard_D1_v2
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: '{vm-name}'
          resourceGroupName: myResourceGroup
          storageProfile:
            imageReference:
              offer: WindowsServer
              publisher: MicrosoftWindowsServer
              sku: 2016-Datacenter
              version: latest
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              managedDisk:
                storageAccountType: Standard_LRS
              name: vmOSdisk
          userData: RXhhbXBsZSBVc2VyRGF0YQ==
          vmName: '{vm-name}'
    

    Create a VM with network interface configuration

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D1_v2",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkApiVersion = "2020-11-01",
                NetworkInterfaceConfigurations = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineNetworkInterfaceConfigurationArgs
                    {
                        DeleteOption = "Delete",
                        IpConfigurations = new[]
                        {
                            new AzureNative.Compute.Inputs.VirtualMachineNetworkInterfaceIPConfigurationArgs
                            {
                                Name = "{ip-config-name}",
                                Primary = true,
                                PublicIPAddressConfiguration = new AzureNative.Compute.Inputs.VirtualMachinePublicIPAddressConfigurationArgs
                                {
                                    DeleteOption = "Detach",
                                    Name = "{publicIP-config-name}",
                                    PublicIPAllocationMethod = "Static",
                                    Sku = new AzureNative.Compute.Inputs.PublicIPAddressSkuArgs
                                    {
                                        Name = "Basic",
                                        Tier = "Global",
                                    },
                                },
                            },
                        },
                        Name = "{nic-config-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
            },
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "WindowsServer",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "2016-Datacenter",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                    Name = "myVMosdisk",
                },
            },
            VmName = "myVM",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
                .location("westus")
                .networkProfile(Map.ofEntries(
                    Map.entry("networkApiVersion", "2020-11-01"),
                    Map.entry("networkInterfaceConfigurations", Map.ofEntries(
                        Map.entry("deleteOption", "Delete"),
                        Map.entry("ipConfigurations", Map.ofEntries(
                            Map.entry("name", "{ip-config-name}"),
                            Map.entry("primary", true),
                            Map.entry("publicIPAddressConfiguration", Map.ofEntries(
                                Map.entry("deleteOption", "Detach"),
                                Map.entry("name", "{publicIP-config-name}"),
                                Map.entry("publicIPAllocationMethod", "Static"),
                                Map.entry("sku", Map.ofEntries(
                                    Map.entry("name", "Basic"),
                                    Map.entry("tier", "Global")
                                ))
                            ))
                        )),
                        Map.entry("name", "{nic-config-name}"),
                        Map.entry("primary", true)
                    ))
                ))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM")
                ))
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("imageReference", Map.ofEntries(
                        Map.entry("offer", "WindowsServer"),
                        Map.entry("publisher", "MicrosoftWindowsServer"),
                        Map.entry("sku", "2016-Datacenter"),
                        Map.entry("version", "latest")
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadWrite"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
                        Map.entry("name", "myVMosdisk")
                    ))
                ))
                .vmName("myVM")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D1_v2",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_api_version="2020-11-01",
            network_interface_configurations=[{
                "deleteOption": "Delete",
                "ipConfigurations": [{
                    "name": "{ip-config-name}",
                    "primary": True,
                    "publicIPAddressConfiguration": {
                        "deleteOption": "Detach",
                        "name": "{publicIP-config-name}",
                        "publicIPAllocationMethod": "Static",
                        "sku": azure_native.compute.PublicIPAddressSkuArgs(
                            name="Basic",
                            tier="Global",
                        ),
                    },
                }],
                "name": "{nic-config-name}",
                "primary": True,
            }],
        ),
        os_profile=azure_native.compute.OSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
        ),
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            image_reference=azure_native.compute.ImageReferenceArgs(
                offer="WindowsServer",
                publisher="MicrosoftWindowsServer",
                sku="2016-Datacenter",
                version="latest",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.ManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
                "name": "myVMosdisk",
            },
        ),
        vm_name="myVM")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        hardwareProfile: {
            vmSize: "Standard_D1_v2",
        },
        location: "westus",
        networkProfile: {
            networkApiVersion: "2020-11-01",
            networkInterfaceConfigurations: [{
                deleteOption: "Delete",
                ipConfigurations: [{
                    name: "{ip-config-name}",
                    primary: true,
                    publicIPAddressConfiguration: {
                        deleteOption: "Detach",
                        name: "{publicIP-config-name}",
                        publicIPAllocationMethod: "Static",
                        sku: {
                            name: "Basic",
                            tier: "Global",
                        },
                    },
                }],
                name: "{nic-config-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
        },
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            imageReference: {
                offer: "WindowsServer",
                publisher: "MicrosoftWindowsServer",
                sku: "2016-Datacenter",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Standard_LRS",
                },
                name: "myVMosdisk",
            },
        },
        vmName: "myVM",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          hardwareProfile:
            vmSize: Standard_D1_v2
          location: westus
          networkProfile:
            networkApiVersion: 2020-11-01
            networkInterfaceConfigurations:
              - deleteOption: Delete
                ipConfigurations:
                  - name: '{ip-config-name}'
                    primary: true
                    publicIPAddressConfiguration:
                      deleteOption: Detach
                      name: '{publicIP-config-name}'
                      publicIPAllocationMethod: Static
                      sku:
                        name: Basic
                        tier: Global
                name: '{nic-config-name}'
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
          resourceGroupName: myResourceGroup
          storageProfile:
            imageReference:
              offer: WindowsServer
              publisher: MicrosoftWindowsServer
              sku: 2016-Datacenter
              version: latest
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              managedDisk:
                storageAccountType: Standard_LRS
              name: myVMosdisk
          vmName: myVM
    

    Create a Windows vm with a patch setting assessmentMode of ImageDefault.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D1_v2",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
                WindowsConfiguration = new AzureNative.Compute.Inputs.WindowsConfigurationArgs
                {
                    EnableAutomaticUpdates = true,
                    PatchSettings = new AzureNative.Compute.Inputs.PatchSettingsArgs
                    {
                        AssessmentMode = "ImageDefault",
                    },
                    ProvisionVMAgent = true,
                },
            },
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "WindowsServer",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "2016-Datacenter",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        StorageAccountType = "Premium_LRS",
                    },
                    Name = "myVMosdisk",
                },
            },
            VmName = "myVM",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM"),
                    Map.entry("windowsConfiguration", Map.ofEntries(
                        Map.entry("enableAutomaticUpdates", true),
                        Map.entry("patchSettings", Map.of("assessmentMode", "ImageDefault")),
                        Map.entry("provisionVMAgent", true)
                    ))
                ))
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("imageReference", Map.ofEntries(
                        Map.entry("offer", "WindowsServer"),
                        Map.entry("publisher", "MicrosoftWindowsServer"),
                        Map.entry("sku", "2016-Datacenter"),
                        Map.entry("version", "latest")
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadWrite"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
                        Map.entry("name", "myVMosdisk")
                    ))
                ))
                .vmName("myVM")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D1_v2",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileResponseArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
            windows_configuration={
                "enableAutomaticUpdates": True,
                "patchSettings": azure_native.compute.PatchSettingsArgs(
                    assessment_mode="ImageDefault",
                ),
                "provisionVMAgent": True,
            },
        ),
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            image_reference=azure_native.compute.ImageReferenceArgs(
                offer="WindowsServer",
                publisher="MicrosoftWindowsServer",
                sku="2016-Datacenter",
                version="latest",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.ManagedDiskParametersArgs(
                    storage_account_type="Premium_LRS",
                ),
                "name": "myVMosdisk",
            },
        ),
        vm_name="myVM")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        hardwareProfile: {
            vmSize: "Standard_D1_v2",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
            windowsConfiguration: {
                enableAutomaticUpdates: true,
                patchSettings: {
                    assessmentMode: "ImageDefault",
                },
                provisionVMAgent: true,
            },
        },
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            imageReference: {
                offer: "WindowsServer",
                publisher: "MicrosoftWindowsServer",
                sku: "2016-Datacenter",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Premium_LRS",
                },
                name: "myVMosdisk",
            },
        },
        vmName: "myVM",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          hardwareProfile:
            vmSize: Standard_D1_v2
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
            windowsConfiguration:
              enableAutomaticUpdates: true
              patchSettings:
                assessmentMode: ImageDefault
              provisionVMAgent: true
          resourceGroupName: myResourceGroup
          storageProfile:
            imageReference:
              offer: WindowsServer
              publisher: MicrosoftWindowsServer
              sku: 2016-Datacenter
              version: latest
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              managedDisk:
                storageAccountType: Premium_LRS
              name: myVMosdisk
          vmName: myVM
    

    Create a Windows vm with a patch setting patchMode of AutomaticByOS.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D1_v2",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/nsgExistingNic",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
                WindowsConfiguration = new AzureNative.Compute.Inputs.WindowsConfigurationArgs
                {
                    EnableAutomaticUpdates = true,
                    PatchSettings = new AzureNative.Compute.Inputs.PatchSettingsArgs
                    {
                        PatchMode = "AutomaticByOS",
                    },
                    ProvisionVMAgent = true,
                },
            },
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "WindowsServer",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "2016-Datacenter",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        StorageAccountType = "Premium_LRS",
                    },
                    Name = "myVMosdisk",
                },
            },
            VmName = "myVM",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/nsgExistingNic"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM"),
                    Map.entry("windowsConfiguration", Map.ofEntries(
                        Map.entry("enableAutomaticUpdates", true),
                        Map.entry("patchSettings", Map.of("patchMode", "AutomaticByOS")),
                        Map.entry("provisionVMAgent", true)
                    ))
                ))
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("imageReference", Map.ofEntries(
                        Map.entry("offer", "WindowsServer"),
                        Map.entry("publisher", "MicrosoftWindowsServer"),
                        Map.entry("sku", "2016-Datacenter"),
                        Map.entry("version", "latest")
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadWrite"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
                        Map.entry("name", "myVMosdisk")
                    ))
                ))
                .vmName("myVM")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D1_v2",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/nsgExistingNic",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileResponseArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
            windows_configuration={
                "enableAutomaticUpdates": True,
                "patchSettings": azure_native.compute.PatchSettingsArgs(
                    patch_mode="AutomaticByOS",
                ),
                "provisionVMAgent": True,
            },
        ),
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            image_reference=azure_native.compute.ImageReferenceArgs(
                offer="WindowsServer",
                publisher="MicrosoftWindowsServer",
                sku="2016-Datacenter",
                version="latest",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.ManagedDiskParametersArgs(
                    storage_account_type="Premium_LRS",
                ),
                "name": "myVMosdisk",
            },
        ),
        vm_name="myVM")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        hardwareProfile: {
            vmSize: "Standard_D1_v2",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/nsgExistingNic",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
            windowsConfiguration: {
                enableAutomaticUpdates: true,
                patchSettings: {
                    patchMode: "AutomaticByOS",
                },
                provisionVMAgent: true,
            },
        },
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            imageReference: {
                offer: "WindowsServer",
                publisher: "MicrosoftWindowsServer",
                sku: "2016-Datacenter",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Premium_LRS",
                },
                name: "myVMosdisk",
            },
        },
        vmName: "myVM",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          hardwareProfile:
            vmSize: Standard_D1_v2
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/nsgExistingNic
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
            windowsConfiguration:
              enableAutomaticUpdates: true
              patchSettings:
                patchMode: AutomaticByOS
              provisionVMAgent: true
          resourceGroupName: myResourceGroup
          storageProfile:
            imageReference:
              offer: WindowsServer
              publisher: MicrosoftWindowsServer
              sku: 2016-Datacenter
              version: latest
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              managedDisk:
                storageAccountType: Premium_LRS
              name: myVMosdisk
          vmName: myVM
    

    Create a Windows vm with a patch setting patchMode of AutomaticByPlatform and enableHotpatching set to true.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D1_v2",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
                WindowsConfiguration = new AzureNative.Compute.Inputs.WindowsConfigurationArgs
                {
                    EnableAutomaticUpdates = true,
                    PatchSettings = new AzureNative.Compute.Inputs.PatchSettingsArgs
                    {
                        EnableHotpatching = true,
                        PatchMode = "AutomaticByPlatform",
                    },
                    ProvisionVMAgent = true,
                },
            },
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "WindowsServer",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "2016-Datacenter",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        StorageAccountType = "Premium_LRS",
                    },
                    Name = "myVMosdisk",
                },
            },
            VmName = "myVM",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM"),
                    Map.entry("windowsConfiguration", Map.ofEntries(
                        Map.entry("enableAutomaticUpdates", true),
                        Map.entry("patchSettings", Map.ofEntries(
                            Map.entry("enableHotpatching", true),
                            Map.entry("patchMode", "AutomaticByPlatform")
                        )),
                        Map.entry("provisionVMAgent", true)
                    ))
                ))
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("imageReference", Map.ofEntries(
                        Map.entry("offer", "WindowsServer"),
                        Map.entry("publisher", "MicrosoftWindowsServer"),
                        Map.entry("sku", "2016-Datacenter"),
                        Map.entry("version", "latest")
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadWrite"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
                        Map.entry("name", "myVMosdisk")
                    ))
                ))
                .vmName("myVM")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D1_v2",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileResponseArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
            windows_configuration={
                "enableAutomaticUpdates": True,
                "patchSettings": azure_native.compute.PatchSettingsArgs(
                    enable_hotpatching=True,
                    patch_mode="AutomaticByPlatform",
                ),
                "provisionVMAgent": True,
            },
        ),
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            image_reference=azure_native.compute.ImageReferenceArgs(
                offer="WindowsServer",
                publisher="MicrosoftWindowsServer",
                sku="2016-Datacenter",
                version="latest",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.ManagedDiskParametersArgs(
                    storage_account_type="Premium_LRS",
                ),
                "name": "myVMosdisk",
            },
        ),
        vm_name="myVM")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        hardwareProfile: {
            vmSize: "Standard_D1_v2",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
            windowsConfiguration: {
                enableAutomaticUpdates: true,
                patchSettings: {
                    enableHotpatching: true,
                    patchMode: "AutomaticByPlatform",
                },
                provisionVMAgent: true,
            },
        },
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            imageReference: {
                offer: "WindowsServer",
                publisher: "MicrosoftWindowsServer",
                sku: "2016-Datacenter",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Premium_LRS",
                },
                name: "myVMosdisk",
            },
        },
        vmName: "myVM",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          hardwareProfile:
            vmSize: Standard_D1_v2
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
            windowsConfiguration:
              enableAutomaticUpdates: true
              patchSettings:
                enableHotpatching: true
                patchMode: AutomaticByPlatform
              provisionVMAgent: true
          resourceGroupName: myResourceGroup
          storageProfile:
            imageReference:
              offer: WindowsServer
              publisher: MicrosoftWindowsServer
              sku: 2016-Datacenter
              version: latest
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              managedDisk:
                storageAccountType: Premium_LRS
              name: myVMosdisk
          vmName: myVM
    

    Create a Windows vm with a patch setting patchMode of Manual.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D1_v2",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
                WindowsConfiguration = new AzureNative.Compute.Inputs.WindowsConfigurationArgs
                {
                    EnableAutomaticUpdates = true,
                    PatchSettings = new AzureNative.Compute.Inputs.PatchSettingsArgs
                    {
                        PatchMode = "Manual",
                    },
                    ProvisionVMAgent = true,
                },
            },
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "WindowsServer",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "2016-Datacenter",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        StorageAccountType = "Premium_LRS",
                    },
                    Name = "myVMosdisk",
                },
            },
            VmName = "myVM",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM"),
                    Map.entry("windowsConfiguration", Map.ofEntries(
                        Map.entry("enableAutomaticUpdates", true),
                        Map.entry("patchSettings", Map.of("patchMode", "Manual")),
                        Map.entry("provisionVMAgent", true)
                    ))
                ))
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("imageReference", Map.ofEntries(
                        Map.entry("offer", "WindowsServer"),
                        Map.entry("publisher", "MicrosoftWindowsServer"),
                        Map.entry("sku", "2016-Datacenter"),
                        Map.entry("version", "latest")
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadWrite"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
                        Map.entry("name", "myVMosdisk")
                    ))
                ))
                .vmName("myVM")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D1_v2",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileResponseArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
            windows_configuration={
                "enableAutomaticUpdates": True,
                "patchSettings": azure_native.compute.PatchSettingsArgs(
                    patch_mode="Manual",
                ),
                "provisionVMAgent": True,
            },
        ),
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            image_reference=azure_native.compute.ImageReferenceArgs(
                offer="WindowsServer",
                publisher="MicrosoftWindowsServer",
                sku="2016-Datacenter",
                version="latest",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.ManagedDiskParametersArgs(
                    storage_account_type="Premium_LRS",
                ),
                "name": "myVMosdisk",
            },
        ),
        vm_name="myVM")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        hardwareProfile: {
            vmSize: "Standard_D1_v2",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
            windowsConfiguration: {
                enableAutomaticUpdates: true,
                patchSettings: {
                    patchMode: "Manual",
                },
                provisionVMAgent: true,
            },
        },
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            imageReference: {
                offer: "WindowsServer",
                publisher: "MicrosoftWindowsServer",
                sku: "2016-Datacenter",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Premium_LRS",
                },
                name: "myVMosdisk",
            },
        },
        vmName: "myVM",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          hardwareProfile:
            vmSize: Standard_D1_v2
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
            windowsConfiguration:
              enableAutomaticUpdates: true
              patchSettings:
                patchMode: Manual
              provisionVMAgent: true
          resourceGroupName: myResourceGroup
          storageProfile:
            imageReference:
              offer: WindowsServer
              publisher: MicrosoftWindowsServer
              sku: 2016-Datacenter
              version: latest
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              managedDisk:
                storageAccountType: Premium_LRS
              name: myVMosdisk
          vmName: myVM
    

    Create a Windows vm with patch settings patchMode and assessmentMode set to AutomaticByPlatform.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D1_v2",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
                WindowsConfiguration = new AzureNative.Compute.Inputs.WindowsConfigurationArgs
                {
                    EnableAutomaticUpdates = true,
                    PatchSettings = new AzureNative.Compute.Inputs.PatchSettingsArgs
                    {
                        AssessmentMode = "AutomaticByPlatform",
                        PatchMode = "AutomaticByPlatform",
                    },
                    ProvisionVMAgent = true,
                },
            },
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "WindowsServer",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "2016-Datacenter",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        StorageAccountType = "Premium_LRS",
                    },
                    Name = "myVMosdisk",
                },
            },
            VmName = "myVM",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM"),
                    Map.entry("windowsConfiguration", Map.ofEntries(
                        Map.entry("enableAutomaticUpdates", true),
                        Map.entry("patchSettings", Map.ofEntries(
                            Map.entry("assessmentMode", "AutomaticByPlatform"),
                            Map.entry("patchMode", "AutomaticByPlatform")
                        )),
                        Map.entry("provisionVMAgent", true)
                    ))
                ))
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("imageReference", Map.ofEntries(
                        Map.entry("offer", "WindowsServer"),
                        Map.entry("publisher", "MicrosoftWindowsServer"),
                        Map.entry("sku", "2016-Datacenter"),
                        Map.entry("version", "latest")
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadWrite"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
                        Map.entry("name", "myVMosdisk")
                    ))
                ))
                .vmName("myVM")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D1_v2",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileResponseArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
            windows_configuration={
                "enableAutomaticUpdates": True,
                "patchSettings": azure_native.compute.PatchSettingsArgs(
                    assessment_mode="AutomaticByPlatform",
                    patch_mode="AutomaticByPlatform",
                ),
                "provisionVMAgent": True,
            },
        ),
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            image_reference=azure_native.compute.ImageReferenceArgs(
                offer="WindowsServer",
                publisher="MicrosoftWindowsServer",
                sku="2016-Datacenter",
                version="latest",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.ManagedDiskParametersArgs(
                    storage_account_type="Premium_LRS",
                ),
                "name": "myVMosdisk",
            },
        ),
        vm_name="myVM")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        hardwareProfile: {
            vmSize: "Standard_D1_v2",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
            windowsConfiguration: {
                enableAutomaticUpdates: true,
                patchSettings: {
                    assessmentMode: "AutomaticByPlatform",
                    patchMode: "AutomaticByPlatform",
                },
                provisionVMAgent: true,
            },
        },
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            imageReference: {
                offer: "WindowsServer",
                publisher: "MicrosoftWindowsServer",
                sku: "2016-Datacenter",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Premium_LRS",
                },
                name: "myVMosdisk",
            },
        },
        vmName: "myVM",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          hardwareProfile:
            vmSize: Standard_D1_v2
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
            windowsConfiguration:
              enableAutomaticUpdates: true
              patchSettings:
                assessmentMode: AutomaticByPlatform
                patchMode: AutomaticByPlatform
              provisionVMAgent: true
          resourceGroupName: myResourceGroup
          storageProfile:
            imageReference:
              offer: WindowsServer
              publisher: MicrosoftWindowsServer
              sku: 2016-Datacenter
              version: latest
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              managedDisk:
                storageAccountType: Premium_LRS
              name: myVMosdisk
          vmName: myVM
    

    Create a custom-image vm from an unmanaged generalized os image.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D1_v2",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
            },
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    Image = new AzureNative.Compute.Inputs.VirtualHardDiskArgs
                    {
                        Uri = "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/{existing-generalized-os-image-blob-name}.vhd",
                    },
                    Name = "myVMosdisk",
                    OsType = AzureNative.Compute.OperatingSystemTypes.Windows,
                    Vhd = new AzureNative.Compute.Inputs.VirtualHardDiskArgs
                    {
                        Uri = "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd",
                    },
                },
            },
            VmName = "{vm-name}",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM")
                ))
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.of("osDisk", Map.ofEntries(
                    Map.entry("caching", "ReadWrite"),
                    Map.entry("createOption", "FromImage"),
                    Map.entry("image", Map.of("uri", "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/{existing-generalized-os-image-blob-name}.vhd")),
                    Map.entry("name", "myVMosdisk"),
                    Map.entry("osType", "Windows"),
                    Map.entry("vhd", Map.of("uri", "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd"))
                )))
                .vmName("{vm-name}")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D1_v2",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
        ),
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "image": azure_native.compute.VirtualHardDiskArgs(
                    uri="http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/{existing-generalized-os-image-blob-name}.vhd",
                ),
                "name": "myVMosdisk",
                "osType": azure_native.compute.OperatingSystemTypes.WINDOWS,
                "vhd": azure_native.compute.VirtualHardDiskArgs(
                    uri="http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd",
                ),
            },
        ),
        vm_name="{vm-name}")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        hardwareProfile: {
            vmSize: "Standard_D1_v2",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
        },
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                image: {
                    uri: "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/{existing-generalized-os-image-blob-name}.vhd",
                },
                name: "myVMosdisk",
                osType: azure_native.compute.OperatingSystemTypes.Windows,
                vhd: {
                    uri: "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd",
                },
            },
        },
        vmName: "{vm-name}",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          hardwareProfile:
            vmSize: Standard_D1_v2
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
          resourceGroupName: myResourceGroup
          storageProfile:
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              image:
                uri: http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/{existing-generalized-os-image-blob-name}.vhd
              name: myVMosdisk
              osType: Windows
              vhd:
                uri: http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd
          vmName: '{vm-name}'
    

    Create a platform-image vm with unmanaged os and data disks.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D2_v2",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
            },
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                DataDisks = new[]
                {
                    new AzureNative.Compute.Inputs.DataDiskArgs
                    {
                        CreateOption = "Empty",
                        DiskSizeGB = 1023,
                        Lun = 0,
                        Vhd = new AzureNative.Compute.Inputs.VirtualHardDiskArgs
                        {
                            Uri = "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk0.vhd",
                        },
                    },
                    new AzureNative.Compute.Inputs.DataDiskArgs
                    {
                        CreateOption = "Empty",
                        DiskSizeGB = 1023,
                        Lun = 1,
                        Vhd = new AzureNative.Compute.Inputs.VirtualHardDiskArgs
                        {
                            Uri = "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk1.vhd",
                        },
                    },
                },
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "WindowsServer",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "2016-Datacenter",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    Name = "myVMosdisk",
                    Vhd = new AzureNative.Compute.Inputs.VirtualHardDiskArgs
                    {
                        Uri = "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd",
                    },
                },
            },
            VmName = "{vm-name}",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .hardwareProfile(Map.of("vmSize", "Standard_D2_v2"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM")
                ))
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("dataDisks",                 
                        Map.ofEntries(
                            Map.entry("createOption", "Empty"),
                            Map.entry("diskSizeGB", 1023),
                            Map.entry("lun", 0),
                            Map.entry("vhd", Map.of("uri", "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk0.vhd"))
                        ),
                        Map.ofEntries(
                            Map.entry("createOption", "Empty"),
                            Map.entry("diskSizeGB", 1023),
                            Map.entry("lun", 1),
                            Map.entry("vhd", Map.of("uri", "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk1.vhd"))
                        )),
                    Map.entry("imageReference", Map.ofEntries(
                        Map.entry("offer", "WindowsServer"),
                        Map.entry("publisher", "MicrosoftWindowsServer"),
                        Map.entry("sku", "2016-Datacenter"),
                        Map.entry("version", "latest")
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadWrite"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("name", "myVMosdisk"),
                        Map.entry("vhd", Map.of("uri", "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd"))
                    ))
                ))
                .vmName("{vm-name}")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D2_v2",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
        ),
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            data_disks=[
                {
                    "createOption": "Empty",
                    "diskSizeGB": 1023,
                    "lun": 0,
                    "vhd": azure_native.compute.VirtualHardDiskArgs(
                        uri="http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk0.vhd",
                    ),
                },
                {
                    "createOption": "Empty",
                    "diskSizeGB": 1023,
                    "lun": 1,
                    "vhd": azure_native.compute.VirtualHardDiskArgs(
                        uri="http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk1.vhd",
                    ),
                },
            ],
            image_reference=azure_native.compute.ImageReferenceArgs(
                offer="WindowsServer",
                publisher="MicrosoftWindowsServer",
                sku="2016-Datacenter",
                version="latest",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "name": "myVMosdisk",
                "vhd": azure_native.compute.VirtualHardDiskArgs(
                    uri="http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd",
                ),
            },
        ),
        vm_name="{vm-name}")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        hardwareProfile: {
            vmSize: "Standard_D2_v2",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
        },
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            dataDisks: [
                {
                    createOption: "Empty",
                    diskSizeGB: 1023,
                    lun: 0,
                    vhd: {
                        uri: "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk0.vhd",
                    },
                },
                {
                    createOption: "Empty",
                    diskSizeGB: 1023,
                    lun: 1,
                    vhd: {
                        uri: "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk1.vhd",
                    },
                },
            ],
            imageReference: {
                offer: "WindowsServer",
                publisher: "MicrosoftWindowsServer",
                sku: "2016-Datacenter",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                name: "myVMosdisk",
                vhd: {
                    uri: "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd",
                },
            },
        },
        vmName: "{vm-name}",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          hardwareProfile:
            vmSize: Standard_D2_v2
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
          resourceGroupName: myResourceGroup
          storageProfile:
            dataDisks:
              - createOption: Empty
                diskSizeGB: 1023
                lun: 0
                vhd:
                  uri: http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk0.vhd
              - createOption: Empty
                diskSizeGB: 1023
                lun: 1
                vhd:
                  uri: http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk1.vhd
            imageReference:
              offer: WindowsServer
              publisher: MicrosoftWindowsServer
              sku: 2016-Datacenter
              version: latest
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              name: myVMosdisk
              vhd:
                uri: http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd
          vmName: '{vm-name}'
    

    Create a vm from a custom image.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D1_v2",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
            },
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                    Name = "myVMosdisk",
                },
            },
            VmName = "myVM",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM")
                ))
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("imageReference", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}")),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadWrite"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
                        Map.entry("name", "myVMosdisk")
                    ))
                ))
                .vmName("myVM")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D1_v2",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
        ),
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            image_reference=azure_native.compute.ImageReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.ManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
                "name": "myVMosdisk",
            },
        ),
        vm_name="myVM")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        hardwareProfile: {
            vmSize: "Standard_D1_v2",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
        },
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            imageReference: {
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Standard_LRS",
                },
                name: "myVMosdisk",
            },
        },
        vmName: "myVM",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          hardwareProfile:
            vmSize: Standard_D1_v2
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
          resourceGroupName: myResourceGroup
          storageProfile:
            imageReference:
              id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              managedDisk:
                storageAccountType: Standard_LRS
              name: myVMosdisk
          vmName: myVM
    

    Create a vm from a generalized shared image.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D1_v2",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
            },
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                    Name = "myVMosdisk",
                },
            },
            VmName = "myVM",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM")
                ))
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("imageReference", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage")),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadWrite"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
                        Map.entry("name", "myVMosdisk")
                    ))
                ))
                .vmName("myVM")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D1_v2",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
        ),
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            image_reference=azure_native.compute.ImageReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.ManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
                "name": "myVMosdisk",
            },
        ),
        vm_name="myVM")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        hardwareProfile: {
            vmSize: "Standard_D1_v2",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
        },
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            imageReference: {
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Standard_LRS",
                },
                name: "myVMosdisk",
            },
        },
        vmName: "myVM",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          hardwareProfile:
            vmSize: Standard_D1_v2
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
          resourceGroupName: myResourceGroup
          storageProfile:
            imageReference:
              id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              managedDisk:
                storageAccountType: Standard_LRS
              name: myVMosdisk
          vmName: myVM
    

    Create a vm from a specialized shared image.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D1_v2",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                    Name = "myVMosdisk",
                },
            },
            VmName = "myVM",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("imageReference", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage")),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadWrite"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
                        Map.entry("name", "myVMosdisk")
                    ))
                ))
                .vmName("myVM")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D1_v2",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            image_reference=azure_native.compute.ImageReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.ManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
                "name": "myVMosdisk",
            },
        ),
        vm_name="myVM")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        hardwareProfile: {
            vmSize: "Standard_D1_v2",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            imageReference: {
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Standard_LRS",
                },
                name: "myVMosdisk",
            },
        },
        vmName: "myVM",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          hardwareProfile:
            vmSize: Standard_D1_v2
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          resourceGroupName: myResourceGroup
          storageProfile:
            imageReference:
              id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              managedDisk:
                storageAccountType: Standard_LRS
              name: myVMosdisk
          vmName: myVM
    

    Create a vm in a Virtual Machine Scale Set with customer assigned platformFaultDomain.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D1_v2",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
            },
            PlatformFaultDomain = 1,
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "WindowsServer",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "2016-Datacenter",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                    Name = "myVMosdisk",
                },
            },
            VirtualMachineScaleSet = new AzureNative.Compute.Inputs.SubResourceArgs
            {
                Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachineScaleSets/{existing-flex-vmss-name-with-platformFaultDomainCount-greater-than-1}",
            },
            VmName = "myVM",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM")
                ))
                .platformFaultDomain(1)
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("imageReference", Map.ofEntries(
                        Map.entry("offer", "WindowsServer"),
                        Map.entry("publisher", "MicrosoftWindowsServer"),
                        Map.entry("sku", "2016-Datacenter"),
                        Map.entry("version", "latest")
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadWrite"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
                        Map.entry("name", "myVMosdisk")
                    ))
                ))
                .virtualMachineScaleSet(Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachineScaleSets/{existing-flex-vmss-name-with-platformFaultDomainCount-greater-than-1}"))
                .vmName("myVM")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D1_v2",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
        ),
        platform_fault_domain=1,
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            image_reference=azure_native.compute.ImageReferenceArgs(
                offer="WindowsServer",
                publisher="MicrosoftWindowsServer",
                sku="2016-Datacenter",
                version="latest",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.ManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
                "name": "myVMosdisk",
            },
        ),
        virtual_machine_scale_set=azure_native.compute.SubResourceArgs(
            id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachineScaleSets/{existing-flex-vmss-name-with-platformFaultDomainCount-greater-than-1}",
        ),
        vm_name="myVM")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        hardwareProfile: {
            vmSize: "Standard_D1_v2",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
        },
        platformFaultDomain: 1,
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            imageReference: {
                offer: "WindowsServer",
                publisher: "MicrosoftWindowsServer",
                sku: "2016-Datacenter",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Standard_LRS",
                },
                name: "myVMosdisk",
            },
        },
        virtualMachineScaleSet: {
            id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachineScaleSets/{existing-flex-vmss-name-with-platformFaultDomainCount-greater-than-1}",
        },
        vmName: "myVM",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          hardwareProfile:
            vmSize: Standard_D1_v2
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
          platformFaultDomain: 1
          resourceGroupName: myResourceGroup
          storageProfile:
            imageReference:
              offer: WindowsServer
              publisher: MicrosoftWindowsServer
              sku: 2016-Datacenter
              version: latest
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              managedDisk:
                storageAccountType: Standard_LRS
              name: myVMosdisk
          virtualMachineScaleSet:
            id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachineScaleSets/{existing-flex-vmss-name-with-platformFaultDomainCount-greater-than-1}
          vmName: myVM
    

    Create a vm in an availability set.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            AvailabilitySet = new AzureNative.Compute.Inputs.SubResourceArgs
            {
                Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/availabilitySets/{existing-availability-set-name}",
            },
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D1_v2",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
            },
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "WindowsServer",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "2016-Datacenter",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                    Name = "myVMosdisk",
                },
            },
            VmName = "myVM",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .availabilitySet(Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/availabilitySets/{existing-availability-set-name}"))
                .hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM")
                ))
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("imageReference", Map.ofEntries(
                        Map.entry("offer", "WindowsServer"),
                        Map.entry("publisher", "MicrosoftWindowsServer"),
                        Map.entry("sku", "2016-Datacenter"),
                        Map.entry("version", "latest")
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadWrite"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
                        Map.entry("name", "myVMosdisk")
                    ))
                ))
                .vmName("myVM")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        availability_set=azure_native.compute.SubResourceArgs(
            id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/availabilitySets/{existing-availability-set-name}",
        ),
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D1_v2",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
        ),
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            image_reference=azure_native.compute.ImageReferenceArgs(
                offer="WindowsServer",
                publisher="MicrosoftWindowsServer",
                sku="2016-Datacenter",
                version="latest",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.ManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
                "name": "myVMosdisk",
            },
        ),
        vm_name="myVM")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        availabilitySet: {
            id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/availabilitySets/{existing-availability-set-name}",
        },
        hardwareProfile: {
            vmSize: "Standard_D1_v2",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
        },
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            imageReference: {
                offer: "WindowsServer",
                publisher: "MicrosoftWindowsServer",
                sku: "2016-Datacenter",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Standard_LRS",
                },
                name: "myVMosdisk",
            },
        },
        vmName: "myVM",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          availabilitySet:
            id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/availabilitySets/{existing-availability-set-name}
          hardwareProfile:
            vmSize: Standard_D1_v2
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
          resourceGroupName: myResourceGroup
          storageProfile:
            imageReference:
              offer: WindowsServer
              publisher: MicrosoftWindowsServer
              sku: 2016-Datacenter
              version: latest
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              managedDisk:
                storageAccountType: Standard_LRS
              name: myVMosdisk
          vmName: myVM
    

    Create a vm with DiskEncryptionSet resource id in the os disk and data disk.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D1_v2",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
            },
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                DataDisks = new[]
                {
                    new AzureNative.Compute.Inputs.DataDiskArgs
                    {
                        Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                        CreateOption = "Empty",
                        DiskSizeGB = 1023,
                        Lun = 0,
                        ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                        {
                            DiskEncryptionSet = new AzureNative.Compute.Inputs.DiskEncryptionSetParametersArgs
                            {
                                Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                            },
                            StorageAccountType = "Standard_LRS",
                        },
                    },
                    new AzureNative.Compute.Inputs.DataDiskArgs
                    {
                        Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                        CreateOption = "Attach",
                        DiskSizeGB = 1023,
                        Lun = 1,
                        ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                        {
                            DiskEncryptionSet = new AzureNative.Compute.Inputs.DiskEncryptionSetParametersArgs
                            {
                                Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                            },
                            Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/{existing-managed-disk-name}",
                            StorageAccountType = "Standard_LRS",
                        },
                    },
                },
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        DiskEncryptionSet = new AzureNative.Compute.Inputs.DiskEncryptionSetParametersArgs
                        {
                            Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                        },
                        StorageAccountType = "Standard_LRS",
                    },
                    Name = "myVMosdisk",
                },
            },
            VmName = "myVM",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM")
                ))
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("dataDisks",                 
                        Map.ofEntries(
                            Map.entry("caching", "ReadWrite"),
                            Map.entry("createOption", "Empty"),
                            Map.entry("diskSizeGB", 1023),
                            Map.entry("lun", 0),
                            Map.entry("managedDisk", Map.ofEntries(
                                Map.entry("diskEncryptionSet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}")),
                                Map.entry("storageAccountType", "Standard_LRS")
                            ))
                        ),
                        Map.ofEntries(
                            Map.entry("caching", "ReadWrite"),
                            Map.entry("createOption", "Attach"),
                            Map.entry("diskSizeGB", 1023),
                            Map.entry("lun", 1),
                            Map.entry("managedDisk", Map.ofEntries(
                                Map.entry("diskEncryptionSet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}")),
                                Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/{existing-managed-disk-name}"),
                                Map.entry("storageAccountType", "Standard_LRS")
                            ))
                        )),
                    Map.entry("imageReference", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}")),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadWrite"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.ofEntries(
                            Map.entry("diskEncryptionSet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}")),
                            Map.entry("storageAccountType", "Standard_LRS")
                        )),
                        Map.entry("name", "myVMosdisk")
                    ))
                ))
                .vmName("myVM")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D1_v2",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
        ),
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            data_disks=[
                {
                    "caching": azure_native.compute.CachingTypes.READ_WRITE,
                    "createOption": "Empty",
                    "diskSizeGB": 1023,
                    "lun": 0,
                    "managedDisk": {
                        "diskEncryptionSet": azure_native.compute.DiskEncryptionSetParametersArgs(
                            id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                        ),
                        "storageAccountType": "Standard_LRS",
                    },
                },
                {
                    "caching": azure_native.compute.CachingTypes.READ_WRITE,
                    "createOption": "Attach",
                    "diskSizeGB": 1023,
                    "lun": 1,
                    "managedDisk": {
                        "diskEncryptionSet": azure_native.compute.DiskEncryptionSetParametersArgs(
                            id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                        ),
                        "id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/{existing-managed-disk-name}",
                        "storageAccountType": "Standard_LRS",
                    },
                },
            ],
            image_reference=azure_native.compute.ImageReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": {
                    "diskEncryptionSet": azure_native.compute.DiskEncryptionSetParametersArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                    ),
                    "storageAccountType": "Standard_LRS",
                },
                "name": "myVMosdisk",
            },
        ),
        vm_name="myVM")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        hardwareProfile: {
            vmSize: "Standard_D1_v2",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
        },
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            dataDisks: [
                {
                    caching: azure_native.compute.CachingTypes.ReadWrite,
                    createOption: "Empty",
                    diskSizeGB: 1023,
                    lun: 0,
                    managedDisk: {
                        diskEncryptionSet: {
                            id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                        },
                        storageAccountType: "Standard_LRS",
                    },
                },
                {
                    caching: azure_native.compute.CachingTypes.ReadWrite,
                    createOption: "Attach",
                    diskSizeGB: 1023,
                    lun: 1,
                    managedDisk: {
                        diskEncryptionSet: {
                            id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                        },
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/{existing-managed-disk-name}",
                        storageAccountType: "Standard_LRS",
                    },
                },
            ],
            imageReference: {
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    diskEncryptionSet: {
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                    },
                    storageAccountType: "Standard_LRS",
                },
                name: "myVMosdisk",
            },
        },
        vmName: "myVM",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          hardwareProfile:
            vmSize: Standard_D1_v2
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
          resourceGroupName: myResourceGroup
          storageProfile:
            dataDisks:
              - caching: ReadWrite
                createOption: Empty
                diskSizeGB: 1023
                lun: 0
                managedDisk:
                  diskEncryptionSet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}
                  storageAccountType: Standard_LRS
              - caching: ReadWrite
                createOption: Attach
                diskSizeGB: 1023
                lun: 1
                managedDisk:
                  diskEncryptionSet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}
                  id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/{existing-managed-disk-name}
                  storageAccountType: Standard_LRS
            imageReference:
              id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              managedDisk:
                diskEncryptionSet:
                  id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}
                storageAccountType: Standard_LRS
              name: myVMosdisk
          vmName: myVM
    

    Create a vm with Host Encryption using encryptionAtHost property.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_DS1_v2",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
            },
            Plan = new AzureNative.Compute.Inputs.PlanArgs
            {
                Name = "windows2016",
                Product = "windows-data-science-vm",
                Publisher = "microsoft-ads",
            },
            ResourceGroupName = "myResourceGroup",
            SecurityProfile = new AzureNative.Compute.Inputs.SecurityProfileArgs
            {
                EncryptionAtHost = true,
            },
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "windows-data-science-vm",
                    Publisher = "microsoft-ads",
                    Sku = "windows2016",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadOnly,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                    Name = "myVMosdisk",
                },
            },
            VmName = "myVM",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .hardwareProfile(Map.of("vmSize", "Standard_DS1_v2"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM")
                ))
                .plan(Map.ofEntries(
                    Map.entry("name", "windows2016"),
                    Map.entry("product", "windows-data-science-vm"),
                    Map.entry("publisher", "microsoft-ads")
                ))
                .resourceGroupName("myResourceGroup")
                .securityProfile(Map.of("encryptionAtHost", true))
                .storageProfile(Map.ofEntries(
                    Map.entry("imageReference", Map.ofEntries(
                        Map.entry("offer", "windows-data-science-vm"),
                        Map.entry("publisher", "microsoft-ads"),
                        Map.entry("sku", "windows2016"),
                        Map.entry("version", "latest")
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadOnly"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
                        Map.entry("name", "myVMosdisk")
                    ))
                ))
                .vmName("myVM")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_DS1_v2",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
        ),
        plan=azure_native.compute.PlanArgs(
            name="windows2016",
            product="windows-data-science-vm",
            publisher="microsoft-ads",
        ),
        resource_group_name="myResourceGroup",
        security_profile=azure_native.compute.SecurityProfileArgs(
            encryption_at_host=True,
        ),
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            image_reference=azure_native.compute.ImageReferenceArgs(
                offer="windows-data-science-vm",
                publisher="microsoft-ads",
                sku="windows2016",
                version="latest",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_ONLY,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.ManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
                "name": "myVMosdisk",
            },
        ),
        vm_name="myVM")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        hardwareProfile: {
            vmSize: "Standard_DS1_v2",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
        },
        plan: {
            name: "windows2016",
            product: "windows-data-science-vm",
            publisher: "microsoft-ads",
        },
        resourceGroupName: "myResourceGroup",
        securityProfile: {
            encryptionAtHost: true,
        },
        storageProfile: {
            imageReference: {
                offer: "windows-data-science-vm",
                publisher: "microsoft-ads",
                sku: "windows2016",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadOnly,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Standard_LRS",
                },
                name: "myVMosdisk",
            },
        },
        vmName: "myVM",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          hardwareProfile:
            vmSize: Standard_DS1_v2
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
          plan:
            name: windows2016
            product: windows-data-science-vm
            publisher: microsoft-ads
          resourceGroupName: myResourceGroup
          securityProfile:
            encryptionAtHost: true
          storageProfile:
            imageReference:
              offer: windows-data-science-vm
              publisher: microsoft-ads
              sku: windows2016
              version: latest
            osDisk:
              caching: ReadOnly
              createOption: FromImage
              managedDisk:
                storageAccountType: Standard_LRS
              name: myVMosdisk
          vmName: myVM
    

    Create a vm with Scheduled Events Profile

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            DiagnosticsProfile = new AzureNative.Compute.Inputs.DiagnosticsProfileArgs
            {
                BootDiagnostics = new AzureNative.Compute.Inputs.BootDiagnosticsArgs
                {
                    Enabled = true,
                    StorageUri = "http://{existing-storage-account-name}.blob.core.windows.net",
                },
            },
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D1_v2",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
            },
            ResourceGroupName = "myResourceGroup",
            ScheduledEventsProfile = new AzureNative.Compute.Inputs.ScheduledEventsProfileArgs
            {
                TerminateNotificationProfile = new AzureNative.Compute.Inputs.TerminateNotificationProfileArgs
                {
                    Enable = true,
                    NotBeforeTimeout = "PT10M",
                },
            },
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "WindowsServer",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "2016-Datacenter",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                    Name = "myVMosdisk",
                },
            },
            VmName = "myVM",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .diagnosticsProfile(Map.of("bootDiagnostics", Map.ofEntries(
                    Map.entry("enabled", true),
                    Map.entry("storageUri", "http://{existing-storage-account-name}.blob.core.windows.net")
                )))
                .hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM")
                ))
                .resourceGroupName("myResourceGroup")
                .scheduledEventsProfile(Map.of("terminateNotificationProfile", Map.ofEntries(
                    Map.entry("enable", true),
                    Map.entry("notBeforeTimeout", "PT10M")
                )))
                .storageProfile(Map.ofEntries(
                    Map.entry("imageReference", Map.ofEntries(
                        Map.entry("offer", "WindowsServer"),
                        Map.entry("publisher", "MicrosoftWindowsServer"),
                        Map.entry("sku", "2016-Datacenter"),
                        Map.entry("version", "latest")
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadWrite"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
                        Map.entry("name", "myVMosdisk")
                    ))
                ))
                .vmName("myVM")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        diagnostics_profile=azure_native.compute.DiagnosticsProfileResponseArgs(
            boot_diagnostics=azure_native.compute.BootDiagnosticsArgs(
                enabled=True,
                storage_uri="http://{existing-storage-account-name}.blob.core.windows.net",
            ),
        ),
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D1_v2",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
        ),
        resource_group_name="myResourceGroup",
        scheduled_events_profile=azure_native.compute.ScheduledEventsProfileResponseArgs(
            terminate_notification_profile=azure_native.compute.TerminateNotificationProfileArgs(
                enable=True,
                not_before_timeout="PT10M",
            ),
        ),
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            image_reference=azure_native.compute.ImageReferenceArgs(
                offer="WindowsServer",
                publisher="MicrosoftWindowsServer",
                sku="2016-Datacenter",
                version="latest",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.ManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
                "name": "myVMosdisk",
            },
        ),
        vm_name="myVM")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        diagnosticsProfile: {
            bootDiagnostics: {
                enabled: true,
                storageUri: "http://{existing-storage-account-name}.blob.core.windows.net",
            },
        },
        hardwareProfile: {
            vmSize: "Standard_D1_v2",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
        },
        resourceGroupName: "myResourceGroup",
        scheduledEventsProfile: {
            terminateNotificationProfile: {
                enable: true,
                notBeforeTimeout: "PT10M",
            },
        },
        storageProfile: {
            imageReference: {
                offer: "WindowsServer",
                publisher: "MicrosoftWindowsServer",
                sku: "2016-Datacenter",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Standard_LRS",
                },
                name: "myVMosdisk",
            },
        },
        vmName: "myVM",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          diagnosticsProfile:
            bootDiagnostics:
              enabled: true
              storageUri: http://{existing-storage-account-name}.blob.core.windows.net
          hardwareProfile:
            vmSize: Standard_D1_v2
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
          resourceGroupName: myResourceGroup
          scheduledEventsProfile:
            terminateNotificationProfile:
              enable: true
              notBeforeTimeout: PT10M
          storageProfile:
            imageReference:
              offer: WindowsServer
              publisher: MicrosoftWindowsServer
              sku: 2016-Datacenter
              version: latest
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              managedDisk:
                storageAccountType: Standard_LRS
              name: myVMosdisk
          vmName: myVM
    

    Create a vm with a marketplace image plan.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D1_v2",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
            },
            Plan = new AzureNative.Compute.Inputs.PlanArgs
            {
                Name = "windows2016",
                Product = "windows-data-science-vm",
                Publisher = "microsoft-ads",
            },
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "windows-data-science-vm",
                    Publisher = "microsoft-ads",
                    Sku = "windows2016",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                    Name = "myVMosdisk",
                },
            },
            VmName = "myVM",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM")
                ))
                .plan(Map.ofEntries(
                    Map.entry("name", "windows2016"),
                    Map.entry("product", "windows-data-science-vm"),
                    Map.entry("publisher", "microsoft-ads")
                ))
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("imageReference", Map.ofEntries(
                        Map.entry("offer", "windows-data-science-vm"),
                        Map.entry("publisher", "microsoft-ads"),
                        Map.entry("sku", "windows2016"),
                        Map.entry("version", "latest")
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadWrite"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
                        Map.entry("name", "myVMosdisk")
                    ))
                ))
                .vmName("myVM")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D1_v2",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
        ),
        plan=azure_native.compute.PlanArgs(
            name="windows2016",
            product="windows-data-science-vm",
            publisher="microsoft-ads",
        ),
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            image_reference=azure_native.compute.ImageReferenceArgs(
                offer="windows-data-science-vm",
                publisher="microsoft-ads",
                sku="windows2016",
                version="latest",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.ManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
                "name": "myVMosdisk",
            },
        ),
        vm_name="myVM")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        hardwareProfile: {
            vmSize: "Standard_D1_v2",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
        },
        plan: {
            name: "windows2016",
            product: "windows-data-science-vm",
            publisher: "microsoft-ads",
        },
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            imageReference: {
                offer: "windows-data-science-vm",
                publisher: "microsoft-ads",
                sku: "windows2016",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Standard_LRS",
                },
                name: "myVMosdisk",
            },
        },
        vmName: "myVM",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          hardwareProfile:
            vmSize: Standard_D1_v2
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
          plan:
            name: windows2016
            product: windows-data-science-vm
            publisher: microsoft-ads
          resourceGroupName: myResourceGroup
          storageProfile:
            imageReference:
              offer: windows-data-science-vm
              publisher: microsoft-ads
              sku: windows2016
              version: latest
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              managedDisk:
                storageAccountType: Standard_LRS
              name: myVMosdisk
          vmName: myVM
    

    Create a vm with an extensions time budget.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            DiagnosticsProfile = new AzureNative.Compute.Inputs.DiagnosticsProfileArgs
            {
                BootDiagnostics = new AzureNative.Compute.Inputs.BootDiagnosticsArgs
                {
                    Enabled = true,
                    StorageUri = "http://{existing-storage-account-name}.blob.core.windows.net",
                },
            },
            ExtensionsTimeBudget = "PT30M",
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D1_v2",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerName = "myVM",
            },
            ResourceGroupName = "myResourceGroup",
            StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "WindowsServer",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "2016-Datacenter",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                    Name = "myVMosdisk",
                },
            },
            VmName = "myVM",
        });
    
    });
    

    Coming soon!

    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.azurenative.compute.VirtualMachine;
    import com.pulumi.azurenative.compute.VirtualMachineArgs;
    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 virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()        
                .diagnosticsProfile(Map.of("bootDiagnostics", Map.ofEntries(
                    Map.entry("enabled", true),
                    Map.entry("storageUri", "http://{existing-storage-account-name}.blob.core.windows.net")
                )))
                .extensionsTimeBudget("PT30M")
                .hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
                .location("westus")
                .networkProfile(Map.of("networkInterfaces", Map.ofEntries(
                    Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
                    Map.entry("primary", true)
                )))
                .osProfile(Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerName", "myVM")
                ))
                .resourceGroupName("myResourceGroup")
                .storageProfile(Map.ofEntries(
                    Map.entry("imageReference", Map.ofEntries(
                        Map.entry("offer", "WindowsServer"),
                        Map.entry("publisher", "MicrosoftWindowsServer"),
                        Map.entry("sku", "2016-Datacenter"),
                        Map.entry("version", "latest")
                    )),
                    Map.entry("osDisk", Map.ofEntries(
                        Map.entry("caching", "ReadWrite"),
                        Map.entry("createOption", "FromImage"),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
                        Map.entry("name", "myVMosdisk")
                    ))
                ))
                .vmName("myVM")
                .build());
    
        }
    }
    
    import pulumi
    import pulumi_azure_native as azure_native
    
    virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
        diagnostics_profile=azure_native.compute.DiagnosticsProfileResponseArgs(
            boot_diagnostics=azure_native.compute.BootDiagnosticsArgs(
                enabled=True,
                storage_uri="http://{existing-storage-account-name}.blob.core.windows.net",
            ),
        ),
        extensions_time_budget="PT30M",
        hardware_profile=azure_native.compute.HardwareProfileArgs(
            vm_size="Standard_D1_v2",
        ),
        location="westus",
        network_profile=azure_native.compute.NetworkProfileResponseArgs(
            network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary=True,
            )],
        ),
        os_profile=azure_native.compute.OSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name="myVM",
        ),
        resource_group_name="myResourceGroup",
        storage_profile=azure_native.compute.StorageProfileResponseArgs(
            image_reference=azure_native.compute.ImageReferenceArgs(
                offer="WindowsServer",
                publisher="MicrosoftWindowsServer",
                sku="2016-Datacenter",
                version="latest",
            ),
            os_disk={
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.ManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
                "name": "myVMosdisk",
            },
        ),
        vm_name="myVM")
    
    import * as pulumi from "@pulumi/pulumi";
    import * as azure_native from "@pulumi/azure-native";
    
    const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
        diagnosticsProfile: {
            bootDiagnostics: {
                enabled: true,
                storageUri: "http://{existing-storage-account-name}.blob.core.windows.net",
            },
        },
        extensionsTimeBudget: "PT30M",
        hardwareProfile: {
            vmSize: "Standard_D1_v2",
        },
        location: "westus",
        networkProfile: {
            networkInterfaces: [{
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerName: "myVM",
        },
        resourceGroupName: "myResourceGroup",
        storageProfile: {
            imageReference: {
                offer: "WindowsServer",
                publisher: "MicrosoftWindowsServer",
                sku: "2016-Datacenter",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Standard_LRS",
                },
                name: "myVMosdisk",
            },
        },
        vmName: "myVM",
    });
    
    resources:
      virtualMachine:
        type: azure-native:compute:VirtualMachine
        properties:
          diagnosticsProfile:
            bootDiagnostics:
              enabled: true
              storageUri: http://{existing-storage-account-name}.blob.core.windows.net
          extensionsTimeBudget: PT30M
          hardwareProfile:
            vmSize: Standard_D1_v2
          location: westus
          networkProfile:
            networkInterfaces:
              - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
                primary: true
          osProfile:
            adminPassword: '{your-password}'
            adminUsername: '{your-username}'
            computerName: myVM
          resourceGroupName: myResourceGroup
          storageProfile:
            imageReference:
              offer: WindowsServer
              publisher: MicrosoftWindowsServer
              sku: 2016-Datacenter
              version: latest
            osDisk:
              caching: ReadWrite
              createOption: FromImage
              managedDisk:
                storageAccountType: Standard_LRS
              name: myVMosdisk
          vmName: myVM
    

    Create a vm with boot diagnostics.

    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using AzureNative = Pulumi.AzureNative;
    
    return await Deployment.RunAsync(() => 
    {
        var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
        {
            DiagnosticsProfile = new AzureNative.Compute.Inputs.DiagnosticsProfileArgs
            {
                BootDiagnostics = new AzureNative.Compute.Inputs.BootDiagnosticsArgs
                {
                    Enabled = true,
                    StorageUri = "http://{existing-storage-account-name}.blob.core.windows.net",
                },
            },
            HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
            {
                VmSize = "Standard_D1_v2",
            },
            Location = "westus",
            NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
            {
                NetworkInterfaces = new[]
                {
                    new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
                    {
                        Id = "/subscriptions/{subscription