azure-native.compute.VirtualMachineScaleSet

Explore with Pulumi AI

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

Example Usage

Create a custom-image scale set from an unmanaged generalized os image.

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

return await Deployment.RunAsync(() => 
{
    var virtualMachineScaleSet = new AzureNative.Compute.VirtualMachineScaleSet("virtualMachineScaleSet", new()
    {
        Location = "westus",
        Overprovision = true,
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.SkuArgs
        {
            Capacity = 3,
            Name = "Standard_D1_v2",
            Tier = "Standard",
        },
        UpgradePolicy = new AzureNative.Compute.Inputs.UpgradePolicyArgs
        {
            Mode = AzureNative.Compute.UpgradeMode.Manual,
        },
        VirtualMachineProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetVMProfileArgs
        {
            NetworkProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkProfileArgs
            {
                NetworkInterfaceConfigurations = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkConfigurationArgs
                    {
                        EnableIPForwarding = true,
                        IpConfigurations = new[]
                        {
                            new AzureNative.Compute.Inputs.VirtualMachineScaleSetIPConfigurationArgs
                            {
                                Name = "{vmss-name}",
                                Subnet = new AzureNative.Compute.Inputs.ApiEntityReferenceArgs
                                {
                                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                                },
                            },
                        },
                        Name = "{vmss-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerNamePrefix = "{vmss-name}",
            },
            StorageProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetStorageProfileArgs
            {
                OsDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSDiskArgs
                {
                    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 = "osDisk",
                },
            },
        },
        VmScaleSetName = "{vmss-name}",
    });

});

Coming soon!

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachineScaleSet;
import com.pulumi.azurenative.compute.VirtualMachineScaleSetArgs;
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 virtualMachineScaleSet = new VirtualMachineScaleSet("virtualMachineScaleSet", VirtualMachineScaleSetArgs.builder()        
            .location("westus")
            .overprovision(true)
            .resourceGroupName("myResourceGroup")
            .sku(Map.ofEntries(
                Map.entry("capacity", 3),
                Map.entry("name", "Standard_D1_v2"),
                Map.entry("tier", "Standard")
            ))
            .upgradePolicy(Map.of("mode", "Manual"))
            .virtualMachineProfile(Map.ofEntries(
                Map.entry("networkProfile", Map.of("networkInterfaceConfigurations", Map.ofEntries(
                    Map.entry("enableIPForwarding", true),
                    Map.entry("ipConfigurations", Map.ofEntries(
                        Map.entry("name", "{vmss-name}"),
                        Map.entry("subnet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}"))
                    )),
                    Map.entry("name", "{vmss-name}"),
                    Map.entry("primary", true)
                ))),
                Map.entry("osProfile", Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerNamePrefix", "{vmss-name}")
                )),
                Map.entry("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", "osDisk")
                )))
            ))
            .vmScaleSetName("{vmss-name}")
            .build());

    }
}
import pulumi
import pulumi_azure_native as azure_native

virtual_machine_scale_set = azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet",
    location="westus",
    overprovision=True,
    resource_group_name="myResourceGroup",
    sku=azure_native.compute.SkuArgs(
        capacity=3,
        name="Standard_D1_v2",
        tier="Standard",
    ),
    upgrade_policy=azure_native.compute.UpgradePolicyArgs(
        mode=azure_native.compute.UpgradeMode.MANUAL,
    ),
    virtual_machine_profile=azure_native.compute.VirtualMachineScaleSetVMProfileResponseArgs(
        network_profile={
            "networkInterfaceConfigurations": [{
                "enableIPForwarding": True,
                "ipConfigurations": [{
                    "name": "{vmss-name}",
                    "subnet": azure_native.compute.ApiEntityReferenceArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    ),
                }],
                "name": "{vmss-name}",
                "primary": True,
            }],
        },
        os_profile=azure_native.compute.VirtualMachineScaleSetOSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name_prefix="{vmss-name}",
        ),
        storage_profile={
            "osDisk": {
                "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": "osDisk",
            },
        },
    ),
    vm_scale_set_name="{vmss-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const virtualMachineScaleSet = new azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet", {
    location: "westus",
    overprovision: true,
    resourceGroupName: "myResourceGroup",
    sku: {
        capacity: 3,
        name: "Standard_D1_v2",
        tier: "Standard",
    },
    upgradePolicy: {
        mode: azure_native.compute.UpgradeMode.Manual,
    },
    virtualMachineProfile: {
        networkProfile: {
            networkInterfaceConfigurations: [{
                enableIPForwarding: true,
                ipConfigurations: [{
                    name: "{vmss-name}",
                    subnet: {
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    },
                }],
                name: "{vmss-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerNamePrefix: "{vmss-name}",
        },
        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: "osDisk",
            },
        },
    },
    vmScaleSetName: "{vmss-name}",
});
resources:
  virtualMachineScaleSet:
    type: azure-native:compute:VirtualMachineScaleSet
    properties:
      location: westus
      overprovision: true
      resourceGroupName: myResourceGroup
      sku:
        capacity: 3
        name: Standard_D1_v2
        tier: Standard
      upgradePolicy:
        mode: Manual
      virtualMachineProfile:
        networkProfile:
          networkInterfaceConfigurations:
            - enableIPForwarding: true
              ipConfigurations:
                - name: '{vmss-name}'
                  subnet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}
              name: '{vmss-name}'
              primary: true
        osProfile:
          adminPassword: '{your-password}'
          adminUsername: '{your-username}'
          computerNamePrefix: '{vmss-name}'
        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: osDisk
      vmScaleSetName: '{vmss-name}'

Create a platform-image scale set with unmanaged os disks.

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

return await Deployment.RunAsync(() => 
{
    var virtualMachineScaleSet = new AzureNative.Compute.VirtualMachineScaleSet("virtualMachineScaleSet", new()
    {
        Location = "westus",
        Overprovision = true,
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.SkuArgs
        {
            Capacity = 3,
            Name = "Standard_D1_v2",
            Tier = "Standard",
        },
        UpgradePolicy = new AzureNative.Compute.Inputs.UpgradePolicyArgs
        {
            Mode = AzureNative.Compute.UpgradeMode.Manual,
        },
        VirtualMachineProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetVMProfileArgs
        {
            NetworkProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkProfileArgs
            {
                NetworkInterfaceConfigurations = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkConfigurationArgs
                    {
                        EnableIPForwarding = true,
                        IpConfigurations = new[]
                        {
                            new AzureNative.Compute.Inputs.VirtualMachineScaleSetIPConfigurationArgs
                            {
                                Name = "{vmss-name}",
                                Subnet = new AzureNative.Compute.Inputs.ApiEntityReferenceArgs
                                {
                                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                                },
                            },
                        },
                        Name = "{vmss-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerNamePrefix = "{vmss-name}",
            },
            StorageProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetStorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "WindowsServer",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "2016-Datacenter",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    Name = "osDisk",
                    VhdContainers = new[]
                    {
                        "http://{existing-storage-account-name-0}.blob.core.windows.net/vhdContainer",
                        "http://{existing-storage-account-name-1}.blob.core.windows.net/vhdContainer",
                        "http://{existing-storage-account-name-2}.blob.core.windows.net/vhdContainer",
                        "http://{existing-storage-account-name-3}.blob.core.windows.net/vhdContainer",
                        "http://{existing-storage-account-name-4}.blob.core.windows.net/vhdContainer",
                    },
                },
            },
        },
        VmScaleSetName = "{vmss-name}",
    });

});

Coming soon!

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachineScaleSet;
import com.pulumi.azurenative.compute.VirtualMachineScaleSetArgs;
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 virtualMachineScaleSet = new VirtualMachineScaleSet("virtualMachineScaleSet", VirtualMachineScaleSetArgs.builder()        
            .location("westus")
            .overprovision(true)
            .resourceGroupName("myResourceGroup")
            .sku(Map.ofEntries(
                Map.entry("capacity", 3),
                Map.entry("name", "Standard_D1_v2"),
                Map.entry("tier", "Standard")
            ))
            .upgradePolicy(Map.of("mode", "Manual"))
            .virtualMachineProfile(Map.ofEntries(
                Map.entry("networkProfile", Map.of("networkInterfaceConfigurations", Map.ofEntries(
                    Map.entry("enableIPForwarding", true),
                    Map.entry("ipConfigurations", Map.ofEntries(
                        Map.entry("name", "{vmss-name}"),
                        Map.entry("subnet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}"))
                    )),
                    Map.entry("name", "{vmss-name}"),
                    Map.entry("primary", true)
                ))),
                Map.entry("osProfile", Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerNamePrefix", "{vmss-name}")
                )),
                Map.entry("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("name", "osDisk"),
                        Map.entry("vhdContainers",                         
                            "http://{existing-storage-account-name-0}.blob.core.windows.net/vhdContainer",
                            "http://{existing-storage-account-name-1}.blob.core.windows.net/vhdContainer",
                            "http://{existing-storage-account-name-2}.blob.core.windows.net/vhdContainer",
                            "http://{existing-storage-account-name-3}.blob.core.windows.net/vhdContainer",
                            "http://{existing-storage-account-name-4}.blob.core.windows.net/vhdContainer")
                    ))
                ))
            ))
            .vmScaleSetName("{vmss-name}")
            .build());

    }
}
import pulumi
import pulumi_azure_native as azure_native

virtual_machine_scale_set = azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet",
    location="westus",
    overprovision=True,
    resource_group_name="myResourceGroup",
    sku=azure_native.compute.SkuArgs(
        capacity=3,
        name="Standard_D1_v2",
        tier="Standard",
    ),
    upgrade_policy=azure_native.compute.UpgradePolicyArgs(
        mode=azure_native.compute.UpgradeMode.MANUAL,
    ),
    virtual_machine_profile=azure_native.compute.VirtualMachineScaleSetVMProfileResponseArgs(
        network_profile={
            "networkInterfaceConfigurations": [{
                "enableIPForwarding": True,
                "ipConfigurations": [{
                    "name": "{vmss-name}",
                    "subnet": azure_native.compute.ApiEntityReferenceArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    ),
                }],
                "name": "{vmss-name}",
                "primary": True,
            }],
        },
        os_profile=azure_native.compute.VirtualMachineScaleSetOSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name_prefix="{vmss-name}",
        ),
        storage_profile={
            "imageReference": azure_native.compute.ImageReferenceArgs(
                offer="WindowsServer",
                publisher="MicrosoftWindowsServer",
                sku="2016-Datacenter",
                version="latest",
            ),
            "osDisk": azure_native.compute.VirtualMachineScaleSetOSDiskArgs(
                caching=azure_native.compute.CachingTypes.READ_WRITE,
                create_option="FromImage",
                name="osDisk",
                vhd_containers=[
                    "http://{existing-storage-account-name-0}.blob.core.windows.net/vhdContainer",
                    "http://{existing-storage-account-name-1}.blob.core.windows.net/vhdContainer",
                    "http://{existing-storage-account-name-2}.blob.core.windows.net/vhdContainer",
                    "http://{existing-storage-account-name-3}.blob.core.windows.net/vhdContainer",
                    "http://{existing-storage-account-name-4}.blob.core.windows.net/vhdContainer",
                ],
            ),
        },
    ),
    vm_scale_set_name="{vmss-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const virtualMachineScaleSet = new azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet", {
    location: "westus",
    overprovision: true,
    resourceGroupName: "myResourceGroup",
    sku: {
        capacity: 3,
        name: "Standard_D1_v2",
        tier: "Standard",
    },
    upgradePolicy: {
        mode: azure_native.compute.UpgradeMode.Manual,
    },
    virtualMachineProfile: {
        networkProfile: {
            networkInterfaceConfigurations: [{
                enableIPForwarding: true,
                ipConfigurations: [{
                    name: "{vmss-name}",
                    subnet: {
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    },
                }],
                name: "{vmss-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerNamePrefix: "{vmss-name}",
        },
        storageProfile: {
            imageReference: {
                offer: "WindowsServer",
                publisher: "MicrosoftWindowsServer",
                sku: "2016-Datacenter",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                name: "osDisk",
                vhdContainers: [
                    "http://{existing-storage-account-name-0}.blob.core.windows.net/vhdContainer",
                    "http://{existing-storage-account-name-1}.blob.core.windows.net/vhdContainer",
                    "http://{existing-storage-account-name-2}.blob.core.windows.net/vhdContainer",
                    "http://{existing-storage-account-name-3}.blob.core.windows.net/vhdContainer",
                    "http://{existing-storage-account-name-4}.blob.core.windows.net/vhdContainer",
                ],
            },
        },
    },
    vmScaleSetName: "{vmss-name}",
});
resources:
  virtualMachineScaleSet:
    type: azure-native:compute:VirtualMachineScaleSet
    properties:
      location: westus
      overprovision: true
      resourceGroupName: myResourceGroup
      sku:
        capacity: 3
        name: Standard_D1_v2
        tier: Standard
      upgradePolicy:
        mode: Manual
      virtualMachineProfile:
        networkProfile:
          networkInterfaceConfigurations:
            - enableIPForwarding: true
              ipConfigurations:
                - name: '{vmss-name}'
                  subnet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}
              name: '{vmss-name}'
              primary: true
        osProfile:
          adminPassword: '{your-password}'
          adminUsername: '{your-username}'
          computerNamePrefix: '{vmss-name}'
        storageProfile:
          imageReference:
            offer: WindowsServer
            publisher: MicrosoftWindowsServer
            sku: 2016-Datacenter
            version: latest
          osDisk:
            caching: ReadWrite
            createOption: FromImage
            name: osDisk
            vhdContainers:
              - http://{existing-storage-account-name-0}.blob.core.windows.net/vhdContainer
              - http://{existing-storage-account-name-1}.blob.core.windows.net/vhdContainer
              - http://{existing-storage-account-name-2}.blob.core.windows.net/vhdContainer
              - http://{existing-storage-account-name-3}.blob.core.windows.net/vhdContainer
              - http://{existing-storage-account-name-4}.blob.core.windows.net/vhdContainer
      vmScaleSetName: '{vmss-name}'

Create a scale set from a custom image.

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

return await Deployment.RunAsync(() => 
{
    var virtualMachineScaleSet = new AzureNative.Compute.VirtualMachineScaleSet("virtualMachineScaleSet", new()
    {
        Location = "westus",
        Overprovision = true,
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.SkuArgs
        {
            Capacity = 3,
            Name = "Standard_D1_v2",
            Tier = "Standard",
        },
        UpgradePolicy = new AzureNative.Compute.Inputs.UpgradePolicyArgs
        {
            Mode = AzureNative.Compute.UpgradeMode.Manual,
        },
        VirtualMachineProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetVMProfileArgs
        {
            NetworkProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkProfileArgs
            {
                NetworkInterfaceConfigurations = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkConfigurationArgs
                    {
                        EnableIPForwarding = true,
                        IpConfigurations = new[]
                        {
                            new AzureNative.Compute.Inputs.VirtualMachineScaleSetIPConfigurationArgs
                            {
                                Name = "{vmss-name}",
                                Subnet = new AzureNative.Compute.Inputs.ApiEntityReferenceArgs
                                {
                                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                                },
                            },
                        },
                        Name = "{vmss-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerNamePrefix = "{vmss-name}",
            },
            StorageProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetStorageProfileArgs
            {
                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.VirtualMachineScaleSetOSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                },
            },
        },
        VmScaleSetName = "{vmss-name}",
    });

});

