azure-native.compute.VirtualMachine

using System.Collections.Generic;
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",
    });

});

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

using System.Collections.Generic;
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",
    });

});

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

using System.Collections.Generic;
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",
    });

});

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

using System.Collections.Generic;
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",
    });

});

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

using System.Collections.Generic;
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}",
    });

});

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}'

using System.Collections.Generic;
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",
    });

});