Coming soon!

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachineScaleSet;
import com.pulumi.azurenative.compute.VirtualMachineScaleSetArgs;
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 virtualMachineScaleSet = new VirtualMachineScaleSet("virtualMachineScaleSet", VirtualMachineScaleSetArgs.builder()        
            .location("westus")
            .overprovision(true)
            .resourceGroupName("myResourceGroup")
            .sku(Map.ofEntries(
                Map.entry("capacity", 3),
                Map.entry("name", "Standard_D1_v2"),
                Map.entry("tier", "Standard")
            ))
            .upgradePolicy(Map.of("mode", "Manual"))
            .virtualMachineProfile(Map.ofEntries(
                Map.entry("networkProfile", Map.of("networkInterfaceConfigurations", Map.ofEntries(
                    Map.entry("enableIPForwarding", true),
                    Map.entry("ipConfigurations", Map.ofEntries(
                        Map.entry("name", "{vmss-name}"),
                        Map.entry("subnet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}"))
                    )),
                    Map.entry("name", "{vmss-name}"),
                    Map.entry("primary", true)
                ))),
                Map.entry("osProfile", Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerNamePrefix", "{vmss-name}")
                )),
                Map.entry("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"))
                    ))
                ))
            ))
            .vmScaleSetName("{vmss-name}")
            .build());

    }
}
import pulumi
import pulumi_azure_native as azure_native

virtual_machine_scale_set = azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet",
    location="westus",
    overprovision=True,
    resource_group_name="myResourceGroup",
    sku=azure_native.compute.SkuArgs(
        capacity=3,
        name="Standard_D1_v2",
        tier="Standard",
    ),
    upgrade_policy=azure_native.compute.UpgradePolicyArgs(
        mode=azure_native.compute.UpgradeMode.MANUAL,
    ),
    virtual_machine_profile=azure_native.compute.VirtualMachineScaleSetVMProfileResponseArgs(
        network_profile={
            "networkInterfaceConfigurations": [{
                "enableIPForwarding": True,
                "ipConfigurations": [{
                    "name": "{vmss-name}",
                    "subnet": azure_native.compute.ApiEntityReferenceArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    ),
                }],
                "name": "{vmss-name}",
                "primary": True,
            }],
        },
        os_profile=azure_native.compute.VirtualMachineScaleSetOSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name_prefix="{vmss-name}",
        ),
        storage_profile={
            "imageReference": azure_native.compute.ImageReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}",
            ),
            "osDisk": {
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.VirtualMachineScaleSetManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
            },
        },
    ),
    vm_scale_set_name="{vmss-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const virtualMachineScaleSet = new azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet", {
    location: "westus",
    overprovision: true,
    resourceGroupName: "myResourceGroup",
    sku: {
        capacity: 3,
        name: "Standard_D1_v2",
        tier: "Standard",
    },
    upgradePolicy: {
        mode: azure_native.compute.UpgradeMode.Manual,
    },
    virtualMachineProfile: {
        networkProfile: {
            networkInterfaceConfigurations: [{
                enableIPForwarding: true,
                ipConfigurations: [{
                    name: "{vmss-name}",
                    subnet: {
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    },
                }],
                name: "{vmss-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerNamePrefix: "{vmss-name}",
        },
        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",
                },
            },
        },
    },
    vmScaleSetName: "{vmss-name}",
});
resources:
  virtualMachineScaleSet:
    type: azure-native:compute:VirtualMachineScaleSet
    properties:
      location: westus
      overprovision: true
      resourceGroupName: myResourceGroup
      sku:
        capacity: 3
        name: Standard_D1_v2
        tier: Standard
      upgradePolicy:
        mode: Manual
      virtualMachineProfile:
        networkProfile:
          networkInterfaceConfigurations:
            - enableIPForwarding: true
              ipConfigurations:
                - name: '{vmss-name}'
                  subnet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}
              name: '{vmss-name}'
              primary: true
        osProfile:
          adminPassword: '{your-password}'
          adminUsername: '{your-username}'
          computerNamePrefix: '{vmss-name}'
        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
      vmScaleSetName: '{vmss-name}'

Create a scale set from a generalized shared image.

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

return await Deployment.RunAsync(() => 
{
    var virtualMachineScaleSet = new AzureNative.Compute.VirtualMachineScaleSet("virtualMachineScaleSet", new()
    {
        Location = "westus",
        Overprovision = true,
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.SkuArgs
        {
            Capacity = 3,
            Name = "Standard_D1_v2",
            Tier = "Standard",
        },
        UpgradePolicy = new AzureNative.Compute.Inputs.UpgradePolicyArgs
        {
            Mode = AzureNative.Compute.UpgradeMode.Manual,
        },
        VirtualMachineProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetVMProfileArgs
        {
            NetworkProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkProfileArgs
            {
                NetworkInterfaceConfigurations = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkConfigurationArgs
                    {
                        EnableIPForwarding = true,
                        IpConfigurations = new[]
                        {
                            new AzureNative.Compute.Inputs.VirtualMachineScaleSetIPConfigurationArgs
                            {
                                Name = "{vmss-name}",
                                Subnet = new AzureNative.Compute.Inputs.ApiEntityReferenceArgs
                                {
                                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                                },
                            },
                        },
                        Name = "{vmss-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerNamePrefix = "{vmss-name}",
            },
            StorageProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetStorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage",
                },
                OsDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                },
            },
        },
        VmScaleSetName = "{vmss-name}",
    });

});

Coming soon!

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachineScaleSet;
import com.pulumi.azurenative.compute.VirtualMachineScaleSetArgs;
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 virtualMachineScaleSet = new VirtualMachineScaleSet("virtualMachineScaleSet", VirtualMachineScaleSetArgs.builder()        
            .location("westus")
            .overprovision(true)
            .resourceGroupName("myResourceGroup")
            .sku(Map.ofEntries(
                Map.entry("capacity", 3),
                Map.entry("name", "Standard_D1_v2"),
                Map.entry("tier", "Standard")
            ))
            .upgradePolicy(Map.of("mode", "Manual"))
            .virtualMachineProfile(Map.ofEntries(
                Map.entry("networkProfile", Map.of("networkInterfaceConfigurations", Map.ofEntries(
                    Map.entry("enableIPForwarding", true),
                    Map.entry("ipConfigurations", Map.ofEntries(
                        Map.entry("name", "{vmss-name}"),
                        Map.entry("subnet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}"))
                    )),
                    Map.entry("name", "{vmss-name}"),
                    Map.entry("primary", true)
                ))),
                Map.entry("osProfile", Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerNamePrefix", "{vmss-name}")
                )),
                Map.entry("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"))
                    ))
                ))
            ))
            .vmScaleSetName("{vmss-name}")
            .build());

    }
}
import pulumi
import pulumi_azure_native as azure_native

virtual_machine_scale_set = azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet",
    location="westus",
    overprovision=True,
    resource_group_name="myResourceGroup",
    sku=azure_native.compute.SkuArgs(
        capacity=3,
        name="Standard_D1_v2",
        tier="Standard",
    ),
    upgrade_policy=azure_native.compute.UpgradePolicyArgs(
        mode=azure_native.compute.UpgradeMode.MANUAL,
    ),
    virtual_machine_profile=azure_native.compute.VirtualMachineScaleSetVMProfileResponseArgs(
        network_profile={
            "networkInterfaceConfigurations": [{
                "enableIPForwarding": True,
                "ipConfigurations": [{
                    "name": "{vmss-name}",
                    "subnet": azure_native.compute.ApiEntityReferenceArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    ),
                }],
                "name": "{vmss-name}",
                "primary": True,
            }],
        },
        os_profile=azure_native.compute.VirtualMachineScaleSetOSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name_prefix="{vmss-name}",
        ),
        storage_profile={
            "imageReference": azure_native.compute.ImageReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage",
            ),
            "osDisk": {
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.VirtualMachineScaleSetManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
            },
        },
    ),
    vm_scale_set_name="{vmss-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const virtualMachineScaleSet = new azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet", {
    location: "westus",
    overprovision: true,
    resourceGroupName: "myResourceGroup",
    sku: {
        capacity: 3,
        name: "Standard_D1_v2",
        tier: "Standard",
    },
    upgradePolicy: {
        mode: azure_native.compute.UpgradeMode.Manual,
    },
    virtualMachineProfile: {
        networkProfile: {
            networkInterfaceConfigurations: [{
                enableIPForwarding: true,
                ipConfigurations: [{
                    name: "{vmss-name}",
                    subnet: {
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    },
                }],
                name: "{vmss-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerNamePrefix: "{vmss-name}",
        },
        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",
                },
            },
        },
    },
    vmScaleSetName: "{vmss-name}",
});
resources:
  virtualMachineScaleSet:
    type: azure-native:compute:VirtualMachineScaleSet
    properties:
      location: westus
      overprovision: true
      resourceGroupName: myResourceGroup
      sku:
        capacity: 3
        name: Standard_D1_v2
        tier: Standard
      upgradePolicy:
        mode: Manual
      virtualMachineProfile:
        networkProfile:
          networkInterfaceConfigurations:
            - enableIPForwarding: true
              ipConfigurations:
                - name: '{vmss-name}'
                  subnet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}
              name: '{vmss-name}'
              primary: true
        osProfile:
          adminPassword: '{your-password}'
          adminUsername: '{your-username}'
          computerNamePrefix: '{vmss-name}'
        storageProfile:
          imageReference:
            id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage
          osDisk:
            caching: ReadWrite
            createOption: FromImage
            managedDisk:
              storageAccountType: Standard_LRS
      vmScaleSetName: '{vmss-name}'

Create a scale set from a specialized shared image.

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

return await Deployment.RunAsync(() => 
{
    var virtualMachineScaleSet = new AzureNative.Compute.VirtualMachineScaleSet("virtualMachineScaleSet", new()
    {
        Location = "westus",
        Overprovision = true,
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.SkuArgs
        {
            Capacity = 3,
            Name = "Standard_D1_v2",
            Tier = "Standard",
        },
        UpgradePolicy = new AzureNative.Compute.Inputs.UpgradePolicyArgs
        {
            Mode = AzureNative.Compute.UpgradeMode.Manual,
        },
        VirtualMachineProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetVMProfileArgs
        {
            NetworkProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkProfileArgs
            {
                NetworkInterfaceConfigurations = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkConfigurationArgs
                    {
                        EnableIPForwarding = true,
                        IpConfigurations = new[]
                        {
                            new AzureNative.Compute.Inputs.VirtualMachineScaleSetIPConfigurationArgs
                            {
                                Name = "{vmss-name}",
                                Subnet = new AzureNative.Compute.Inputs.ApiEntityReferenceArgs
                                {
                                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                                },
                            },
                        },
                        Name = "{vmss-name}",
                        Primary = true,
                    },
                },
            },
            StorageProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetStorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage",
                },
                OsDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                },
            },
        },
        VmScaleSetName = "{vmss-name}",
    });

});

Coming soon!

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachineScaleSet;
import com.pulumi.azurenative.compute.VirtualMachineScaleSetArgs;
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 virtualMachineScaleSet = new VirtualMachineScaleSet("virtualMachineScaleSet", VirtualMachineScaleSetArgs.builder()        
            .location("westus")
            .overprovision(true)
            .resourceGroupName("myResourceGroup")
            .sku(Map.ofEntries(
                Map.entry("capacity", 3),
                Map.entry("name", "Standard_D1_v2"),
                Map.entry("tier", "Standard")
            ))
            .upgradePolicy(Map.of("mode", "Manual"))
            .virtualMachineProfile(Map.ofEntries(
                Map.entry("networkProfile", Map.of("networkInterfaceConfigurations", Map.ofEntries(
                    Map.entry("enableIPForwarding", true),
                    Map.entry("ipConfigurations", Map.ofEntries(
                        Map.entry("name", "{vmss-name}"),
                        Map.entry("subnet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}"))
                    )),
                    Map.entry("name", "{vmss-name}"),
                    Map.entry("primary", true)
                ))),
                Map.entry("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"))
                    ))
                ))
            ))
            .vmScaleSetName("{vmss-name}")
            .build());

    }
}
import pulumi
import pulumi_azure_native as azure_native

virtual_machine_scale_set = azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet",
    location="westus",
    overprovision=True,
    resource_group_name="myResourceGroup",
    sku=azure_native.compute.SkuArgs(
        capacity=3,
        name="Standard_D1_v2",
        tier="Standard",
    ),
    upgrade_policy=azure_native.compute.UpgradePolicyArgs(
        mode=azure_native.compute.UpgradeMode.MANUAL,
    ),
    virtual_machine_profile=azure_native.compute.VirtualMachineScaleSetVMProfileResponseArgs(
        network_profile={
            "networkInterfaceConfigurations": [{
                "enableIPForwarding": True,
                "ipConfigurations": [{
                    "name": "{vmss-name}",
                    "subnet": azure_native.compute.ApiEntityReferenceArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    ),
                }],
                "name": "{vmss-name}",
                "primary": True,
            }],
        },
        storage_profile={
            "imageReference": azure_native.compute.ImageReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage",
            ),
            "osDisk": {
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.VirtualMachineScaleSetManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
            },
        },
    ),
    vm_scale_set_name="{vmss-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const virtualMachineScaleSet = new azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet", {
    location: "westus",
    overprovision: true,
    resourceGroupName: "myResourceGroup",
    sku: {
        capacity: 3,
        name: "Standard_D1_v2",
        tier: "Standard",
    },
    upgradePolicy: {
        mode: azure_native.compute.UpgradeMode.Manual,
    },
    virtualMachineProfile: {
        networkProfile: {
            networkInterfaceConfigurations: [{
                enableIPForwarding: true,
                ipConfigurations: [{
                    name: "{vmss-name}",
                    subnet: {
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    },
                }],
                name: "{vmss-name}",
                primary: true,
            }],
        },
        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",
                },
            },
        },
    },
    vmScaleSetName: "{vmss-name}",
});
resources:
  virtualMachineScaleSet:
    type: azure-native:compute:VirtualMachineScaleSet
    properties:
      location: westus
      overprovision: true
      resourceGroupName: myResourceGroup
      sku:
        capacity: 3
        name: Standard_D1_v2
        tier: Standard
      upgradePolicy:
        mode: Manual
      virtualMachineProfile:
        networkProfile:
          networkInterfaceConfigurations:
            - enableIPForwarding: true
              ipConfigurations:
                - name: '{vmss-name}'
                  subnet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}
              name: '{vmss-name}'
              primary: true
        storageProfile:
          imageReference:
            id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage
          osDisk:
            caching: ReadWrite
            createOption: FromImage
            managedDisk:
              storageAccountType: Standard_LRS
      vmScaleSetName: '{vmss-name}'

Create a scale set with DiskEncryptionSet resource in os disk and data disk.

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

return await Deployment.RunAsync(() => 
{
    var virtualMachineScaleSet = new AzureNative.Compute.VirtualMachineScaleSet("virtualMachineScaleSet", new()
    {
        Location = "westus",
        Overprovision = true,
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.SkuArgs
        {
            Capacity = 3,
            Name = "Standard_DS1_v2",
            Tier = "Standard",
        },
        UpgradePolicy = new AzureNative.Compute.Inputs.UpgradePolicyArgs
        {
            Mode = AzureNative.Compute.UpgradeMode.Manual,
        },
        VirtualMachineProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetVMProfileArgs
        {
            NetworkProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkProfileArgs
            {
                NetworkInterfaceConfigurations = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkConfigurationArgs
                    {
                        EnableIPForwarding = true,
                        IpConfigurations = new[]
                        {
                            new AzureNative.Compute.Inputs.VirtualMachineScaleSetIPConfigurationArgs
                            {
                                Name = "{vmss-name}",
                                Subnet = new AzureNative.Compute.Inputs.ApiEntityReferenceArgs
                                {
                                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                                },
                            },
                        },
                        Name = "{vmss-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerNamePrefix = "{vmss-name}",
            },
            StorageProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetStorageProfileArgs
            {
                DataDisks = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetDataDiskArgs
                    {
                        Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                        CreateOption = "Empty",
                        DiskSizeGB = 1023,
                        Lun = 0,
                        ManagedDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetManagedDiskParametersArgs
                        {
                            DiskEncryptionSet = new AzureNative.Compute.Inputs.DiskEncryptionSetParametersArgs
                            {
                                Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-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.VirtualMachineScaleSetOSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetManagedDiskParametersArgs
                    {
                        DiskEncryptionSet = new AzureNative.Compute.Inputs.DiskEncryptionSetParametersArgs
                        {
                            Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                        },
                        StorageAccountType = "Standard_LRS",
                    },
                },
            },
        },
        VmScaleSetName = "{vmss-name}",
    });

});

Coming soon!

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachineScaleSet;
import com.pulumi.azurenative.compute.VirtualMachineScaleSetArgs;
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 virtualMachineScaleSet = new VirtualMachineScaleSet("virtualMachineScaleSet", VirtualMachineScaleSetArgs.builder()        
            .location("westus")
            .overprovision(true)
            .resourceGroupName("myResourceGroup")
            .sku(Map.ofEntries(
                Map.entry("capacity", 3),
                Map.entry("name", "Standard_DS1_v2"),
                Map.entry("tier", "Standard")
            ))
            .upgradePolicy(Map.of("mode", "Manual"))
            .virtualMachineProfile(Map.ofEntries(
                Map.entry("networkProfile", Map.of("networkInterfaceConfigurations", Map.ofEntries(
                    Map.entry("enableIPForwarding", true),
                    Map.entry("ipConfigurations", Map.ofEntries(
                        Map.entry("name", "{vmss-name}"),
                        Map.entry("subnet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}"))
                    )),
                    Map.entry("name", "{vmss-name}"),
                    Map.entry("primary", true)
                ))),
                Map.entry("osProfile", Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerNamePrefix", "{vmss-name}")
                )),
                Map.entry("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.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")
                        ))
                    ))
                ))
            ))
            .vmScaleSetName("{vmss-name}")
            .build());

    }
}
import pulumi
import pulumi_azure_native as azure_native

virtual_machine_scale_set = azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet",
    location="westus",
    overprovision=True,
    resource_group_name="myResourceGroup",
    sku=azure_native.compute.SkuArgs(
        capacity=3,
        name="Standard_DS1_v2",
        tier="Standard",
    ),
    upgrade_policy=azure_native.compute.UpgradePolicyArgs(
        mode=azure_native.compute.UpgradeMode.MANUAL,
    ),
    virtual_machine_profile=azure_native.compute.VirtualMachineScaleSetVMProfileResponseArgs(
        network_profile={
            "networkInterfaceConfigurations": [{
                "enableIPForwarding": True,
                "ipConfigurations": [{
                    "name": "{vmss-name}",
                    "subnet": azure_native.compute.ApiEntityReferenceArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    ),
                }],
                "name": "{vmss-name}",
                "primary": True,
            }],
        },
        os_profile=azure_native.compute.VirtualMachineScaleSetOSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name_prefix="{vmss-name}",
        ),
        storage_profile={
            "dataDisks": [{
                "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",
                },
            }],
            "imageReference": azure_native.compute.ImageReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}",
            ),
            "osDisk": {
                "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",
                },
            },
        },
    ),
    vm_scale_set_name="{vmss-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const virtualMachineScaleSet = new azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet", {
    location: "westus",
    overprovision: true,
    resourceGroupName: "myResourceGroup",
    sku: {
        capacity: 3,
        name: "Standard_DS1_v2",
        tier: "Standard",
    },
    upgradePolicy: {
        mode: azure_native.compute.UpgradeMode.Manual,
    },
    virtualMachineProfile: {
        networkProfile: {
            networkInterfaceConfigurations: [{
                enableIPForwarding: true,
                ipConfigurations: [{
                    name: "{vmss-name}",
                    subnet: {
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    },
                }],
                name: "{vmss-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerNamePrefix: "{vmss-name}",
        },
        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",
                },
            }],
            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",
                },
            },
        },
    },
    vmScaleSetName: "{vmss-name}",
});
resources:
  virtualMachineScaleSet:
    type: azure-native:compute:VirtualMachineScaleSet
    properties:
      location: westus
      overprovision: true
      resourceGroupName: myResourceGroup
      sku:
        capacity: 3
        name: Standard_DS1_v2
        tier: Standard
      upgradePolicy:
        mode: Manual
      virtualMachineProfile:
        networkProfile:
          networkInterfaceConfigurations:
            - enableIPForwarding: true
              ipConfigurations:
                - name: '{vmss-name}'
                  subnet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}
              name: '{vmss-name}'
              primary: true
        osProfile:
          adminPassword: '{your-password}'
          adminUsername: '{your-username}'
          computerNamePrefix: '{vmss-name}'
        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
          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
      vmScaleSetName: '{vmss-name}'

Create a scale set with Fpga Network Interfaces.

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

return await Deployment.RunAsync(() => 
{
    var virtualMachineScaleSet = new AzureNative.Compute.VirtualMachineScaleSet("virtualMachineScaleSet", new()
    {
        Location = "westus",
        Overprovision = true,
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.SkuArgs
        {
            Capacity = 3,
            Name = "Standard_D1_v2",
            Tier = "Standard",
        },
        UpgradePolicy = new AzureNative.Compute.Inputs.UpgradePolicyArgs
        {
            Mode = AzureNative.Compute.UpgradeMode.Manual,
        },
        VirtualMachineProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetVMProfileArgs
        {
            NetworkProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkProfileArgs
            {
                NetworkInterfaceConfigurations = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkConfigurationArgs
                    {
                        EnableIPForwarding = true,
                        IpConfigurations = new[]
                        {
                            new AzureNative.Compute.Inputs.VirtualMachineScaleSetIPConfigurationArgs
                            {
                                Name = "{vmss-name}",
                                Subnet = new AzureNative.Compute.Inputs.ApiEntityReferenceArgs
                                {
                                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                                },
                            },
                        },
                        Name = "{vmss-name}",
                        Primary = true,
                    },
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkConfigurationArgs
                    {
                        EnableAcceleratedNetworking = false,
                        EnableFpga = true,
                        EnableIPForwarding = false,
                        IpConfigurations = new[]
                        {
                            new AzureNative.Compute.Inputs.VirtualMachineScaleSetIPConfigurationArgs
                            {
                                Name = "{fpgaNic-Name}",
                                Primary = true,
                                PrivateIPAddressVersion = "IPv4",
                                Subnet = new AzureNative.Compute.Inputs.ApiEntityReferenceArgs
                                {
                                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-fpga-subnet-name}",
                                },
                            },
                        },
                        Name = "{fpgaNic-Name}",
                        Primary = false,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerNamePrefix = "{vmss-name}",
            },
            StorageProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetStorageProfileArgs
            {
                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.VirtualMachineScaleSetOSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                },
            },
        },
        VmScaleSetName = "{vmss-name}",
    });

});

Coming soon!

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachineScaleSet;
import com.pulumi.azurenative.compute.VirtualMachineScaleSetArgs;
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 virtualMachineScaleSet = new VirtualMachineScaleSet("virtualMachineScaleSet", VirtualMachineScaleSetArgs.builder()        
            .location("westus")
            .overprovision(true)
            .resourceGroupName("myResourceGroup")
            .sku(Map.ofEntries(
                Map.entry("capacity", 3),
                Map.entry("name", "Standard_D1_v2"),
                Map.entry("tier", "Standard")
            ))
            .upgradePolicy(Map.of("mode", "Manual"))
            .virtualMachineProfile(Map.ofEntries(
                Map.entry("networkProfile", Map.of("networkInterfaceConfigurations",                 
                    Map.ofEntries(
                        Map.entry("enableIPForwarding", true),
                        Map.entry("ipConfigurations", Map.ofEntries(
                            Map.entry("name", "{vmss-name}"),
                            Map.entry("subnet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}"))
                        )),
                        Map.entry("name", "{vmss-name}"),
                        Map.entry("primary", true)
                    ),
                    Map.ofEntries(
                        Map.entry("enableAcceleratedNetworking", false),
                        Map.entry("enableFpga", true),
                        Map.entry("enableIPForwarding", false),
                        Map.entry("ipConfigurations", Map.ofEntries(
                            Map.entry("name", "{fpgaNic-Name}"),
                            Map.entry("primary", true),
                            Map.entry("privateIPAddressVersion", "IPv4"),
                            Map.entry("subnet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-fpga-subnet-name}"))
                        )),
                        Map.entry("name", "{fpgaNic-Name}"),
                        Map.entry("primary", false)
                    ))),
                Map.entry("osProfile", Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerNamePrefix", "{vmss-name}")
                )),
                Map.entry("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"))
                    ))
                ))
            ))
            .vmScaleSetName("{vmss-name}")
            .build());

    }
}
import pulumi
import pulumi_azure_native as azure_native

virtual_machine_scale_set = azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet",
    location="westus",
    overprovision=True,
    resource_group_name="myResourceGroup",
    sku=azure_native.compute.SkuArgs(
        capacity=3,
        name="Standard_D1_v2",
        tier="Standard",
    ),
    upgrade_policy=azure_native.compute.UpgradePolicyArgs(
        mode=azure_native.compute.UpgradeMode.MANUAL,
    ),
    virtual_machine_profile=azure_native.compute.VirtualMachineScaleSetVMProfileResponseArgs(
        network_profile={
            "networkInterfaceConfigurations": [
                {
                    "enableIPForwarding": True,
                    "ipConfigurations": [{
                        "name": "{vmss-name}",
                        "subnet": azure_native.compute.ApiEntityReferenceArgs(
                            id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                        ),
                    }],
                    "name": "{vmss-name}",
                    "primary": True,
                },
                {
                    "enableAcceleratedNetworking": False,
                    "enableFpga": True,
                    "enableIPForwarding": False,
                    "ipConfigurations": [{
                        "name": "{fpgaNic-Name}",
                        "primary": True,
                        "privateIPAddressVersion": "IPv4",
                        "subnet": azure_native.compute.ApiEntityReferenceArgs(
                            id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-fpga-subnet-name}",
                        ),
                    }],
                    "name": "{fpgaNic-Name}",
                    "primary": False,
                },
            ],
        },
        os_profile=azure_native.compute.VirtualMachineScaleSetOSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name_prefix="{vmss-name}",
        ),
        storage_profile={
            "imageReference": azure_native.compute.ImageReferenceArgs(
                id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}",
            ),
            "osDisk": {
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.VirtualMachineScaleSetManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
            },
        },
    ),
    vm_scale_set_name="{vmss-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const virtualMachineScaleSet = new azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet", {
    location: "westus",
    overprovision: true,
    resourceGroupName: "myResourceGroup",
    sku: {
        capacity: 3,
        name: "Standard_D1_v2",
        tier: "Standard",
    },
    upgradePolicy: {
        mode: azure_native.compute.UpgradeMode.Manual,
    },
    virtualMachineProfile: {
        networkProfile: {
            networkInterfaceConfigurations: [
                {
                    enableIPForwarding: true,
                    ipConfigurations: [{
                        name: "{vmss-name}",
                        subnet: {
                            id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                        },
                    }],
                    name: "{vmss-name}",
                    primary: true,
                },
                {
                    enableAcceleratedNetworking: false,
                    enableFpga: true,
                    enableIPForwarding: false,
                    ipConfigurations: [{
                        name: "{fpgaNic-Name}",
                        primary: true,
                        privateIPAddressVersion: "IPv4",
                        subnet: {
                            id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-fpga-subnet-name}",
                        },
                    }],
                    name: "{fpgaNic-Name}",
                    primary: false,
                },
            ],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerNamePrefix: "{vmss-name}",
        },
        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",
                },
            },
        },
    },
    vmScaleSetName: "{vmss-name}",
});
resources:
  virtualMachineScaleSet:
    type: azure-native:compute:VirtualMachineScaleSet
    properties:
      location: westus
      overprovision: true
      resourceGroupName: myResourceGroup
      sku:
        capacity: 3
        name: Standard_D1_v2
        tier: Standard
      upgradePolicy:
        mode: Manual
      virtualMachineProfile:
        networkProfile:
          networkInterfaceConfigurations:
            - enableIPForwarding: true
              ipConfigurations:
                - name: '{vmss-name}'
                  subnet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}
              name: '{vmss-name}'
              primary: true
            - enableAcceleratedNetworking: false
              enableFpga: true
              enableIPForwarding: false
              ipConfigurations:
                - name: '{fpgaNic-Name}'
                  primary: true
                  privateIPAddressVersion: IPv4
                  subnet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-fpga-subnet-name}
              name: '{fpgaNic-Name}'
              primary: false
        osProfile:
          adminPassword: '{your-password}'
          adminUsername: '{your-username}'
          computerNamePrefix: '{vmss-name}'
        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
      vmScaleSetName: '{vmss-name}'

Create a scale set with Host Encryption using encryptionAtHost property.

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

return await Deployment.RunAsync(() => 
{
    var virtualMachineScaleSet = new AzureNative.Compute.VirtualMachineScaleSet("virtualMachineScaleSet", new()
    {
        Location = "westus",
        Overprovision = true,
        Plan = new AzureNative.Compute.Inputs.PlanArgs
        {
            Name = "windows2016",
            Product = "windows-data-science-vm",
            Publisher = "microsoft-ads",
        },
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.SkuArgs
        {
            Capacity = 3,
            Name = "Standard_DS1_v2",
            Tier = "Standard",
        },
        UpgradePolicy = new AzureNative.Compute.Inputs.UpgradePolicyArgs
        {
            Mode = AzureNative.Compute.UpgradeMode.Manual,
        },
        VirtualMachineProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetVMProfileArgs
        {
            NetworkProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkProfileArgs
            {
                NetworkInterfaceConfigurations = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkConfigurationArgs
                    {
                        EnableIPForwarding = true,
                        IpConfigurations = new[]
                        {
                            new AzureNative.Compute.Inputs.VirtualMachineScaleSetIPConfigurationArgs
                            {
                                Name = "{vmss-name}",
                                Subnet = new AzureNative.Compute.Inputs.ApiEntityReferenceArgs
                                {
                                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                                },
                            },
                        },
                        Name = "{vmss-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerNamePrefix = "{vmss-name}",
            },
            SecurityProfile = new AzureNative.Compute.Inputs.SecurityProfileArgs
            {
                EncryptionAtHost = true,
            },
            StorageProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetStorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "windows-data-science-vm",
                    Publisher = "microsoft-ads",
                    Sku = "windows2016",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadOnly,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                },
            },
        },
        VmScaleSetName = "{vmss-name}",
    });

});

Coming soon!

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachineScaleSet;
import com.pulumi.azurenative.compute.VirtualMachineScaleSetArgs;
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 virtualMachineScaleSet = new VirtualMachineScaleSet("virtualMachineScaleSet", VirtualMachineScaleSetArgs.builder()        
            .location("westus")
            .overprovision(true)
            .plan(Map.ofEntries(
                Map.entry("name", "windows2016"),
                Map.entry("product", "windows-data-science-vm"),
                Map.entry("publisher", "microsoft-ads")
            ))
            .resourceGroupName("myResourceGroup")
            .sku(Map.ofEntries(
                Map.entry("capacity", 3),
                Map.entry("name", "Standard_DS1_v2"),
                Map.entry("tier", "Standard")
            ))
            .upgradePolicy(Map.of("mode", "Manual"))
            .virtualMachineProfile(Map.ofEntries(
                Map.entry("networkProfile", Map.of("networkInterfaceConfigurations", Map.ofEntries(
                    Map.entry("enableIPForwarding", true),
                    Map.entry("ipConfigurations", Map.ofEntries(
                        Map.entry("name", "{vmss-name}"),
                        Map.entry("subnet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}"))
                    )),
                    Map.entry("name", "{vmss-name}"),
                    Map.entry("primary", true)
                ))),
                Map.entry("osProfile", Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerNamePrefix", "{vmss-name}")
                )),
                Map.entry("securityProfile", Map.of("encryptionAtHost", true)),
                Map.entry("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"))
                    ))
                ))
            ))
            .vmScaleSetName("{vmss-name}")
            .build());

    }
}
import pulumi
import pulumi_azure_native as azure_native

virtual_machine_scale_set = azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet",
    location="westus",
    overprovision=True,
    plan=azure_native.compute.PlanArgs(
        name="windows2016",
        product="windows-data-science-vm",
        publisher="microsoft-ads",
    ),
    resource_group_name="myResourceGroup",
    sku=azure_native.compute.SkuArgs(
        capacity=3,
        name="Standard_DS1_v2",
        tier="Standard",
    ),
    upgrade_policy=azure_native.compute.UpgradePolicyArgs(
        mode=azure_native.compute.UpgradeMode.MANUAL,
    ),
    virtual_machine_profile=azure_native.compute.VirtualMachineScaleSetVMProfileResponseArgs(
        network_profile={
            "networkInterfaceConfigurations": [{
                "enableIPForwarding": True,
                "ipConfigurations": [{
                    "name": "{vmss-name}",
                    "subnet": azure_native.compute.ApiEntityReferenceArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    ),
                }],
                "name": "{vmss-name}",
                "primary": True,
            }],
        },
        os_profile=azure_native.compute.VirtualMachineScaleSetOSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name_prefix="{vmss-name}",
        ),
        security_profile=azure_native.compute.SecurityProfileArgs(
            encryption_at_host=True,
        ),
        storage_profile={
            "imageReference": azure_native.compute.ImageReferenceArgs(
                offer="windows-data-science-vm",
                publisher="microsoft-ads",
                sku="windows2016",
                version="latest",
            ),
            "osDisk": {
                "caching": azure_native.compute.CachingTypes.READ_ONLY,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.VirtualMachineScaleSetManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
            },
        },
    ),
    vm_scale_set_name="{vmss-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const virtualMachineScaleSet = new azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet", {
    location: "westus",
    overprovision: true,
    plan: {
        name: "windows2016",
        product: "windows-data-science-vm",
        publisher: "microsoft-ads",
    },
    resourceGroupName: "myResourceGroup",
    sku: {
        capacity: 3,
        name: "Standard_DS1_v2",
        tier: "Standard",
    },
    upgradePolicy: {
        mode: azure_native.compute.UpgradeMode.Manual,
    },
    virtualMachineProfile: {
        networkProfile: {
            networkInterfaceConfigurations: [{
                enableIPForwarding: true,
                ipConfigurations: [{
                    name: "{vmss-name}",
                    subnet: {
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    },
                }],
                name: "{vmss-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerNamePrefix: "{vmss-name}",
        },
        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",
                },
            },
        },
    },
    vmScaleSetName: "{vmss-name}",
});
resources:
  virtualMachineScaleSet:
    type: azure-native:compute:VirtualMachineScaleSet
    properties:
      location: westus
      overprovision: true
      plan:
        name: windows2016
        product: windows-data-science-vm
        publisher: microsoft-ads
      resourceGroupName: myResourceGroup
      sku:
        capacity: 3
        name: Standard_DS1_v2
        tier: Standard
      upgradePolicy:
        mode: Manual
      virtualMachineProfile:
        networkProfile:
          networkInterfaceConfigurations:
            - enableIPForwarding: true
              ipConfigurations:
                - name: '{vmss-name}'
                  subnet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}
              name: '{vmss-name}'
              primary: true
        osProfile:
          adminPassword: '{your-password}'
          adminUsername: '{your-username}'
          computerNamePrefix: '{vmss-name}'
        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
      vmScaleSetName: '{vmss-name}'

Create a scale set with Uefi Settings of secureBoot and vTPM.

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

return await Deployment.RunAsync(() => 
{
    var virtualMachineScaleSet = new AzureNative.Compute.VirtualMachineScaleSet("virtualMachineScaleSet", new()
    {
        Location = "westus",
        Overprovision = true,
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.SkuArgs
        {
            Capacity = 3,
            Name = "Standard_D2s_v3",
            Tier = "Standard",
        },
        UpgradePolicy = new AzureNative.Compute.Inputs.UpgradePolicyArgs
        {
            Mode = AzureNative.Compute.UpgradeMode.Manual,
        },
        VirtualMachineProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetVMProfileArgs
        {
            NetworkProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkProfileArgs
            {
                NetworkInterfaceConfigurations = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkConfigurationArgs
                    {
                        EnableIPForwarding = true,
                        IpConfigurations = new[]
                        {
                            new AzureNative.Compute.Inputs.VirtualMachineScaleSetIPConfigurationArgs
                            {
                                Name = "{vmss-name}",
                                Subnet = new AzureNative.Compute.Inputs.ApiEntityReferenceArgs
                                {
                                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                                },
                            },
                        },
                        Name = "{vmss-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerNamePrefix = "{vmss-name}",
            },
            SecurityProfile = new AzureNative.Compute.Inputs.SecurityProfileArgs
            {
                SecurityType = "TrustedLaunch",
                UefiSettings = new AzureNative.Compute.Inputs.UefiSettingsArgs
                {
                    SecureBootEnabled = true,
                    VTpmEnabled = true,
                },
            },
            StorageProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetStorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "windowsserver-gen2preview-preview",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "windows10-tvm",
                    Version = "18363.592.2001092016",
                },
                OsDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadOnly,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetManagedDiskParametersArgs
                    {
                        StorageAccountType = "StandardSSD_LRS",
                    },
                },
            },
        },
        VmScaleSetName = "{vmss-name}",
    });

});

Coming soon!

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachineScaleSet;
import com.pulumi.azurenative.compute.VirtualMachineScaleSetArgs;
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 virtualMachineScaleSet = new VirtualMachineScaleSet("virtualMachineScaleSet", VirtualMachineScaleSetArgs.builder()        
            .location("westus")
            .overprovision(true)
            .resourceGroupName("myResourceGroup")
            .sku(Map.ofEntries(
                Map.entry("capacity", 3),
                Map.entry("name", "Standard_D2s_v3"),
                Map.entry("tier", "Standard")
            ))
            .upgradePolicy(Map.of("mode", "Manual"))
            .virtualMachineProfile(Map.ofEntries(
                Map.entry("networkProfile", Map.of("networkInterfaceConfigurations", Map.ofEntries(
                    Map.entry("enableIPForwarding", true),
                    Map.entry("ipConfigurations", Map.ofEntries(
                        Map.entry("name", "{vmss-name}"),
                        Map.entry("subnet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}"))
                    )),
                    Map.entry("name", "{vmss-name}"),
                    Map.entry("primary", true)
                ))),
                Map.entry("osProfile", Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerNamePrefix", "{vmss-name}")
                )),
                Map.entry("securityProfile", Map.ofEntries(
                    Map.entry("securityType", "TrustedLaunch"),
                    Map.entry("uefiSettings", Map.ofEntries(
                        Map.entry("secureBootEnabled", true),
                        Map.entry("vTpmEnabled", true)
                    ))
                )),
                Map.entry("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"))
                    ))
                ))
            ))
            .vmScaleSetName("{vmss-name}")
            .build());

    }
}
import pulumi
import pulumi_azure_native as azure_native

virtual_machine_scale_set = azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet",
    location="westus",
    overprovision=True,
    resource_group_name="myResourceGroup",
    sku=azure_native.compute.SkuArgs(
        capacity=3,
        name="Standard_D2s_v3",
        tier="Standard",
    ),
    upgrade_policy=azure_native.compute.UpgradePolicyArgs(
        mode=azure_native.compute.UpgradeMode.MANUAL,
    ),
    virtual_machine_profile=azure_native.compute.VirtualMachineScaleSetVMProfileResponseArgs(
        network_profile={
            "networkInterfaceConfigurations": [{
                "enableIPForwarding": True,
                "ipConfigurations": [{
                    "name": "{vmss-name}",
                    "subnet": azure_native.compute.ApiEntityReferenceArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    ),
                }],
                "name": "{vmss-name}",
                "primary": True,
            }],
        },
        os_profile=azure_native.compute.VirtualMachineScaleSetOSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name_prefix="{vmss-name}",
        ),
        security_profile={
            "securityType": "TrustedLaunch",
            "uefiSettings": azure_native.compute.UefiSettingsArgs(
                secure_boot_enabled=True,
                v_tpm_enabled=True,
            ),
        },
        storage_profile={
            "imageReference": azure_native.compute.ImageReferenceArgs(
                offer="windowsserver-gen2preview-preview",
                publisher="MicrosoftWindowsServer",
                sku="windows10-tvm",
                version="18363.592.2001092016",
            ),
            "osDisk": {
                "caching": azure_native.compute.CachingTypes.READ_ONLY,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.VirtualMachineScaleSetManagedDiskParametersArgs(
                    storage_account_type="StandardSSD_LRS",
                ),
            },
        },
    ),
    vm_scale_set_name="{vmss-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const virtualMachineScaleSet = new azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet", {
    location: "westus",
    overprovision: true,
    resourceGroupName: "myResourceGroup",
    sku: {
        capacity: 3,
        name: "Standard_D2s_v3",
        tier: "Standard",
    },
    upgradePolicy: {
        mode: azure_native.compute.UpgradeMode.Manual,
    },
    virtualMachineProfile: {
        networkProfile: {
            networkInterfaceConfigurations: [{
                enableIPForwarding: true,
                ipConfigurations: [{
                    name: "{vmss-name}",
                    subnet: {
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    },
                }],
                name: "{vmss-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerNamePrefix: "{vmss-name}",
        },
        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",
                },
            },
        },
    },
    vmScaleSetName: "{vmss-name}",
});
resources:
  virtualMachineScaleSet:
    type: azure-native:compute:VirtualMachineScaleSet
    properties:
      location: westus
      overprovision: true
      resourceGroupName: myResourceGroup
      sku:
        capacity: 3
        name: Standard_D2s_v3
        tier: Standard
      upgradePolicy:
        mode: Manual
      virtualMachineProfile:
        networkProfile:
          networkInterfaceConfigurations:
            - enableIPForwarding: true
              ipConfigurations:
                - name: '{vmss-name}'
                  subnet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}
              name: '{vmss-name}'
              primary: true
        osProfile:
          adminPassword: '{your-password}'
          adminUsername: '{your-username}'
          computerNamePrefix: '{vmss-name}'
        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
      vmScaleSetName: '{vmss-name}'

Create a scale set with a marketplace image plan.

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

return await Deployment.RunAsync(() => 
{
    var virtualMachineScaleSet = new AzureNative.Compute.VirtualMachineScaleSet("virtualMachineScaleSet", new()
    {
        Location = "westus",
        Overprovision = true,
        Plan = new AzureNative.Compute.Inputs.PlanArgs
        {
            Name = "windows2016",
            Product = "windows-data-science-vm",
            Publisher = "microsoft-ads",
        },
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.SkuArgs
        {
            Capacity = 3,
            Name = "Standard_D1_v2",
            Tier = "Standard",
        },
        UpgradePolicy = new AzureNative.Compute.Inputs.UpgradePolicyArgs
        {
            Mode = AzureNative.Compute.UpgradeMode.Manual,
        },
        VirtualMachineProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetVMProfileArgs
        {
            NetworkProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkProfileArgs
            {
                NetworkInterfaceConfigurations = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkConfigurationArgs
                    {
                        EnableIPForwarding = true,
                        IpConfigurations = new[]
                        {
                            new AzureNative.Compute.Inputs.VirtualMachineScaleSetIPConfigurationArgs
                            {
                                Name = "{vmss-name}",
                                Subnet = new AzureNative.Compute.Inputs.ApiEntityReferenceArgs
                                {
                                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                                },
                            },
                        },
                        Name = "{vmss-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerNamePrefix = "{vmss-name}",
            },
            StorageProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetStorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "windows-data-science-vm",
                    Publisher = "microsoft-ads",
                    Sku = "windows2016",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                },
            },
        },
        VmScaleSetName = "{vmss-name}",
    });

});

Coming soon!

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachineScaleSet;
import com.pulumi.azurenative.compute.VirtualMachineScaleSetArgs;
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 virtualMachineScaleSet = new VirtualMachineScaleSet("virtualMachineScaleSet", VirtualMachineScaleSetArgs.builder()        
            .location("westus")
            .overprovision(true)
            .plan(Map.ofEntries(
                Map.entry("name", "windows2016"),
                Map.entry("product", "windows-data-science-vm"),
                Map.entry("publisher", "microsoft-ads")
            ))
            .resourceGroupName("myResourceGroup")
            .sku(Map.ofEntries(
                Map.entry("capacity", 3),
                Map.entry("name", "Standard_D1_v2"),
                Map.entry("tier", "Standard")
            ))
            .upgradePolicy(Map.of("mode", "Manual"))
            .virtualMachineProfile(Map.ofEntries(
                Map.entry("networkProfile", Map.of("networkInterfaceConfigurations", Map.ofEntries(
                    Map.entry("enableIPForwarding", true),
                    Map.entry("ipConfigurations", Map.ofEntries(
                        Map.entry("name", "{vmss-name}"),
                        Map.entry("subnet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}"))
                    )),
                    Map.entry("name", "{vmss-name}"),
                    Map.entry("primary", true)
                ))),
                Map.entry("osProfile", Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerNamePrefix", "{vmss-name}")
                )),
                Map.entry("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"))
                    ))
                ))
            ))
            .vmScaleSetName("{vmss-name}")
            .build());

    }
}
import pulumi
import pulumi_azure_native as azure_native

virtual_machine_scale_set = azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet",
    location="westus",
    overprovision=True,
    plan=azure_native.compute.PlanArgs(
        name="windows2016",
        product="windows-data-science-vm",
        publisher="microsoft-ads",
    ),
    resource_group_name="myResourceGroup",
    sku=azure_native.compute.SkuArgs(
        capacity=3,
        name="Standard_D1_v2",
        tier="Standard",
    ),
    upgrade_policy=azure_native.compute.UpgradePolicyArgs(
        mode=azure_native.compute.UpgradeMode.MANUAL,
    ),
    virtual_machine_profile=azure_native.compute.VirtualMachineScaleSetVMProfileResponseArgs(
        network_profile={
            "networkInterfaceConfigurations": [{
                "enableIPForwarding": True,
                "ipConfigurations": [{
                    "name": "{vmss-name}",
                    "subnet": azure_native.compute.ApiEntityReferenceArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    ),
                }],
                "name": "{vmss-name}",
                "primary": True,
            }],
        },
        os_profile=azure_native.compute.VirtualMachineScaleSetOSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name_prefix="{vmss-name}",
        ),
        storage_profile={
            "imageReference": azure_native.compute.ImageReferenceArgs(
                offer="windows-data-science-vm",
                publisher="microsoft-ads",
                sku="windows2016",
                version="latest",
            ),
            "osDisk": {
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.VirtualMachineScaleSetManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
            },
        },
    ),
    vm_scale_set_name="{vmss-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const virtualMachineScaleSet = new azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet", {
    location: "westus",
    overprovision: true,
    plan: {
        name: "windows2016",
        product: "windows-data-science-vm",
        publisher: "microsoft-ads",
    },
    resourceGroupName: "myResourceGroup",
    sku: {
        capacity: 3,
        name: "Standard_D1_v2",
        tier: "Standard",
    },
    upgradePolicy: {
        mode: azure_native.compute.UpgradeMode.Manual,
    },
    virtualMachineProfile: {
        networkProfile: {
            networkInterfaceConfigurations: [{
                enableIPForwarding: true,
                ipConfigurations: [{
                    name: "{vmss-name}",
                    subnet: {
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    },
                }],
                name: "{vmss-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerNamePrefix: "{vmss-name}",
        },
        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",
                },
            },
        },
    },
    vmScaleSetName: "{vmss-name}",
});
resources:
  virtualMachineScaleSet:
    type: azure-native:compute:VirtualMachineScaleSet
    properties:
      location: westus
      overprovision: true
      plan:
        name: windows2016
        product: windows-data-science-vm
        publisher: microsoft-ads
      resourceGroupName: myResourceGroup
      sku:
        capacity: 3
        name: Standard_D1_v2
        tier: Standard
      upgradePolicy:
        mode: Manual
      virtualMachineProfile:
        networkProfile:
          networkInterfaceConfigurations:
            - enableIPForwarding: true
              ipConfigurations:
                - name: '{vmss-name}'
                  subnet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}
              name: '{vmss-name}'
              primary: true
        osProfile:
          adminPassword: '{your-password}'
          adminUsername: '{your-username}'
          computerNamePrefix: '{vmss-name}'
        storageProfile:
          imageReference:
            offer: windows-data-science-vm
            publisher: microsoft-ads
            sku: windows2016
            version: latest
          osDisk:
            caching: ReadWrite
            createOption: FromImage
            managedDisk:
              storageAccountType: Standard_LRS
      vmScaleSetName: '{vmss-name}'

Create a scale set with an azure application gateway.

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

return await Deployment.RunAsync(() => 
{
    var virtualMachineScaleSet = new AzureNative.Compute.VirtualMachineScaleSet("virtualMachineScaleSet", new()
    {
        Location = "westus",
        Overprovision = true,
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.SkuArgs
        {
            Capacity = 3,
            Name = "Standard_D1_v2",
            Tier = "Standard",
        },
        UpgradePolicy = new AzureNative.Compute.Inputs.UpgradePolicyArgs
        {
            Mode = AzureNative.Compute.UpgradeMode.Manual,
        },
        VirtualMachineProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetVMProfileArgs
        {
            NetworkProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkProfileArgs
            {
                NetworkInterfaceConfigurations = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkConfigurationArgs
                    {
                        EnableIPForwarding = true,
                        IpConfigurations = new[]
                        {
                            new AzureNative.Compute.Inputs.VirtualMachineScaleSetIPConfigurationArgs
                            {
                                ApplicationGatewayBackendAddressPools = new[]
                                {
                                    new AzureNative.Compute.Inputs.SubResourceArgs
                                    {
                                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/applicationGateways/{existing-application-gateway-name}/backendAddressPools/{existing-backend-address-pool-name}",
                                    },
                                },
                                Name = "{vmss-name}",
                                Subnet = new AzureNative.Compute.Inputs.ApiEntityReferenceArgs
                                {
                                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                                },
                            },
                        },
                        Name = "{vmss-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerNamePrefix = "{vmss-name}",
            },
            StorageProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetStorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "WindowsServer",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "2016-Datacenter",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                },
            },
        },
        VmScaleSetName = "{vmss-name}",
    });

});

Coming soon!

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachineScaleSet;
import com.pulumi.azurenative.compute.VirtualMachineScaleSetArgs;
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 virtualMachineScaleSet = new VirtualMachineScaleSet("virtualMachineScaleSet", VirtualMachineScaleSetArgs.builder()        
            .location("westus")
            .overprovision(true)
            .resourceGroupName("myResourceGroup")
            .sku(Map.ofEntries(
                Map.entry("capacity", 3),
                Map.entry("name", "Standard_D1_v2"),
                Map.entry("tier", "Standard")
            ))
            .upgradePolicy(Map.of("mode", "Manual"))
            .virtualMachineProfile(Map.ofEntries(
                Map.entry("networkProfile", Map.of("networkInterfaceConfigurations", Map.ofEntries(
                    Map.entry("enableIPForwarding", true),
                    Map.entry("ipConfigurations", Map.ofEntries(
                        Map.entry("applicationGatewayBackendAddressPools", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/applicationGateways/{existing-application-gateway-name}/backendAddressPools/{existing-backend-address-pool-name}")),
                        Map.entry("name", "{vmss-name}"),
                        Map.entry("subnet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}"))
                    )),
                    Map.entry("name", "{vmss-name}"),
                    Map.entry("primary", true)
                ))),
                Map.entry("osProfile", Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerNamePrefix", "{vmss-name}")
                )),
                Map.entry("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"))
                    ))
                ))
            ))
            .vmScaleSetName("{vmss-name}")
            .build());

    }
}
import pulumi
import pulumi_azure_native as azure_native

virtual_machine_scale_set = azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet",
    location="westus",
    overprovision=True,
    resource_group_name="myResourceGroup",
    sku=azure_native.compute.SkuArgs(
        capacity=3,
        name="Standard_D1_v2",
        tier="Standard",
    ),
    upgrade_policy=azure_native.compute.UpgradePolicyArgs(
        mode=azure_native.compute.UpgradeMode.MANUAL,
    ),
    virtual_machine_profile=azure_native.compute.VirtualMachineScaleSetVMProfileResponseArgs(
        network_profile={
            "networkInterfaceConfigurations": [{
                "enableIPForwarding": True,
                "ipConfigurations": [{
                    "applicationGatewayBackendAddressPools": [azure_native.compute.SubResourceArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/applicationGateways/{existing-application-gateway-name}/backendAddressPools/{existing-backend-address-pool-name}",
                    )],
                    "name": "{vmss-name}",
                    "subnet": azure_native.compute.ApiEntityReferenceArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    ),
                }],
                "name": "{vmss-name}",
                "primary": True,
            }],
        },
        os_profile=azure_native.compute.VirtualMachineScaleSetOSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name_prefix="{vmss-name}",
        ),
        storage_profile={
            "imageReference": azure_native.compute.ImageReferenceArgs(
                offer="WindowsServer",
                publisher="MicrosoftWindowsServer",
                sku="2016-Datacenter",
                version="latest",
            ),
            "osDisk": {
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.VirtualMachineScaleSetManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
            },
        },
    ),
    vm_scale_set_name="{vmss-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const virtualMachineScaleSet = new azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet", {
    location: "westus",
    overprovision: true,
    resourceGroupName: "myResourceGroup",
    sku: {
        capacity: 3,
        name: "Standard_D1_v2",
        tier: "Standard",
    },
    upgradePolicy: {
        mode: azure_native.compute.UpgradeMode.Manual,
    },
    virtualMachineProfile: {
        networkProfile: {
            networkInterfaceConfigurations: [{
                enableIPForwarding: true,
                ipConfigurations: [{
                    applicationGatewayBackendAddressPools: [{
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/applicationGateways/{existing-application-gateway-name}/backendAddressPools/{existing-backend-address-pool-name}",
                    }],
                    name: "{vmss-name}",
                    subnet: {
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    },
                }],
                name: "{vmss-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerNamePrefix: "{vmss-name}",
        },
        storageProfile: {
            imageReference: {
                offer: "WindowsServer",
                publisher: "MicrosoftWindowsServer",
                sku: "2016-Datacenter",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Standard_LRS",
                },
            },
        },
    },
    vmScaleSetName: "{vmss-name}",
});
resources:
  virtualMachineScaleSet:
    type: azure-native:compute:VirtualMachineScaleSet
    properties:
      location: westus
      overprovision: true
      resourceGroupName: myResourceGroup
      sku:
        capacity: 3
        name: Standard_D1_v2
        tier: Standard
      upgradePolicy:
        mode: Manual
      virtualMachineProfile:
        networkProfile:
          networkInterfaceConfigurations:
            - enableIPForwarding: true
              ipConfigurations:
                - applicationGatewayBackendAddressPools:
                    - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/applicationGateways/{existing-application-gateway-name}/backendAddressPools/{existing-backend-address-pool-name}
                  name: '{vmss-name}'
                  subnet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}
              name: '{vmss-name}'
              primary: true
        osProfile:
          adminPassword: '{your-password}'
          adminUsername: '{your-username}'
          computerNamePrefix: '{vmss-name}'
        storageProfile:
          imageReference:
            offer: WindowsServer
            publisher: MicrosoftWindowsServer
            sku: 2016-Datacenter
            version: latest
          osDisk:
            caching: ReadWrite
            createOption: FromImage
            managedDisk:
              storageAccountType: Standard_LRS
      vmScaleSetName: '{vmss-name}'

Create a scale set with an azure load balancer.

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

return await Deployment.RunAsync(() => 
{
    var virtualMachineScaleSet = new AzureNative.Compute.VirtualMachineScaleSet("virtualMachineScaleSet", new()
    {
        Location = "westus",
        Overprovision = true,
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.SkuArgs
        {
            Capacity = 3,
            Name = "Standard_D1_v2",
            Tier = "Standard",
        },
        UpgradePolicy = new AzureNative.Compute.Inputs.UpgradePolicyArgs
        {
            Mode = AzureNative.Compute.UpgradeMode.Manual,
        },
        VirtualMachineProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetVMProfileArgs
        {
            NetworkProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkProfileArgs
            {
                NetworkInterfaceConfigurations = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkConfigurationArgs
                    {
                        EnableIPForwarding = true,
                        IpConfigurations = new[]
                        {
                            new AzureNative.Compute.Inputs.VirtualMachineScaleSetIPConfigurationArgs
                            {
                                LoadBalancerBackendAddressPools = new[]
                                {
                                    new AzureNative.Compute.Inputs.SubResourceArgs
                                    {
                                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/{existing-load-balancer-name}/backendAddressPools/{existing-backend-address-pool-name}",
                                    },
                                },
                                LoadBalancerInboundNatPools = new[]
                                {
                                    new AzureNative.Compute.Inputs.SubResourceArgs
                                    {
                                        Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/{existing-load-balancer-name}/inboundNatPools/{existing-nat-pool-name}",
                                    },
                                },
                                Name = "{vmss-name}",
                                PublicIPAddressConfiguration = new AzureNative.Compute.Inputs.VirtualMachineScaleSetPublicIPAddressConfigurationArgs
                                {
                                    Name = "{vmss-name}",
                                    PublicIPAddressVersion = "IPv4",
                                },
                                Subnet = new AzureNative.Compute.Inputs.ApiEntityReferenceArgs
                                {
                                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                                },
                            },
                        },
                        Name = "{vmss-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerNamePrefix = "{vmss-name}",
            },
            StorageProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetStorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "WindowsServer",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "2016-Datacenter",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                },
            },
        },
        VmScaleSetName = "{vmss-name}",
    });

});

Coming soon!

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachineScaleSet;
import com.pulumi.azurenative.compute.VirtualMachineScaleSetArgs;
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 virtualMachineScaleSet = new VirtualMachineScaleSet("virtualMachineScaleSet", VirtualMachineScaleSetArgs.builder()        
            .location("westus")
            .overprovision(true)
            .resourceGroupName("myResourceGroup")
            .sku(Map.ofEntries(
                Map.entry("capacity", 3),
                Map.entry("name", "Standard_D1_v2"),
                Map.entry("tier", "Standard")
            ))
            .upgradePolicy(Map.of("mode", "Manual"))
            .virtualMachineProfile(Map.ofEntries(
                Map.entry("networkProfile", Map.of("networkInterfaceConfigurations", Map.ofEntries(
                    Map.entry("enableIPForwarding", true),
                    Map.entry("ipConfigurations", Map.ofEntries(
                        Map.entry("loadBalancerBackendAddressPools", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/{existing-load-balancer-name}/backendAddressPools/{existing-backend-address-pool-name}")),
                        Map.entry("loadBalancerInboundNatPools", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/{existing-load-balancer-name}/inboundNatPools/{existing-nat-pool-name}")),
                        Map.entry("name", "{vmss-name}"),
                        Map.entry("publicIPAddressConfiguration", Map.ofEntries(
                            Map.entry("name", "{vmss-name}"),
                            Map.entry("publicIPAddressVersion", "IPv4")
                        )),
                        Map.entry("subnet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}"))
                    )),
                    Map.entry("name", "{vmss-name}"),
                    Map.entry("primary", true)
                ))),
                Map.entry("osProfile", Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerNamePrefix", "{vmss-name}")
                )),
                Map.entry("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"))
                    ))
                ))
            ))
            .vmScaleSetName("{vmss-name}")
            .build());

    }
}
import pulumi
import pulumi_azure_native as azure_native

virtual_machine_scale_set = azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet",
    location="westus",
    overprovision=True,
    resource_group_name="myResourceGroup",
    sku=azure_native.compute.SkuArgs(
        capacity=3,
        name="Standard_D1_v2",
        tier="Standard",
    ),
    upgrade_policy=azure_native.compute.UpgradePolicyArgs(
        mode=azure_native.compute.UpgradeMode.MANUAL,
    ),
    virtual_machine_profile=azure_native.compute.VirtualMachineScaleSetVMProfileResponseArgs(
        network_profile={
            "networkInterfaceConfigurations": [{
                "enableIPForwarding": True,
                "ipConfigurations": [{
                    "loadBalancerBackendAddressPools": [azure_native.compute.SubResourceArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/{existing-load-balancer-name}/backendAddressPools/{existing-backend-address-pool-name}",
                    )],
                    "loadBalancerInboundNatPools": [azure_native.compute.SubResourceArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/{existing-load-balancer-name}/inboundNatPools/{existing-nat-pool-name}",
                    )],
                    "name": "{vmss-name}",
                    "publicIPAddressConfiguration": azure_native.compute.VirtualMachineScaleSetPublicIPAddressConfigurationArgs(
                        name="{vmss-name}",
                        public_ip_address_version="IPv4",
                    ),
                    "subnet": azure_native.compute.ApiEntityReferenceArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    ),
                }],
                "name": "{vmss-name}",
                "primary": True,
            }],
        },
        os_profile=azure_native.compute.VirtualMachineScaleSetOSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name_prefix="{vmss-name}",
        ),
        storage_profile={
            "imageReference": azure_native.compute.ImageReferenceArgs(
                offer="WindowsServer",
                publisher="MicrosoftWindowsServer",
                sku="2016-Datacenter",
                version="latest",
            ),
            "osDisk": {
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.VirtualMachineScaleSetManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
            },
        },
    ),
    vm_scale_set_name="{vmss-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const virtualMachineScaleSet = new azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet", {
    location: "westus",
    overprovision: true,
    resourceGroupName: "myResourceGroup",
    sku: {
        capacity: 3,
        name: "Standard_D1_v2",
        tier: "Standard",
    },
    upgradePolicy: {
        mode: azure_native.compute.UpgradeMode.Manual,
    },
    virtualMachineProfile: {
        networkProfile: {
            networkInterfaceConfigurations: [{
                enableIPForwarding: true,
                ipConfigurations: [{
                    loadBalancerBackendAddressPools: [{
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/{existing-load-balancer-name}/backendAddressPools/{existing-backend-address-pool-name}",
                    }],
                    loadBalancerInboundNatPools: [{
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/{existing-load-balancer-name}/inboundNatPools/{existing-nat-pool-name}",
                    }],
                    name: "{vmss-name}",
                    publicIPAddressConfiguration: {
                        name: "{vmss-name}",
                        publicIPAddressVersion: "IPv4",
                    },
                    subnet: {
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    },
                }],
                name: "{vmss-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerNamePrefix: "{vmss-name}",
        },
        storageProfile: {
            imageReference: {
                offer: "WindowsServer",
                publisher: "MicrosoftWindowsServer",
                sku: "2016-Datacenter",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Standard_LRS",
                },
            },
        },
    },
    vmScaleSetName: "{vmss-name}",
});
resources:
  virtualMachineScaleSet:
    type: azure-native:compute:VirtualMachineScaleSet
    properties:
      location: westus
      overprovision: true
      resourceGroupName: myResourceGroup
      sku:
        capacity: 3
        name: Standard_D1_v2
        tier: Standard
      upgradePolicy:
        mode: Manual
      virtualMachineProfile:
        networkProfile:
          networkInterfaceConfigurations:
            - enableIPForwarding: true
              ipConfigurations:
                - loadBalancerBackendAddressPools:
                    - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/{existing-load-balancer-name}/backendAddressPools/{existing-backend-address-pool-name}
                  loadBalancerInboundNatPools:
                    - id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/loadBalancers/{existing-load-balancer-name}/inboundNatPools/{existing-nat-pool-name}
                  name: '{vmss-name}'
                  publicIPAddressConfiguration:
                    name: '{vmss-name}'
                    publicIPAddressVersion: IPv4
                  subnet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}
              name: '{vmss-name}'
              primary: true
        osProfile:
          adminPassword: '{your-password}'
          adminUsername: '{your-username}'
          computerNamePrefix: '{vmss-name}'
        storageProfile:
          imageReference:
            offer: WindowsServer
            publisher: MicrosoftWindowsServer
            sku: 2016-Datacenter
            version: latest
          osDisk:
            caching: ReadWrite
            createOption: FromImage
            managedDisk:
              storageAccountType: Standard_LRS
      vmScaleSetName: '{vmss-name}'

Create a scale set with automatic repairs enabled

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

return await Deployment.RunAsync(() => 
{
    var virtualMachineScaleSet = new AzureNative.Compute.VirtualMachineScaleSet("virtualMachineScaleSet", new()
    {
        AutomaticRepairsPolicy = new AzureNative.Compute.Inputs.AutomaticRepairsPolicyArgs
        {
            Enabled = true,
            GracePeriod = "PT30M",
        },
        Location = "westus",
        Overprovision = true,
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.SkuArgs
        {
            Capacity = 3,
            Name = "Standard_D1_v2",
            Tier = "Standard",
        },
        UpgradePolicy = new AzureNative.Compute.Inputs.UpgradePolicyArgs
        {
            Mode = AzureNative.Compute.UpgradeMode.Manual,
        },
        VirtualMachineProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetVMProfileArgs
        {
            NetworkProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkProfileArgs
            {
                NetworkInterfaceConfigurations = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkConfigurationArgs
                    {
                        EnableIPForwarding = true,
                        IpConfigurations = new[]
                        {
                            new AzureNative.Compute.Inputs.VirtualMachineScaleSetIPConfigurationArgs
                            {
                                Name = "{vmss-name}",
                                Subnet = new AzureNative.Compute.Inputs.ApiEntityReferenceArgs
                                {
                                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                                },
                            },
                        },
                        Name = "{vmss-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerNamePrefix = "{vmss-name}",
            },
            StorageProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetStorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "WindowsServer",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "2016-Datacenter",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                },
            },
        },
        VmScaleSetName = "{vmss-name}",
    });

});

Coming soon!

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachineScaleSet;
import com.pulumi.azurenative.compute.VirtualMachineScaleSetArgs;
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 virtualMachineScaleSet = new VirtualMachineScaleSet("virtualMachineScaleSet", VirtualMachineScaleSetArgs.builder()        
            .automaticRepairsPolicy(Map.ofEntries(
                Map.entry("enabled", true),
                Map.entry("gracePeriod", "PT30M")
            ))
            .location("westus")
            .overprovision(true)
            .resourceGroupName("myResourceGroup")
            .sku(Map.ofEntries(
                Map.entry("capacity", 3),
                Map.entry("name", "Standard_D1_v2"),
                Map.entry("tier", "Standard")
            ))
            .upgradePolicy(Map.of("mode", "Manual"))
            .virtualMachineProfile(Map.ofEntries(
                Map.entry("networkProfile", Map.of("networkInterfaceConfigurations", Map.ofEntries(
                    Map.entry("enableIPForwarding", true),
                    Map.entry("ipConfigurations", Map.ofEntries(
                        Map.entry("name", "{vmss-name}"),
                        Map.entry("subnet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}"))
                    )),
                    Map.entry("name", "{vmss-name}"),
                    Map.entry("primary", true)
                ))),
                Map.entry("osProfile", Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerNamePrefix", "{vmss-name}")
                )),
                Map.entry("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"))
                    ))
                ))
            ))
            .vmScaleSetName("{vmss-name}")
            .build());

    }
}
import pulumi
import pulumi_azure_native as azure_native

virtual_machine_scale_set = azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet",
    automatic_repairs_policy=azure_native.compute.AutomaticRepairsPolicyArgs(
        enabled=True,
        grace_period="PT30M",
    ),
    location="westus",
    overprovision=True,
    resource_group_name="myResourceGroup",
    sku=azure_native.compute.SkuArgs(
        capacity=3,
        name="Standard_D1_v2",
        tier="Standard",
    ),
    upgrade_policy=azure_native.compute.UpgradePolicyArgs(
        mode=azure_native.compute.UpgradeMode.MANUAL,
    ),
    virtual_machine_profile=azure_native.compute.VirtualMachineScaleSetVMProfileResponseArgs(
        network_profile={
            "networkInterfaceConfigurations": [{
                "enableIPForwarding": True,
                "ipConfigurations": [{
                    "name": "{vmss-name}",
                    "subnet": azure_native.compute.ApiEntityReferenceArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    ),
                }],
                "name": "{vmss-name}",
                "primary": True,
            }],
        },
        os_profile=azure_native.compute.VirtualMachineScaleSetOSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name_prefix="{vmss-name}",
        ),
        storage_profile={
            "imageReference": azure_native.compute.ImageReferenceArgs(
                offer="WindowsServer",
                publisher="MicrosoftWindowsServer",
                sku="2016-Datacenter",
                version="latest",
            ),
            "osDisk": {
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.VirtualMachineScaleSetManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
            },
        },
    ),
    vm_scale_set_name="{vmss-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const virtualMachineScaleSet = new azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet", {
    automaticRepairsPolicy: {
        enabled: true,
        gracePeriod: "PT30M",
    },
    location: "westus",
    overprovision: true,
    resourceGroupName: "myResourceGroup",
    sku: {
        capacity: 3,
        name: "Standard_D1_v2",
        tier: "Standard",
    },
    upgradePolicy: {
        mode: azure_native.compute.UpgradeMode.Manual,
    },
    virtualMachineProfile: {
        networkProfile: {
            networkInterfaceConfigurations: [{
                enableIPForwarding: true,
                ipConfigurations: [{
                    name: "{vmss-name}",
                    subnet: {
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    },
                }],
                name: "{vmss-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerNamePrefix: "{vmss-name}",
        },
        storageProfile: {
            imageReference: {
                offer: "WindowsServer",
                publisher: "MicrosoftWindowsServer",
                sku: "2016-Datacenter",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Standard_LRS",
                },
            },
        },
    },
    vmScaleSetName: "{vmss-name}",
});
resources:
  virtualMachineScaleSet:
    type: azure-native:compute:VirtualMachineScaleSet
    properties:
      automaticRepairsPolicy:
        enabled: true
        gracePeriod: PT30M
      location: westus
      overprovision: true
      resourceGroupName: myResourceGroup
      sku:
        capacity: 3
        name: Standard_D1_v2
        tier: Standard
      upgradePolicy:
        mode: Manual
      virtualMachineProfile:
        networkProfile:
          networkInterfaceConfigurations:
            - enableIPForwarding: true
              ipConfigurations:
                - name: '{vmss-name}'
                  subnet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}
              name: '{vmss-name}'
              primary: true
        osProfile:
          adminPassword: '{your-password}'
          adminUsername: '{your-username}'
          computerNamePrefix: '{vmss-name}'
        storageProfile:
          imageReference:
            offer: WindowsServer
            publisher: MicrosoftWindowsServer
            sku: 2016-Datacenter
            version: latest
          osDisk:
            caching: ReadWrite
            createOption: FromImage
            managedDisk:
              storageAccountType: Standard_LRS
      vmScaleSetName: '{vmss-name}'

Create a scale set with boot diagnostics.

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

return await Deployment.RunAsync(() => 
{
    var virtualMachineScaleSet = new AzureNative.Compute.VirtualMachineScaleSet("virtualMachineScaleSet", new()
    {
        Location = "westus",
        Overprovision = true,
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.SkuArgs
        {
            Capacity = 3,
            Name = "Standard_D1_v2",
            Tier = "Standard",
        },
        UpgradePolicy = new AzureNative.Compute.Inputs.UpgradePolicyArgs
        {
            Mode = AzureNative.Compute.UpgradeMode.Manual,
        },
        VirtualMachineProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetVMProfileArgs
        {
            DiagnosticsProfile = new AzureNative.Compute.Inputs.DiagnosticsProfileArgs
            {
                BootDiagnostics = new AzureNative.Compute.Inputs.BootDiagnosticsArgs
                {
                    Enabled = true,
                    StorageUri = "http://{existing-storage-account-name}.blob.core.windows.net",
                },
            },
            NetworkProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkProfileArgs
            {
                NetworkInterfaceConfigurations = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkConfigurationArgs
                    {
                        EnableIPForwarding = true,
                        IpConfigurations = new[]
                        {
                            new AzureNative.Compute.Inputs.VirtualMachineScaleSetIPConfigurationArgs
                            {
                                Name = "{vmss-name}",
                                Subnet = new AzureNative.Compute.Inputs.ApiEntityReferenceArgs
                                {
                                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                                },
                            },
                        },
                        Name = "{vmss-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerNamePrefix = "{vmss-name}",
            },
            StorageProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetStorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "WindowsServer",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "2016-Datacenter",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                },
            },
        },
        VmScaleSetName = "{vmss-name}",
    });

});

Coming soon!

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachineScaleSet;
import com.pulumi.azurenative.compute.VirtualMachineScaleSetArgs;
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 virtualMachineScaleSet = new VirtualMachineScaleSet("virtualMachineScaleSet", VirtualMachineScaleSetArgs.builder()        
            .location("westus")
            .overprovision(true)
            .resourceGroupName("myResourceGroup")
            .sku(Map.ofEntries(
                Map.entry("capacity", 3),
                Map.entry("name", "Standard_D1_v2"),
                Map.entry("tier", "Standard")
            ))
            .upgradePolicy(Map.of("mode", "Manual"))
            .virtualMachineProfile(Map.ofEntries(
                Map.entry("diagnosticsProfile", Map.of("bootDiagnostics", Map.ofEntries(
                    Map.entry("enabled", true),
                    Map.entry("storageUri", "http://{existing-storage-account-name}.blob.core.windows.net")
                ))),
                Map.entry("networkProfile", Map.of("networkInterfaceConfigurations", Map.ofEntries(
                    Map.entry("enableIPForwarding", true),
                    Map.entry("ipConfigurations", Map.ofEntries(
                        Map.entry("name", "{vmss-name}"),
                        Map.entry("subnet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}"))
                    )),
                    Map.entry("name", "{vmss-name}"),
                    Map.entry("primary", true)
                ))),
                Map.entry("osProfile", Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerNamePrefix", "{vmss-name}")
                )),
                Map.entry("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"))
                    ))
                ))
            ))
            .vmScaleSetName("{vmss-name}")
            .build());

    }
}
import pulumi
import pulumi_azure_native as azure_native

virtual_machine_scale_set = azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet",
    location="westus",
    overprovision=True,
    resource_group_name="myResourceGroup",
    sku=azure_native.compute.SkuArgs(
        capacity=3,
        name="Standard_D1_v2",
        tier="Standard",
    ),
    upgrade_policy=azure_native.compute.UpgradePolicyArgs(
        mode=azure_native.compute.UpgradeMode.MANUAL,
    ),
    virtual_machine_profile=azure_native.compute.VirtualMachineScaleSetVMProfileResponseArgs(
        diagnostics_profile={
            "bootDiagnostics": azure_native.compute.BootDiagnosticsArgs(
                enabled=True,
                storage_uri="http://{existing-storage-account-name}.blob.core.windows.net",
            ),
        },
        network_profile={
            "networkInterfaceConfigurations": [{
                "enableIPForwarding": True,
                "ipConfigurations": [{
                    "name": "{vmss-name}",
                    "subnet": azure_native.compute.ApiEntityReferenceArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    ),
                }],
                "name": "{vmss-name}",
                "primary": True,
            }],
        },
        os_profile=azure_native.compute.VirtualMachineScaleSetOSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name_prefix="{vmss-name}",
        ),
        storage_profile={
            "imageReference": azure_native.compute.ImageReferenceArgs(
                offer="WindowsServer",
                publisher="MicrosoftWindowsServer",
                sku="2016-Datacenter",
                version="latest",
            ),
            "osDisk": {
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.VirtualMachineScaleSetManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
            },
        },
    ),
    vm_scale_set_name="{vmss-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const virtualMachineScaleSet = new azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet", {
    location: "westus",
    overprovision: true,
    resourceGroupName: "myResourceGroup",
    sku: {
        capacity: 3,
        name: "Standard_D1_v2",
        tier: "Standard",
    },
    upgradePolicy: {
        mode: azure_native.compute.UpgradeMode.Manual,
    },
    virtualMachineProfile: {
        diagnosticsProfile: {
            bootDiagnostics: {
                enabled: true,
                storageUri: "http://{existing-storage-account-name}.blob.core.windows.net",
            },
        },
        networkProfile: {
            networkInterfaceConfigurations: [{
                enableIPForwarding: true,
                ipConfigurations: [{
                    name: "{vmss-name}",
                    subnet: {
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    },
                }],
                name: "{vmss-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerNamePrefix: "{vmss-name}",
        },
        storageProfile: {
            imageReference: {
                offer: "WindowsServer",
                publisher: "MicrosoftWindowsServer",
                sku: "2016-Datacenter",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Standard_LRS",
                },
            },
        },
    },
    vmScaleSetName: "{vmss-name}",
});
resources:
  virtualMachineScaleSet:
    type: azure-native:compute:VirtualMachineScaleSet
    properties:
      location: westus
      overprovision: true
      resourceGroupName: myResourceGroup
      sku:
        capacity: 3
        name: Standard_D1_v2
        tier: Standard
      upgradePolicy:
        mode: Manual
      virtualMachineProfile:
        diagnosticsProfile:
          bootDiagnostics:
            enabled: true
            storageUri: http://{existing-storage-account-name}.blob.core.windows.net
        networkProfile:
          networkInterfaceConfigurations:
            - enableIPForwarding: true
              ipConfigurations:
                - name: '{vmss-name}'
                  subnet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}
              name: '{vmss-name}'
              primary: true
        osProfile:
          adminPassword: '{your-password}'
          adminUsername: '{your-username}'
          computerNamePrefix: '{vmss-name}'
        storageProfile:
          imageReference:
            offer: WindowsServer
            publisher: MicrosoftWindowsServer
            sku: 2016-Datacenter
            version: latest
          osDisk:
            caching: ReadWrite
            createOption: FromImage
            managedDisk:
              storageAccountType: Standard_LRS
      vmScaleSetName: '{vmss-name}'

Create a scale set with empty data disks on each vm.

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

return await Deployment.RunAsync(() => 
{
    var virtualMachineScaleSet = new AzureNative.Compute.VirtualMachineScaleSet("virtualMachineScaleSet", new()
    {
        Location = "westus",
        Overprovision = true,
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.SkuArgs
        {
            Capacity = 3,
            Name = "Standard_D2_v2",
            Tier = "Standard",
        },
        UpgradePolicy = new AzureNative.Compute.Inputs.UpgradePolicyArgs
        {
            Mode = AzureNative.Compute.UpgradeMode.Manual,
        },
        VirtualMachineProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetVMProfileArgs
        {
            NetworkProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkProfileArgs
            {
                NetworkInterfaceConfigurations = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkConfigurationArgs
                    {
                        EnableIPForwarding = true,
                        IpConfigurations = new[]
                        {
                            new AzureNative.Compute.Inputs.VirtualMachineScaleSetIPConfigurationArgs
                            {
                                Name = "{vmss-name}",
                                Subnet = new AzureNative.Compute.Inputs.ApiEntityReferenceArgs
                                {
                                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                                },
                            },
                        },
                        Name = "{vmss-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerNamePrefix = "{vmss-name}",
            },
            StorageProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetStorageProfileArgs
            {
                DataDisks = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetDataDiskArgs
                    {
                        CreateOption = "Empty",
                        DiskSizeGB = 1023,
                        Lun = 0,
                    },
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetDataDiskArgs
                    {
                        CreateOption = "Empty",
                        DiskSizeGB = 1023,
                        Lun = 1,
                    },
                },
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "WindowsServer",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "2016-Datacenter",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    DiskSizeGB = 512,
                    ManagedDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                },
            },
        },
        VmScaleSetName = "{vmss-name}",
    });

});

Coming soon!

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachineScaleSet;
import com.pulumi.azurenative.compute.VirtualMachineScaleSetArgs;
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 virtualMachineScaleSet = new VirtualMachineScaleSet("virtualMachineScaleSet", VirtualMachineScaleSetArgs.builder()        
            .location("westus")
            .overprovision(true)
            .resourceGroupName("myResourceGroup")
            .sku(Map.ofEntries(
                Map.entry("capacity", 3),
                Map.entry("name", "Standard_D2_v2"),
                Map.entry("tier", "Standard")
            ))
            .upgradePolicy(Map.of("mode", "Manual"))
            .virtualMachineProfile(Map.ofEntries(
                Map.entry("networkProfile", Map.of("networkInterfaceConfigurations", Map.ofEntries(
                    Map.entry("enableIPForwarding", true),
                    Map.entry("ipConfigurations", Map.ofEntries(
                        Map.entry("name", "{vmss-name}"),
                        Map.entry("subnet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}"))
                    )),
                    Map.entry("name", "{vmss-name}"),
                    Map.entry("primary", true)
                ))),
                Map.entry("osProfile", Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerNamePrefix", "{vmss-name}")
                )),
                Map.entry("storageProfile", Map.ofEntries(
                    Map.entry("dataDisks",                     
                        Map.ofEntries(
                            Map.entry("createOption", "Empty"),
                            Map.entry("diskSizeGB", 1023),
                            Map.entry("lun", 0)
                        ),
                        Map.ofEntries(
                            Map.entry("createOption", "Empty"),
                            Map.entry("diskSizeGB", 1023),
                            Map.entry("lun", 1)
                        )),
                    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("diskSizeGB", 512),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS"))
                    ))
                ))
            ))
            .vmScaleSetName("{vmss-name}")
            .build());

    }
}
import pulumi
import pulumi_azure_native as azure_native

virtual_machine_scale_set = azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet",
    location="westus",
    overprovision=True,
    resource_group_name="myResourceGroup",
    sku=azure_native.compute.SkuArgs(
        capacity=3,
        name="Standard_D2_v2",
        tier="Standard",
    ),
    upgrade_policy=azure_native.compute.UpgradePolicyArgs(
        mode=azure_native.compute.UpgradeMode.MANUAL,
    ),
    virtual_machine_profile=azure_native.compute.VirtualMachineScaleSetVMProfileResponseArgs(
        network_profile={
            "networkInterfaceConfigurations": [{
                "enableIPForwarding": True,
                "ipConfigurations": [{
                    "name": "{vmss-name}",
                    "subnet": azure_native.compute.ApiEntityReferenceArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    ),
                }],
                "name": "{vmss-name}",
                "primary": True,
            }],
        },
        os_profile=azure_native.compute.VirtualMachineScaleSetOSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name_prefix="{vmss-name}",
        ),
        storage_profile={
            "dataDisks": [
                azure_native.compute.VirtualMachineScaleSetDataDiskArgs(
                    create_option="Empty",
                    disk_size_gb=1023,
                    lun=0,
                ),
                azure_native.compute.VirtualMachineScaleSetDataDiskArgs(
                    create_option="Empty",
                    disk_size_gb=1023,
                    lun=1,
                ),
            ],
            "imageReference": azure_native.compute.ImageReferenceArgs(
                offer="WindowsServer",
                publisher="MicrosoftWindowsServer",
                sku="2016-Datacenter",
                version="latest",
            ),
            "osDisk": {
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "diskSizeGB": 512,
                "managedDisk": azure_native.compute.VirtualMachineScaleSetManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
            },
        },
    ),
    vm_scale_set_name="{vmss-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const virtualMachineScaleSet = new azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet", {
    location: "westus",
    overprovision: true,
    resourceGroupName: "myResourceGroup",
    sku: {
        capacity: 3,
        name: "Standard_D2_v2",
        tier: "Standard",
    },
    upgradePolicy: {
        mode: azure_native.compute.UpgradeMode.Manual,
    },
    virtualMachineProfile: {
        networkProfile: {
            networkInterfaceConfigurations: [{
                enableIPForwarding: true,
                ipConfigurations: [{
                    name: "{vmss-name}",
                    subnet: {
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    },
                }],
                name: "{vmss-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerNamePrefix: "{vmss-name}",
        },
        storageProfile: {
            dataDisks: [
                {
                    createOption: "Empty",
                    diskSizeGB: 1023,
                    lun: 0,
                },
                {
                    createOption: "Empty",
                    diskSizeGB: 1023,
                    lun: 1,
                },
            ],
            imageReference: {
                offer: "WindowsServer",
                publisher: "MicrosoftWindowsServer",
                sku: "2016-Datacenter",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                diskSizeGB: 512,
                managedDisk: {
                    storageAccountType: "Standard_LRS",
                },
            },
        },
    },
    vmScaleSetName: "{vmss-name}",
});
resources:
  virtualMachineScaleSet:
    type: azure-native:compute:VirtualMachineScaleSet
    properties:
      location: westus
      overprovision: true
      resourceGroupName: myResourceGroup
      sku:
        capacity: 3
        name: Standard_D2_v2
        tier: Standard
      upgradePolicy:
        mode: Manual
      virtualMachineProfile:
        networkProfile:
          networkInterfaceConfigurations:
            - enableIPForwarding: true
              ipConfigurations:
                - name: '{vmss-name}'
                  subnet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}
              name: '{vmss-name}'
              primary: true
        osProfile:
          adminPassword: '{your-password}'
          adminUsername: '{your-username}'
          computerNamePrefix: '{vmss-name}'
        storageProfile:
          dataDisks:
            - createOption: Empty
              diskSizeGB: 1023
              lun: 0
            - createOption: Empty
              diskSizeGB: 1023
              lun: 1
          imageReference:
            offer: WindowsServer
            publisher: MicrosoftWindowsServer
            sku: 2016-Datacenter
            version: latest
          osDisk:
            caching: ReadWrite
            createOption: FromImage
            diskSizeGB: 512
            managedDisk:
              storageAccountType: Standard_LRS
      vmScaleSetName: '{vmss-name}'

Create a scale set with ephemeral os disks using placement property.

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

return await Deployment.RunAsync(() => 
{
    var virtualMachineScaleSet = new AzureNative.Compute.VirtualMachineScaleSet("virtualMachineScaleSet", new()
    {
        Location = "westus",
        Overprovision = true,
        Plan = new AzureNative.Compute.Inputs.PlanArgs
        {
            Name = "windows2016",
            Product = "windows-data-science-vm",
            Publisher = "microsoft-ads",
        },
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.SkuArgs
        {
            Capacity = 3,
            Name = "Standard_DS1_v2",
            Tier = "Standard",
        },
        UpgradePolicy = new AzureNative.Compute.Inputs.UpgradePolicyArgs
        {
            Mode = AzureNative.Compute.UpgradeMode.Manual,
        },
        VirtualMachineProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetVMProfileArgs
        {
            NetworkProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkProfileArgs
            {
                NetworkInterfaceConfigurations = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkConfigurationArgs
                    {
                        EnableIPForwarding = true,
                        IpConfigurations = new[]
                        {
                            new AzureNative.Compute.Inputs.VirtualMachineScaleSetIPConfigurationArgs
                            {
                                Name = "{vmss-name}",
                                Subnet = new AzureNative.Compute.Inputs.ApiEntityReferenceArgs
                                {
                                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                                },
                            },
                        },
                        Name = "{vmss-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerNamePrefix = "{vmss-name}",
            },
            StorageProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetStorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "windows-data-science-vm",
                    Publisher = "microsoft-ads",
                    Sku = "windows2016",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadOnly,
                    CreateOption = "FromImage",
                    DiffDiskSettings = new AzureNative.Compute.Inputs.DiffDiskSettingsArgs
                    {
                        Option = "Local",
                        Placement = "ResourceDisk",
                    },
                    ManagedDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                },
            },
        },
        VmScaleSetName = "{vmss-name}",
    });

});

Coming soon!

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachineScaleSet;
import com.pulumi.azurenative.compute.VirtualMachineScaleSetArgs;
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 virtualMachineScaleSet = new VirtualMachineScaleSet("virtualMachineScaleSet", VirtualMachineScaleSetArgs.builder()        
            .location("westus")
            .overprovision(true)
            .plan(Map.ofEntries(
                Map.entry("name", "windows2016"),
                Map.entry("product", "windows-data-science-vm"),
                Map.entry("publisher", "microsoft-ads")
            ))
            .resourceGroupName("myResourceGroup")
            .sku(Map.ofEntries(
                Map.entry("capacity", 3),
                Map.entry("name", "Standard_DS1_v2"),
                Map.entry("tier", "Standard")
            ))
            .upgradePolicy(Map.of("mode", "Manual"))
            .virtualMachineProfile(Map.ofEntries(
                Map.entry("networkProfile", Map.of("networkInterfaceConfigurations", Map.ofEntries(
                    Map.entry("enableIPForwarding", true),
                    Map.entry("ipConfigurations", Map.ofEntries(
                        Map.entry("name", "{vmss-name}"),
                        Map.entry("subnet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}"))
                    )),
                    Map.entry("name", "{vmss-name}"),
                    Map.entry("primary", true)
                ))),
                Map.entry("osProfile", Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerNamePrefix", "{vmss-name}")
                )),
                Map.entry("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("diffDiskSettings", Map.ofEntries(
                            Map.entry("option", "Local"),
                            Map.entry("placement", "ResourceDisk")
                        )),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS"))
                    ))
                ))
            ))
            .vmScaleSetName("{vmss-name}")
            .build());

    }
}
import pulumi
import pulumi_azure_native as azure_native

virtual_machine_scale_set = azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet",
    location="westus",
    overprovision=True,
    plan=azure_native.compute.PlanArgs(
        name="windows2016",
        product="windows-data-science-vm",
        publisher="microsoft-ads",
    ),
    resource_group_name="myResourceGroup",
    sku=azure_native.compute.SkuArgs(
        capacity=3,
        name="Standard_DS1_v2",
        tier="Standard",
    ),
    upgrade_policy=azure_native.compute.UpgradePolicyArgs(
        mode=azure_native.compute.UpgradeMode.MANUAL,
    ),
    virtual_machine_profile=azure_native.compute.VirtualMachineScaleSetVMProfileResponseArgs(
        network_profile={
            "networkInterfaceConfigurations": [{
                "enableIPForwarding": True,
                "ipConfigurations": [{
                    "name": "{vmss-name}",
                    "subnet": azure_native.compute.ApiEntityReferenceArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    ),
                }],
                "name": "{vmss-name}",
                "primary": True,
            }],
        },
        os_profile=azure_native.compute.VirtualMachineScaleSetOSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name_prefix="{vmss-name}",
        ),
        storage_profile={
            "imageReference": azure_native.compute.ImageReferenceArgs(
                offer="windows-data-science-vm",
                publisher="microsoft-ads",
                sku="windows2016",
                version="latest",
            ),
            "osDisk": {
                "caching": azure_native.compute.CachingTypes.READ_ONLY,
                "createOption": "FromImage",
                "diffDiskSettings": azure_native.compute.DiffDiskSettingsArgs(
                    option="Local",
                    placement="ResourceDisk",
                ),
                "managedDisk": azure_native.compute.VirtualMachineScaleSetManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
            },
        },
    ),
    vm_scale_set_name="{vmss-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const virtualMachineScaleSet = new azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet", {
    location: "westus",
    overprovision: true,
    plan: {
        name: "windows2016",
        product: "windows-data-science-vm",
        publisher: "microsoft-ads",
    },
    resourceGroupName: "myResourceGroup",
    sku: {
        capacity: 3,
        name: "Standard_DS1_v2",
        tier: "Standard",
    },
    upgradePolicy: {
        mode: azure_native.compute.UpgradeMode.Manual,
    },
    virtualMachineProfile: {
        networkProfile: {
            networkInterfaceConfigurations: [{
                enableIPForwarding: true,
                ipConfigurations: [{
                    name: "{vmss-name}",
                    subnet: {
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    },
                }],
                name: "{vmss-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerNamePrefix: "{vmss-name}",
        },
        storageProfile: {
            imageReference: {
                offer: "windows-data-science-vm",
                publisher: "microsoft-ads",
                sku: "windows2016",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadOnly,
                createOption: "FromImage",
                diffDiskSettings: {
                    option: "Local",
                    placement: "ResourceDisk",
                },
                managedDisk: {
                    storageAccountType: "Standard_LRS",
                },
            },
        },
    },
    vmScaleSetName: "{vmss-name}",
});
resources:
  virtualMachineScaleSet:
    type: azure-native:compute:VirtualMachineScaleSet
    properties:
      location: westus
      overprovision: true
      plan:
        name: windows2016
        product: windows-data-science-vm
        publisher: microsoft-ads
      resourceGroupName: myResourceGroup
      sku:
        capacity: 3
        name: Standard_DS1_v2
        tier: Standard
      upgradePolicy:
        mode: Manual
      virtualMachineProfile:
        networkProfile:
          networkInterfaceConfigurations:
            - enableIPForwarding: true
              ipConfigurations:
                - name: '{vmss-name}'
                  subnet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}
              name: '{vmss-name}'
              primary: true
        osProfile:
          adminPassword: '{your-password}'
          adminUsername: '{your-username}'
          computerNamePrefix: '{vmss-name}'
        storageProfile:
          imageReference:
            offer: windows-data-science-vm
            publisher: microsoft-ads
            sku: windows2016
            version: latest
          osDisk:
            caching: ReadOnly
            createOption: FromImage
            diffDiskSettings:
              option: Local
              placement: ResourceDisk
            managedDisk:
              storageAccountType: Standard_LRS
      vmScaleSetName: '{vmss-name}'

Create a scale set with ephemeral os disks.

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

return await Deployment.RunAsync(() => 
{
    var virtualMachineScaleSet = new AzureNative.Compute.VirtualMachineScaleSet("virtualMachineScaleSet", new()
    {
        Location = "westus",
        Overprovision = true,
        Plan = new AzureNative.Compute.Inputs.PlanArgs
        {
            Name = "windows2016",
            Product = "windows-data-science-vm",
            Publisher = "microsoft-ads",
        },
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.SkuArgs
        {
            Capacity = 3,
            Name = "Standard_DS1_v2",
            Tier = "Standard",
        },
        UpgradePolicy = new AzureNative.Compute.Inputs.UpgradePolicyArgs
        {
            Mode = AzureNative.Compute.UpgradeMode.Manual,
        },
        VirtualMachineProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetVMProfileArgs
        {
            NetworkProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkProfileArgs
            {
                NetworkInterfaceConfigurations = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkConfigurationArgs
                    {
                        EnableIPForwarding = true,
                        IpConfigurations = new[]
                        {
                            new AzureNative.Compute.Inputs.VirtualMachineScaleSetIPConfigurationArgs
                            {
                                Name = "{vmss-name}",
                                Subnet = new AzureNative.Compute.Inputs.ApiEntityReferenceArgs
                                {
                                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                                },
                            },
                        },
                        Name = "{vmss-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerNamePrefix = "{vmss-name}",
            },
            StorageProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetStorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "windows-data-science-vm",
                    Publisher = "microsoft-ads",
                    Sku = "windows2016",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadOnly,
                    CreateOption = "FromImage",
                    DiffDiskSettings = new AzureNative.Compute.Inputs.DiffDiskSettingsArgs
                    {
                        Option = "Local",
                    },
                    ManagedDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                },
            },
        },
        VmScaleSetName = "{vmss-name}",
    });

});

Coming soon!

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachineScaleSet;
import com.pulumi.azurenative.compute.VirtualMachineScaleSetArgs;
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 virtualMachineScaleSet = new VirtualMachineScaleSet("virtualMachineScaleSet", VirtualMachineScaleSetArgs.builder()        
            .location("westus")
            .overprovision(true)
            .plan(Map.ofEntries(
                Map.entry("name", "windows2016"),
                Map.entry("product", "windows-data-science-vm"),
                Map.entry("publisher", "microsoft-ads")
            ))
            .resourceGroupName("myResourceGroup")
            .sku(Map.ofEntries(
                Map.entry("capacity", 3),
                Map.entry("name", "Standard_DS1_v2"),
                Map.entry("tier", "Standard")
            ))
            .upgradePolicy(Map.of("mode", "Manual"))
            .virtualMachineProfile(Map.ofEntries(
                Map.entry("networkProfile", Map.of("networkInterfaceConfigurations", Map.ofEntries(
                    Map.entry("enableIPForwarding", true),
                    Map.entry("ipConfigurations", Map.ofEntries(
                        Map.entry("name", "{vmss-name}"),
                        Map.entry("subnet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}"))
                    )),
                    Map.entry("name", "{vmss-name}"),
                    Map.entry("primary", true)
                ))),
                Map.entry("osProfile", Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerNamePrefix", "{vmss-name}")
                )),
                Map.entry("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("diffDiskSettings", Map.of("option", "Local")),
                        Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS"))
                    ))
                ))
            ))
            .vmScaleSetName("{vmss-name}")
            .build());

    }
}
import pulumi
import pulumi_azure_native as azure_native

virtual_machine_scale_set = azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet",
    location="westus",
    overprovision=True,
    plan=azure_native.compute.PlanArgs(
        name="windows2016",
        product="windows-data-science-vm",
        publisher="microsoft-ads",
    ),
    resource_group_name="myResourceGroup",
    sku=azure_native.compute.SkuArgs(
        capacity=3,
        name="Standard_DS1_v2",
        tier="Standard",
    ),
    upgrade_policy=azure_native.compute.UpgradePolicyArgs(
        mode=azure_native.compute.UpgradeMode.MANUAL,
    ),
    virtual_machine_profile=azure_native.compute.VirtualMachineScaleSetVMProfileResponseArgs(
        network_profile={
            "networkInterfaceConfigurations": [{
                "enableIPForwarding": True,
                "ipConfigurations": [{
                    "name": "{vmss-name}",
                    "subnet": azure_native.compute.ApiEntityReferenceArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    ),
                }],
                "name": "{vmss-name}",
                "primary": True,
            }],
        },
        os_profile=azure_native.compute.VirtualMachineScaleSetOSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name_prefix="{vmss-name}",
        ),
        storage_profile={
            "imageReference": azure_native.compute.ImageReferenceArgs(
                offer="windows-data-science-vm",
                publisher="microsoft-ads",
                sku="windows2016",
                version="latest",
            ),
            "osDisk": {
                "caching": azure_native.compute.CachingTypes.READ_ONLY,
                "createOption": "FromImage",
                "diffDiskSettings": azure_native.compute.DiffDiskSettingsArgs(
                    option="Local",
                ),
                "managedDisk": azure_native.compute.VirtualMachineScaleSetManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
            },
        },
    ),
    vm_scale_set_name="{vmss-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const virtualMachineScaleSet = new azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet", {
    location: "westus",
    overprovision: true,
    plan: {
        name: "windows2016",
        product: "windows-data-science-vm",
        publisher: "microsoft-ads",
    },
    resourceGroupName: "myResourceGroup",
    sku: {
        capacity: 3,
        name: "Standard_DS1_v2",
        tier: "Standard",
    },
    upgradePolicy: {
        mode: azure_native.compute.UpgradeMode.Manual,
    },
    virtualMachineProfile: {
        networkProfile: {
            networkInterfaceConfigurations: [{
                enableIPForwarding: true,
                ipConfigurations: [{
                    name: "{vmss-name}",
                    subnet: {
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    },
                }],
                name: "{vmss-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerNamePrefix: "{vmss-name}",
        },
        storageProfile: {
            imageReference: {
                offer: "windows-data-science-vm",
                publisher: "microsoft-ads",
                sku: "windows2016",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadOnly,
                createOption: "FromImage",
                diffDiskSettings: {
                    option: "Local",
                },
                managedDisk: {
                    storageAccountType: "Standard_LRS",
                },
            },
        },
    },
    vmScaleSetName: "{vmss-name}",
});
resources:
  virtualMachineScaleSet:
    type: azure-native:compute:VirtualMachineScaleSet
    properties:
      location: westus
      overprovision: true
      plan:
        name: windows2016
        product: windows-data-science-vm
        publisher: microsoft-ads
      resourceGroupName: myResourceGroup
      sku:
        capacity: 3
        name: Standard_DS1_v2
        tier: Standard
      upgradePolicy:
        mode: Manual
      virtualMachineProfile:
        networkProfile:
          networkInterfaceConfigurations:
            - enableIPForwarding: true
              ipConfigurations:
                - name: '{vmss-name}'
                  subnet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}
              name: '{vmss-name}'
              primary: true
        osProfile:
          adminPassword: '{your-password}'
          adminUsername: '{your-username}'
          computerNamePrefix: '{vmss-name}'
        storageProfile:
          imageReference:
            offer: windows-data-science-vm
            publisher: microsoft-ads
            sku: windows2016
            version: latest
          osDisk:
            caching: ReadOnly
            createOption: FromImage
            diffDiskSettings:
              option: Local
            managedDisk:
              storageAccountType: Standard_LRS
      vmScaleSetName: '{vmss-name}'

Create a scale set with extension time budget.

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

return await Deployment.RunAsync(() => 
{
    var virtualMachineScaleSet = new AzureNative.Compute.VirtualMachineScaleSet("virtualMachineScaleSet", new()
    {
        Location = "westus",
        Overprovision = true,
        ResourceGroupName = "myResourceGroup",
        Sku = new AzureNative.Compute.Inputs.SkuArgs
        {
            Capacity = 3,
            Name = "Standard_D1_v2",
            Tier = "Standard",
        },
        UpgradePolicy = new AzureNative.Compute.Inputs.UpgradePolicyArgs
        {
            Mode = AzureNative.Compute.UpgradeMode.Manual,
        },
        VirtualMachineProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetVMProfileArgs
        {
            DiagnosticsProfile = new AzureNative.Compute.Inputs.DiagnosticsProfileArgs
            {
                BootDiagnostics = new AzureNative.Compute.Inputs.BootDiagnosticsArgs
                {
                    Enabled = true,
                    StorageUri = "http://{existing-storage-account-name}.blob.core.windows.net",
                },
            },
            ExtensionProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetExtensionProfileArgs
            {
                Extensions = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetExtensionArgs
                    {
                        AutoUpgradeMinorVersion = false,
                        Name = "{extension-name}",
                        Publisher = "{extension-Publisher}",
                        Settings = null,
                        Type = "{extension-Type}",
                        TypeHandlerVersion = "{handler-version}",
                    },
                },
                ExtensionsTimeBudget = "PT1H20M",
            },
            NetworkProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkProfileArgs
            {
                NetworkInterfaceConfigurations = new[]
                {
                    new AzureNative.Compute.Inputs.VirtualMachineScaleSetNetworkConfigurationArgs
                    {
                        EnableIPForwarding = true,
                        IpConfigurations = new[]
                        {
                            new AzureNative.Compute.Inputs.VirtualMachineScaleSetIPConfigurationArgs
                            {
                                Name = "{vmss-name}",
                                Subnet = new AzureNative.Compute.Inputs.ApiEntityReferenceArgs
                                {
                                    Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                                },
                            },
                        },
                        Name = "{vmss-name}",
                        Primary = true,
                    },
                },
            },
            OsProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSProfileArgs
            {
                AdminPassword = "{your-password}",
                AdminUsername = "{your-username}",
                ComputerNamePrefix = "{vmss-name}",
            },
            StorageProfile = new AzureNative.Compute.Inputs.VirtualMachineScaleSetStorageProfileArgs
            {
                ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
                {
                    Offer = "WindowsServer",
                    Publisher = "MicrosoftWindowsServer",
                    Sku = "2016-Datacenter",
                    Version = "latest",
                },
                OsDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetOSDiskArgs
                {
                    Caching = AzureNative.Compute.CachingTypes.ReadWrite,
                    CreateOption = "FromImage",
                    ManagedDisk = new AzureNative.Compute.Inputs.VirtualMachineScaleSetManagedDiskParametersArgs
                    {
                        StorageAccountType = "Standard_LRS",
                    },
                },
            },
        },
        VmScaleSetName = "{vmss-name}",
    });

});

Coming soon!

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachineScaleSet;
import com.pulumi.azurenative.compute.VirtualMachineScaleSetArgs;
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 virtualMachineScaleSet = new VirtualMachineScaleSet("virtualMachineScaleSet", VirtualMachineScaleSetArgs.builder()        
            .location("westus")
            .overprovision(true)
            .resourceGroupName("myResourceGroup")
            .sku(Map.ofEntries(
                Map.entry("capacity", 3),
                Map.entry("name", "Standard_D1_v2"),
                Map.entry("tier", "Standard")
            ))
            .upgradePolicy(Map.of("mode", "Manual"))
            .virtualMachineProfile(Map.ofEntries(
                Map.entry("diagnosticsProfile", Map.of("bootDiagnostics", Map.ofEntries(
                    Map.entry("enabled", true),
                    Map.entry("storageUri", "http://{existing-storage-account-name}.blob.core.windows.net")
                ))),
                Map.entry("extensionProfile", Map.ofEntries(
                    Map.entry("extensions", Map.ofEntries(
                        Map.entry("autoUpgradeMinorVersion", false),
                        Map.entry("name", "{extension-name}"),
                        Map.entry("publisher", "{extension-Publisher}"),
                        Map.entry("settings", ),
                        Map.entry("type", "{extension-Type}"),
                        Map.entry("typeHandlerVersion", "{handler-version}")
                    )),
                    Map.entry("extensionsTimeBudget", "PT1H20M")
                )),
                Map.entry("networkProfile", Map.of("networkInterfaceConfigurations", Map.ofEntries(
                    Map.entry("enableIPForwarding", true),
                    Map.entry("ipConfigurations", Map.ofEntries(
                        Map.entry("name", "{vmss-name}"),
                        Map.entry("subnet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}"))
                    )),
                    Map.entry("name", "{vmss-name}"),
                    Map.entry("primary", true)
                ))),
                Map.entry("osProfile", Map.ofEntries(
                    Map.entry("adminPassword", "{your-password}"),
                    Map.entry("adminUsername", "{your-username}"),
                    Map.entry("computerNamePrefix", "{vmss-name}")
                )),
                Map.entry("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"))
                    ))
                ))
            ))
            .vmScaleSetName("{vmss-name}")
            .build());

    }
}
import pulumi
import pulumi_azure_native as azure_native

virtual_machine_scale_set = azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet",
    location="westus",
    overprovision=True,
    resource_group_name="myResourceGroup",
    sku=azure_native.compute.SkuArgs(
        capacity=3,
        name="Standard_D1_v2",
        tier="Standard",
    ),
    upgrade_policy=azure_native.compute.UpgradePolicyArgs(
        mode=azure_native.compute.UpgradeMode.MANUAL,
    ),
    virtual_machine_profile=azure_native.compute.VirtualMachineScaleSetVMProfileResponseArgs(
        diagnostics_profile={
            "bootDiagnostics": azure_native.compute.BootDiagnosticsArgs(
                enabled=True,
                storage_uri="http://{existing-storage-account-name}.blob.core.windows.net",
            ),
        },
        extension_profile={
            "extensions": [azure_native.compute.VirtualMachineScaleSetExtensionArgs(
                auto_upgrade_minor_version=False,
                name="{extension-name}",
                publisher="{extension-Publisher}",
                settings={},
                type="{extension-Type}",
                type_handler_version="{handler-version}",
            )],
            "extensionsTimeBudget": "PT1H20M",
        },
        network_profile={
            "networkInterfaceConfigurations": [{
                "enableIPForwarding": True,
                "ipConfigurations": [{
                    "name": "{vmss-name}",
                    "subnet": azure_native.compute.ApiEntityReferenceArgs(
                        id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    ),
                }],
                "name": "{vmss-name}",
                "primary": True,
            }],
        },
        os_profile=azure_native.compute.VirtualMachineScaleSetOSProfileArgs(
            admin_password="{your-password}",
            admin_username="{your-username}",
            computer_name_prefix="{vmss-name}",
        ),
        storage_profile={
            "imageReference": azure_native.compute.ImageReferenceArgs(
                offer="WindowsServer",
                publisher="MicrosoftWindowsServer",
                sku="2016-Datacenter",
                version="latest",
            ),
            "osDisk": {
                "caching": azure_native.compute.CachingTypes.READ_WRITE,
                "createOption": "FromImage",
                "managedDisk": azure_native.compute.VirtualMachineScaleSetManagedDiskParametersArgs(
                    storage_account_type="Standard_LRS",
                ),
            },
        },
    ),
    vm_scale_set_name="{vmss-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";

const virtualMachineScaleSet = new azure_native.compute.VirtualMachineScaleSet("virtualMachineScaleSet", {
    location: "westus",
    overprovision: true,
    resourceGroupName: "myResourceGroup",
    sku: {
        capacity: 3,
        name: "Standard_D1_v2",
        tier: "Standard",
    },
    upgradePolicy: {
        mode: azure_native.compute.UpgradeMode.Manual,
    },
    virtualMachineProfile: {
        diagnosticsProfile: {
            bootDiagnostics: {
                enabled: true,
                storageUri: "http://{existing-storage-account-name}.blob.core.windows.net",
            },
        },
        extensionProfile: {
            extensions: [{
                autoUpgradeMinorVersion: false,
                name: "{extension-name}",
                publisher: "{extension-Publisher}",
                settings: {},
                type: "{extension-Type}",
                typeHandlerVersion: "{handler-version}",
            }],
            extensionsTimeBudget: "PT1H20M",
        },
        networkProfile: {
            networkInterfaceConfigurations: [{
                enableIPForwarding: true,
                ipConfigurations: [{
                    name: "{vmss-name}",
                    subnet: {
                        id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}",
                    },
                }],
                name: "{vmss-name}",
                primary: true,
            }],
        },
        osProfile: {
            adminPassword: "{your-password}",
            adminUsername: "{your-username}",
            computerNamePrefix: "{vmss-name}",
        },
        storageProfile: {
            imageReference: {
                offer: "WindowsServer",
                publisher: "MicrosoftWindowsServer",
                sku: "2016-Datacenter",
                version: "latest",
            },
            osDisk: {
                caching: azure_native.compute.CachingTypes.ReadWrite,
                createOption: "FromImage",
                managedDisk: {
                    storageAccountType: "Standard_LRS",
                },
            },
        },
    },
    vmScaleSetName: "{vmss-name}",
});
resources:
  virtualMachineScaleSet:
    type: azure-native:compute:VirtualMachineScaleSet
    properties:
      location: westus
      overprovision: true
      resourceGroupName: myResourceGroup
      sku:
        capacity: 3
        name: Standard_D1_v2
        tier: Standard
      upgradePolicy:
        mode: Manual
      virtualMachineProfile:
        diagnosticsProfile:
          bootDiagnostics:
            enabled: true
            storageUri: http://{existing-storage-account-name}.blob.core.windows.net
        extensionProfile:
          extensions:
            - autoUpgradeMinorVersion: false
              name: '{extension-name}'
              publisher: '{extension-Publisher}'
              settings: {}
              type: '{extension-Type}'
              typeHandlerVersion: '{handler-version}'
          extensionsTimeBudget: PT1H20M
        networkProfile:
          networkInterfaceConfigurations:
            - enableIPForwarding: true
              ipConfigurations:
                - name: '{vmss-name}'
                  subnet:
                    id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/virtualNetworks/{existing-virtual-network-name}/subnets/{existing-subnet-name}
              name: '{vmss-name}'
              primary: true
        osProfile:
          adminPassword: '{your-password}'
          adminUsername: '{your-username}'
          computerNamePrefix: '{vmss-name}'
        storageProfile:
          imageReference:
            offer: WindowsServer
            publisher: