This is the latest version of Azure Native. Use the Azure Native v1 docs if using the v1 version of this package.
Azure Native v2.9.0 published on Wednesday, Sep 27, 2023 by Pulumi
azure-native.compute.VirtualMachine
Explore with Pulumi AI
This is the latest version of Azure Native. Use the Azure Native v1 docs if using the v1 version of this package.
Azure Native v2.9.0 published on Wednesday, Sep 27, 2023 by Pulumi
Describes a Virtual Machine. Azure REST API version: 2023-03-01. Prior API version in Azure Native 1.x: 2021-03-01
Example Usage
Create a Linux vm with a patch setting assessmentMode of ImageDefault.
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D2s_v3",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
LinuxConfiguration = new AzureNative.Compute.Inputs.LinuxConfigurationArgs
{
PatchSettings = new AzureNative.Compute.Inputs.LinuxPatchSettingsArgs
{
AssessmentMode = "ImageDefault",
},
ProvisionVMAgent = true,
},
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "UbuntuServer",
Publisher = "Canonical",
Sku = "16.04-LTS",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Premium_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := compute.NewVirtualMachine(ctx, "virtualMachine", &compute.VirtualMachineArgs{
HardwareProfile: &compute.HardwareProfileArgs{
VmSize: pulumi.String("Standard_D2s_v3"),
},
Location: pulumi.String("westus"),
NetworkProfile: compute.NetworkProfileResponse{
NetworkInterfaces: compute.NetworkInterfaceReferenceArray{
&compute.NetworkInterfaceReferenceArgs{
Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Primary: pulumi.Bool(true),
},
},
},
OsProfile: compute.OSProfileResponse{
AdminPassword: pulumi.String("{your-password}"),
AdminUsername: pulumi.String("{your-username}"),
ComputerName: pulumi.String("myVM"),
LinuxConfiguration: interface{}{
PatchSettings: &compute.LinuxPatchSettingsArgs{
AssessmentMode: pulumi.String("ImageDefault"),
},
ProvisionVMAgent: pulumi.Bool(true),
},
},
ResourceGroupName: pulumi.String("myResourceGroup"),
StorageProfile: compute.StorageProfileResponse{
ImageReference: &compute.ImageReferenceArgs{
Offer: pulumi.String("UbuntuServer"),
Publisher: pulumi.String("Canonical"),
Sku: pulumi.String("16.04-LTS"),
Version: pulumi.String("latest"),
},
OsDisk: interface{}{
Caching: compute.CachingTypesReadWrite,
CreateOption: pulumi.String("FromImage"),
ManagedDisk: &compute.ManagedDiskParametersArgs{
StorageAccountType: pulumi.String("Premium_LRS"),
},
Name: pulumi.String("myVMosdisk"),
},
},
VmName: pulumi.String("myVM"),
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D2s_v3"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM"),
Map.entry("linuxConfiguration", Map.ofEntries(
Map.entry("patchSettings", Map.of("assessmentMode", "ImageDefault")),
Map.entry("provisionVMAgent", true)
))
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "UbuntuServer"),
Map.entry("publisher", "Canonical"),
Map.entry("sku", "16.04-LTS"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D2s_v3",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileResponseArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
linux_configuration={
"patchSettings": azure_native.compute.LinuxPatchSettingsArgs(
assessment_mode="ImageDefault",
),
"provisionVMAgent": True,
},
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="UbuntuServer",
publisher="Canonical",
sku="16.04-LTS",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Premium_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D2s_v3",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
linuxConfiguration: {
patchSettings: {
assessmentMode: "ImageDefault",
},
provisionVMAgent: true,
},
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "UbuntuServer",
publisher: "Canonical",
sku: "16.04-LTS",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Premium_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D2s_v3
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
linuxConfiguration:
patchSettings:
assessmentMode: ImageDefault
provisionVMAgent: true
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: UbuntuServer
publisher: Canonical
sku: 16.04-LTS
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Premium_LRS
name: myVMosdisk
vmName: myVM
Create a Linux vm with a patch setting patchMode of AutomaticByPlatform and AutomaticByPlatformSettings.
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D2s_v3",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
LinuxConfiguration = new AzureNative.Compute.Inputs.LinuxConfigurationArgs
{
PatchSettings = new AzureNative.Compute.Inputs.LinuxPatchSettingsArgs
{
AssessmentMode = "AutomaticByPlatform",
AutomaticByPlatformSettings = new AzureNative.Compute.Inputs.LinuxVMGuestPatchAutomaticByPlatformSettingsArgs
{
BypassPlatformSafetyChecksOnUserSchedule = true,
RebootSetting = "Never",
},
PatchMode = "AutomaticByPlatform",
},
ProvisionVMAgent = true,
},
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "UbuntuServer",
Publisher = "Canonical",
Sku = "16.04-LTS",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Premium_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := compute.NewVirtualMachine(ctx, "virtualMachine", &compute.VirtualMachineArgs{
HardwareProfile: &compute.HardwareProfileArgs{
VmSize: pulumi.String("Standard_D2s_v3"),
},
Location: pulumi.String("westus"),
NetworkProfile: compute.NetworkProfileResponse{
NetworkInterfaces: compute.NetworkInterfaceReferenceArray{
&compute.NetworkInterfaceReferenceArgs{
Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Primary: pulumi.Bool(true),
},
},
},
OsProfile: compute.OSProfileResponse{
AdminPassword: pulumi.String("{your-password}"),
AdminUsername: pulumi.String("{your-username}"),
ComputerName: pulumi.String("myVM"),
LinuxConfiguration: interface{}{
PatchSettings: interface{}{
AssessmentMode: pulumi.String("AutomaticByPlatform"),
AutomaticByPlatformSettings: &compute.LinuxVMGuestPatchAutomaticByPlatformSettingsArgs{
BypassPlatformSafetyChecksOnUserSchedule: pulumi.Bool(true),
RebootSetting: pulumi.String("Never"),
},
PatchMode: pulumi.String("AutomaticByPlatform"),
},
ProvisionVMAgent: pulumi.Bool(true),
},
},
ResourceGroupName: pulumi.String("myResourceGroup"),
StorageProfile: compute.StorageProfileResponse{
ImageReference: &compute.ImageReferenceArgs{
Offer: pulumi.String("UbuntuServer"),
Publisher: pulumi.String("Canonical"),
Sku: pulumi.String("16.04-LTS"),
Version: pulumi.String("latest"),
},
OsDisk: interface{}{
Caching: compute.CachingTypesReadWrite,
CreateOption: pulumi.String("FromImage"),
ManagedDisk: &compute.ManagedDiskParametersArgs{
StorageAccountType: pulumi.String("Premium_LRS"),
},
Name: pulumi.String("myVMosdisk"),
},
},
VmName: pulumi.String("myVM"),
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D2s_v3"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM"),
Map.entry("linuxConfiguration", Map.ofEntries(
Map.entry("patchSettings", Map.ofEntries(
Map.entry("assessmentMode", "AutomaticByPlatform"),
Map.entry("automaticByPlatformSettings", Map.ofEntries(
Map.entry("bypassPlatformSafetyChecksOnUserSchedule", true),
Map.entry("rebootSetting", "Never")
)),
Map.entry("patchMode", "AutomaticByPlatform")
)),
Map.entry("provisionVMAgent", true)
))
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "UbuntuServer"),
Map.entry("publisher", "Canonical"),
Map.entry("sku", "16.04-LTS"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D2s_v3",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileResponseArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
linux_configuration={
"patchSettings": {
"assessmentMode": "AutomaticByPlatform",
"automaticByPlatformSettings": azure_native.compute.LinuxVMGuestPatchAutomaticByPlatformSettingsArgs(
bypass_platform_safety_checks_on_user_schedule=True,
reboot_setting="Never",
),
"patchMode": "AutomaticByPlatform",
},
"provisionVMAgent": True,
},
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="UbuntuServer",
publisher="Canonical",
sku="16.04-LTS",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Premium_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D2s_v3",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
linuxConfiguration: {
patchSettings: {
assessmentMode: "AutomaticByPlatform",
automaticByPlatformSettings: {
bypassPlatformSafetyChecksOnUserSchedule: true,
rebootSetting: "Never",
},
patchMode: "AutomaticByPlatform",
},
provisionVMAgent: true,
},
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "UbuntuServer",
publisher: "Canonical",
sku: "16.04-LTS",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Premium_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D2s_v3
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
linuxConfiguration:
patchSettings:
assessmentMode: AutomaticByPlatform
automaticByPlatformSettings:
bypassPlatformSafetyChecksOnUserSchedule: true
rebootSetting: Never
patchMode: AutomaticByPlatform
provisionVMAgent: true
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: UbuntuServer
publisher: Canonical
sku: 16.04-LTS
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Premium_LRS
name: myVMosdisk
vmName: myVM
Create a Linux vm with a patch setting patchMode of ImageDefault.
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D2s_v3",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
LinuxConfiguration = new AzureNative.Compute.Inputs.LinuxConfigurationArgs
{
PatchSettings = new AzureNative.Compute.Inputs.LinuxPatchSettingsArgs
{
PatchMode = "ImageDefault",
},
ProvisionVMAgent = true,
},
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "UbuntuServer",
Publisher = "Canonical",
Sku = "16.04-LTS",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Premium_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := compute.NewVirtualMachine(ctx, "virtualMachine", &compute.VirtualMachineArgs{
HardwareProfile: &compute.HardwareProfileArgs{
VmSize: pulumi.String("Standard_D2s_v3"),
},
Location: pulumi.String("westus"),
NetworkProfile: compute.NetworkProfileResponse{
NetworkInterfaces: compute.NetworkInterfaceReferenceArray{
&compute.NetworkInterfaceReferenceArgs{
Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Primary: pulumi.Bool(true),
},
},
},
OsProfile: compute.OSProfileResponse{
AdminPassword: pulumi.String("{your-password}"),
AdminUsername: pulumi.String("{your-username}"),
ComputerName: pulumi.String("myVM"),
LinuxConfiguration: interface{}{
PatchSettings: &compute.LinuxPatchSettingsArgs{
PatchMode: pulumi.String("ImageDefault"),
},
ProvisionVMAgent: pulumi.Bool(true),
},
},
ResourceGroupName: pulumi.String("myResourceGroup"),
StorageProfile: compute.StorageProfileResponse{
ImageReference: &compute.ImageReferenceArgs{
Offer: pulumi.String("UbuntuServer"),
Publisher: pulumi.String("Canonical"),
Sku: pulumi.String("16.04-LTS"),
Version: pulumi.String("latest"),
},
OsDisk: interface{}{
Caching: compute.CachingTypesReadWrite,
CreateOption: pulumi.String("FromImage"),
ManagedDisk: &compute.ManagedDiskParametersArgs{
StorageAccountType: pulumi.String("Premium_LRS"),
},
Name: pulumi.String("myVMosdisk"),
},
},
VmName: pulumi.String("myVM"),
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D2s_v3"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM"),
Map.entry("linuxConfiguration", Map.ofEntries(
Map.entry("patchSettings", Map.of("patchMode", "ImageDefault")),
Map.entry("provisionVMAgent", true)
))
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "UbuntuServer"),
Map.entry("publisher", "Canonical"),
Map.entry("sku", "16.04-LTS"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D2s_v3",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileResponseArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
linux_configuration={
"patchSettings": azure_native.compute.LinuxPatchSettingsArgs(
patch_mode="ImageDefault",
),
"provisionVMAgent": True,
},
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="UbuntuServer",
publisher="Canonical",
sku="16.04-LTS",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Premium_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D2s_v3",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
linuxConfiguration: {
patchSettings: {
patchMode: "ImageDefault",
},
provisionVMAgent: true,
},
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "UbuntuServer",
publisher: "Canonical",
sku: "16.04-LTS",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Premium_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D2s_v3
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
linuxConfiguration:
patchSettings:
patchMode: ImageDefault
provisionVMAgent: true
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: UbuntuServer
publisher: Canonical
sku: 16.04-LTS
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Premium_LRS
name: myVMosdisk
vmName: myVM
Create a Linux vm with a patch settings patchMode and assessmentMode set to AutomaticByPlatform.
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D2s_v3",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
LinuxConfiguration = new AzureNative.Compute.Inputs.LinuxConfigurationArgs
{
PatchSettings = new AzureNative.Compute.Inputs.LinuxPatchSettingsArgs
{
AssessmentMode = "AutomaticByPlatform",
PatchMode = "AutomaticByPlatform",
},
ProvisionVMAgent = true,
},
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "UbuntuServer",
Publisher = "Canonical",
Sku = "16.04-LTS",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Premium_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := compute.NewVirtualMachine(ctx, "virtualMachine", &compute.VirtualMachineArgs{
HardwareProfile: &compute.HardwareProfileArgs{
VmSize: pulumi.String("Standard_D2s_v3"),
},
Location: pulumi.String("westus"),
NetworkProfile: compute.NetworkProfileResponse{
NetworkInterfaces: compute.NetworkInterfaceReferenceArray{
&compute.NetworkInterfaceReferenceArgs{
Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Primary: pulumi.Bool(true),
},
},
},
OsProfile: compute.OSProfileResponse{
AdminPassword: pulumi.String("{your-password}"),
AdminUsername: pulumi.String("{your-username}"),
ComputerName: pulumi.String("myVM"),
LinuxConfiguration: interface{}{
PatchSettings: &compute.LinuxPatchSettingsArgs{
AssessmentMode: pulumi.String("AutomaticByPlatform"),
PatchMode: pulumi.String("AutomaticByPlatform"),
},
ProvisionVMAgent: pulumi.Bool(true),
},
},
ResourceGroupName: pulumi.String("myResourceGroup"),
StorageProfile: compute.StorageProfileResponse{
ImageReference: &compute.ImageReferenceArgs{
Offer: pulumi.String("UbuntuServer"),
Publisher: pulumi.String("Canonical"),
Sku: pulumi.String("16.04-LTS"),
Version: pulumi.String("latest"),
},
OsDisk: interface{}{
Caching: compute.CachingTypesReadWrite,
CreateOption: pulumi.String("FromImage"),
ManagedDisk: &compute.ManagedDiskParametersArgs{
StorageAccountType: pulumi.String("Premium_LRS"),
},
Name: pulumi.String("myVMosdisk"),
},
},
VmName: pulumi.String("myVM"),
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D2s_v3"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM"),
Map.entry("linuxConfiguration", Map.ofEntries(
Map.entry("patchSettings", Map.ofEntries(
Map.entry("assessmentMode", "AutomaticByPlatform"),
Map.entry("patchMode", "AutomaticByPlatform")
)),
Map.entry("provisionVMAgent", true)
))
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "UbuntuServer"),
Map.entry("publisher", "Canonical"),
Map.entry("sku", "16.04-LTS"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D2s_v3",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileResponseArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
linux_configuration={
"patchSettings": azure_native.compute.LinuxPatchSettingsArgs(
assessment_mode="AutomaticByPlatform",
patch_mode="AutomaticByPlatform",
),
"provisionVMAgent": True,
},
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="UbuntuServer",
publisher="Canonical",
sku="16.04-LTS",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Premium_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D2s_v3",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
linuxConfiguration: {
patchSettings: {
assessmentMode: "AutomaticByPlatform",
patchMode: "AutomaticByPlatform",
},
provisionVMAgent: true,
},
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "UbuntuServer",
publisher: "Canonical",
sku: "16.04-LTS",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Premium_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D2s_v3
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
linuxConfiguration:
patchSettings:
assessmentMode: AutomaticByPlatform
patchMode: AutomaticByPlatform
provisionVMAgent: true
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: UbuntuServer
publisher: Canonical
sku: 16.04-LTS
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Premium_LRS
name: myVMosdisk
vmName: myVM
Create a VM from a community gallery image
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
CommunityGalleryImageId = "/CommunityGalleries/galleryPublicName/Images/communityGalleryImageName/Versions/communityGalleryImageVersionName",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Standard_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := compute.NewVirtualMachine(ctx, "virtualMachine", &compute.VirtualMachineArgs{
HardwareProfile: &compute.HardwareProfileArgs{
VmSize: pulumi.String("Standard_D1_v2"),
},
Location: pulumi.String("westus"),
NetworkProfile: compute.NetworkProfileResponse{
NetworkInterfaces: compute.NetworkInterfaceReferenceArray{
&compute.NetworkInterfaceReferenceArgs{
Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Primary: pulumi.Bool(true),
},
},
},
OsProfile: &compute.OSProfileArgs{
AdminPassword: pulumi.String("{your-password}"),
AdminUsername: pulumi.String("{your-username}"),
ComputerName: pulumi.String("myVM"),
},
ResourceGroupName: pulumi.String("myResourceGroup"),
StorageProfile: compute.StorageProfileResponse{
ImageReference: &compute.ImageReferenceArgs{
CommunityGalleryImageId: pulumi.String("/CommunityGalleries/galleryPublicName/Images/communityGalleryImageName/Versions/communityGalleryImageVersionName"),
},
OsDisk: interface{}{
Caching: compute.CachingTypesReadWrite,
CreateOption: pulumi.String("FromImage"),
ManagedDisk: &compute.ManagedDiskParametersArgs{
StorageAccountType: pulumi.String("Standard_LRS"),
},
Name: pulumi.String("myVMosdisk"),
},
},
VmName: pulumi.String("myVM"),
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.of("communityGalleryImageId", "/CommunityGalleries/galleryPublicName/Images/communityGalleryImageName/Versions/communityGalleryImageVersionName")),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
community_gallery_image_id="/CommunityGalleries/galleryPublicName/Images/communityGalleryImageName/Versions/communityGalleryImageVersionName",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Standard_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
communityGalleryImageId: "/CommunityGalleries/galleryPublicName/Images/communityGalleryImageName/Versions/communityGalleryImageVersionName",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Standard_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
communityGalleryImageId: /CommunityGalleries/galleryPublicName/Images/communityGalleryImageName/Versions/communityGalleryImageVersionName
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Standard_LRS
name: myVMosdisk
vmName: myVM
Create a VM from a shared gallery image
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
SharedGalleryImageId = "/SharedGalleries/sharedGalleryName/Images/sharedGalleryImageName/Versions/sharedGalleryImageVersionName",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Standard_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := compute.NewVirtualMachine(ctx, "virtualMachine", &compute.VirtualMachineArgs{
HardwareProfile: &compute.HardwareProfileArgs{
VmSize: pulumi.String("Standard_D1_v2"),
},
Location: pulumi.String("westus"),
NetworkProfile: compute.NetworkProfileResponse{
NetworkInterfaces: compute.NetworkInterfaceReferenceArray{
&compute.NetworkInterfaceReferenceArgs{
Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Primary: pulumi.Bool(true),
},
},
},
OsProfile: &compute.OSProfileArgs{
AdminPassword: pulumi.String("{your-password}"),
AdminUsername: pulumi.String("{your-username}"),
ComputerName: pulumi.String("myVM"),
},
ResourceGroupName: pulumi.String("myResourceGroup"),
StorageProfile: compute.StorageProfileResponse{
ImageReference: &compute.ImageReferenceArgs{
SharedGalleryImageId: pulumi.String("/SharedGalleries/sharedGalleryName/Images/sharedGalleryImageName/Versions/sharedGalleryImageVersionName"),
},
OsDisk: interface{}{
Caching: compute.CachingTypesReadWrite,
CreateOption: pulumi.String("FromImage"),
ManagedDisk: &compute.ManagedDiskParametersArgs{
StorageAccountType: pulumi.String("Standard_LRS"),
},
Name: pulumi.String("myVMosdisk"),
},
},
VmName: pulumi.String("myVM"),
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.of("sharedGalleryImageId", "/SharedGalleries/sharedGalleryName/Images/sharedGalleryImageName/Versions/sharedGalleryImageVersionName")),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
shared_gallery_image_id="/SharedGalleries/sharedGalleryName/Images/sharedGalleryImageName/Versions/sharedGalleryImageVersionName",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Standard_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
sharedGalleryImageId: "/SharedGalleries/sharedGalleryName/Images/sharedGalleryImageName/Versions/sharedGalleryImageVersionName",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Standard_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
sharedGalleryImageId: /SharedGalleries/sharedGalleryName/Images/sharedGalleryImageName/Versions/sharedGalleryImageVersionName
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Standard_LRS
name: myVMosdisk
vmName: myVM
Create a VM with Disk Controller Type
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
DiagnosticsProfile = new AzureNative.Compute.Inputs.DiagnosticsProfileArgs
{
BootDiagnostics = new AzureNative.Compute.Inputs.BootDiagnosticsArgs
{
Enabled = true,
StorageUri = "http://{existing-storage-account-name}.blob.core.windows.net",
},
},
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D4_v3",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
DiskControllerType = "NVMe",
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Standard_LRS",
},
Name = "myVMosdisk",
},
},
UserData = "U29tZSBDdXN0b20gRGF0YQ==",
VmName = "myVM",
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := compute.NewVirtualMachine(ctx, "virtualMachine", &compute.VirtualMachineArgs{
DiagnosticsProfile: compute.DiagnosticsProfileResponse{
BootDiagnostics: &compute.BootDiagnosticsArgs{
Enabled: pulumi.Bool(true),
StorageUri: pulumi.String("http://{existing-storage-account-name}.blob.core.windows.net"),
},
},
HardwareProfile: &compute.HardwareProfileArgs{
VmSize: pulumi.String("Standard_D4_v3"),
},
Location: pulumi.String("westus"),
NetworkProfile: compute.NetworkProfileResponse{
NetworkInterfaces: compute.NetworkInterfaceReferenceArray{
&compute.NetworkInterfaceReferenceArgs{
Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Primary: pulumi.Bool(true),
},
},
},
OsProfile: &compute.OSProfileArgs{
AdminPassword: pulumi.String("{your-password}"),
AdminUsername: pulumi.String("{your-username}"),
ComputerName: pulumi.String("myVM"),
},
ResourceGroupName: pulumi.String("myResourceGroup"),
StorageProfile: compute.StorageProfileResponse{
DiskControllerType: pulumi.String("NVMe"),
ImageReference: &compute.ImageReferenceArgs{
Offer: pulumi.String("WindowsServer"),
Publisher: pulumi.String("MicrosoftWindowsServer"),
Sku: pulumi.String("2016-Datacenter"),
Version: pulumi.String("latest"),
},
OsDisk: interface{}{
Caching: compute.CachingTypesReadWrite,
CreateOption: pulumi.String("FromImage"),
ManagedDisk: &compute.ManagedDiskParametersArgs{
StorageAccountType: pulumi.String("Standard_LRS"),
},
Name: pulumi.String("myVMosdisk"),
},
},
UserData: pulumi.String("U29tZSBDdXN0b20gRGF0YQ=="),
VmName: pulumi.String("myVM"),
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.diagnosticsProfile(Map.of("bootDiagnostics", Map.ofEntries(
Map.entry("enabled", true),
Map.entry("storageUri", "http://{existing-storage-account-name}.blob.core.windows.net")
)))
.hardwareProfile(Map.of("vmSize", "Standard_D4_v3"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("diskControllerType", "NVMe"),
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2016-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.userData("U29tZSBDdXN0b20gRGF0YQ==")
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
diagnostics_profile=azure_native.compute.DiagnosticsProfileResponseArgs(
boot_diagnostics=azure_native.compute.BootDiagnosticsArgs(
enabled=True,
storage_uri="http://{existing-storage-account-name}.blob.core.windows.net",
),
),
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D4_v3",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
disk_controller_type="NVMe",
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2016-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Standard_LRS",
),
"name": "myVMosdisk",
},
),
user_data="U29tZSBDdXN0b20gRGF0YQ==",
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
diagnosticsProfile: {
bootDiagnostics: {
enabled: true,
storageUri: "http://{existing-storage-account-name}.blob.core.windows.net",
},
},
hardwareProfile: {
vmSize: "Standard_D4_v3",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
resourceGroupName: "myResourceGroup",
storageProfile: {
diskControllerType: "NVMe",
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2016-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Standard_LRS",
},
name: "myVMosdisk",
},
},
userData: "U29tZSBDdXN0b20gRGF0YQ==",
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
diagnosticsProfile:
bootDiagnostics:
enabled: true
storageUri: http://{existing-storage-account-name}.blob.core.windows.net
hardwareProfile:
vmSize: Standard_D4_v3
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
resourceGroupName: myResourceGroup
storageProfile:
diskControllerType: NVMe
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2016-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Standard_LRS
name: myVMosdisk
userData: U29tZSBDdXN0b20gRGF0YQ==
vmName: myVM
Create a VM with HibernationEnabled
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
AdditionalCapabilities = new AzureNative.Compute.Inputs.AdditionalCapabilitiesArgs
{
HibernationEnabled = true,
},
DiagnosticsProfile = new AzureNative.Compute.Inputs.DiagnosticsProfileArgs
{
BootDiagnostics = new AzureNative.Compute.Inputs.BootDiagnosticsArgs
{
Enabled = true,
StorageUri = "http://{existing-storage-account-name}.blob.core.windows.net",
},
},
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D2s_v3",
},
Location = "eastus2euap",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "{vm-name}",
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2019-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Standard_LRS",
},
Name = "vmOSdisk",
},
},
VmName = "{vm-name}",
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := compute.NewVirtualMachine(ctx, "virtualMachine", &compute.VirtualMachineArgs{
AdditionalCapabilities: &compute.AdditionalCapabilitiesArgs{
HibernationEnabled: pulumi.Bool(true),
},
DiagnosticsProfile: compute.DiagnosticsProfileResponse{
BootDiagnostics: &compute.BootDiagnosticsArgs{
Enabled: pulumi.Bool(true),
StorageUri: pulumi.String("http://{existing-storage-account-name}.blob.core.windows.net"),
},
},
HardwareProfile: &compute.HardwareProfileArgs{
VmSize: pulumi.String("Standard_D2s_v3"),
},
Location: pulumi.String("eastus2euap"),
NetworkProfile: compute.NetworkProfileResponse{
NetworkInterfaces: compute.NetworkInterfaceReferenceArray{
&compute.NetworkInterfaceReferenceArgs{
Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Primary: pulumi.Bool(true),
},
},
},
OsProfile: &compute.OSProfileArgs{
AdminPassword: pulumi.String("{your-password}"),
AdminUsername: pulumi.String("{your-username}"),
ComputerName: pulumi.String("{vm-name}"),
},
ResourceGroupName: pulumi.String("myResourceGroup"),
StorageProfile: compute.StorageProfileResponse{
ImageReference: &compute.ImageReferenceArgs{
Offer: pulumi.String("WindowsServer"),
Publisher: pulumi.String("MicrosoftWindowsServer"),
Sku: pulumi.String("2019-Datacenter"),
Version: pulumi.String("latest"),
},
OsDisk: interface{}{
Caching: compute.CachingTypesReadWrite,
CreateOption: pulumi.String("FromImage"),
ManagedDisk: &compute.ManagedDiskParametersArgs{
StorageAccountType: pulumi.String("Standard_LRS"),
},
Name: pulumi.String("vmOSdisk"),
},
},
VmName: pulumi.String("{vm-name}"),
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.additionalCapabilities(Map.of("hibernationEnabled", true))
.diagnosticsProfile(Map.of("bootDiagnostics", Map.ofEntries(
Map.entry("enabled", true),
Map.entry("storageUri", "http://{existing-storage-account-name}.blob.core.windows.net")
)))
.hardwareProfile(Map.of("vmSize", "Standard_D2s_v3"))
.location("eastus2euap")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "{vm-name}")
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2019-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
Map.entry("name", "vmOSdisk")
))
))
.vmName("{vm-name}")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
additional_capabilities=azure_native.compute.AdditionalCapabilitiesArgs(
hibernation_enabled=True,
),
diagnostics_profile=azure_native.compute.DiagnosticsProfileResponseArgs(
boot_diagnostics=azure_native.compute.BootDiagnosticsArgs(
enabled=True,
storage_uri="http://{existing-storage-account-name}.blob.core.windows.net",
),
),
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D2s_v3",
),
location="eastus2euap",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="{vm-name}",
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2019-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Standard_LRS",
),
"name": "vmOSdisk",
},
),
vm_name="{vm-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
additionalCapabilities: {
hibernationEnabled: true,
},
diagnosticsProfile: {
bootDiagnostics: {
enabled: true,
storageUri: "http://{existing-storage-account-name}.blob.core.windows.net",
},
},
hardwareProfile: {
vmSize: "Standard_D2s_v3",
},
location: "eastus2euap",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "{vm-name}",
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2019-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Standard_LRS",
},
name: "vmOSdisk",
},
},
vmName: "{vm-name}",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
additionalCapabilities:
hibernationEnabled: true
diagnosticsProfile:
bootDiagnostics:
enabled: true
storageUri: http://{existing-storage-account-name}.blob.core.windows.net
hardwareProfile:
vmSize: Standard_D2s_v3
location: eastus2euap
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: '{vm-name}'
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2019-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Standard_LRS
name: vmOSdisk
vmName: '{vm-name}'
Create a VM with Uefi Settings of secureBoot and vTPM.
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D2s_v3",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
ResourceGroupName = "myResourceGroup",
SecurityProfile = new AzureNative.Compute.Inputs.SecurityProfileArgs
{
SecurityType = "TrustedLaunch",
UefiSettings = new AzureNative.Compute.Inputs.UefiSettingsArgs
{
SecureBootEnabled = true,
VTpmEnabled = true,
},
},
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "windowsserver-gen2preview-preview",
Publisher = "MicrosoftWindowsServer",
Sku = "windows10-tvm",
Version = "18363.592.2001092016",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadOnly,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "StandardSSD_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := compute.NewVirtualMachine(ctx, "virtualMachine", &compute.VirtualMachineArgs{
HardwareProfile: &compute.HardwareProfileArgs{
VmSize: pulumi.String("Standard_D2s_v3"),
},
Location: pulumi.String("westus"),
NetworkProfile: compute.NetworkProfileResponse{
NetworkInterfaces: compute.NetworkInterfaceReferenceArray{
&compute.NetworkInterfaceReferenceArgs{
Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Primary: pulumi.Bool(true),
},
},
},
OsProfile: &compute.OSProfileArgs{
AdminPassword: pulumi.String("{your-password}"),
AdminUsername: pulumi.String("{your-username}"),
ComputerName: pulumi.String("myVM"),
},
ResourceGroupName: pulumi.String("myResourceGroup"),
SecurityProfile: compute.SecurityProfileResponse{
SecurityType: pulumi.String("TrustedLaunch"),
UefiSettings: &compute.UefiSettingsArgs{
SecureBootEnabled: pulumi.Bool(true),
VTpmEnabled: pulumi.Bool(true),
},
},
StorageProfile: compute.StorageProfileResponse{
ImageReference: &compute.ImageReferenceArgs{
Offer: pulumi.String("windowsserver-gen2preview-preview"),
Publisher: pulumi.String("MicrosoftWindowsServer"),
Sku: pulumi.String("windows10-tvm"),
Version: pulumi.String("18363.592.2001092016"),
},
OsDisk: interface{}{
Caching: compute.CachingTypesReadOnly,
CreateOption: pulumi.String("FromImage"),
ManagedDisk: &compute.ManagedDiskParametersArgs{
StorageAccountType: pulumi.String("StandardSSD_LRS"),
},
Name: pulumi.String("myVMosdisk"),
},
},
VmName: pulumi.String("myVM"),
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D2s_v3"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.resourceGroupName("myResourceGroup")
.securityProfile(Map.ofEntries(
Map.entry("securityType", "TrustedLaunch"),
Map.entry("uefiSettings", Map.ofEntries(
Map.entry("secureBootEnabled", true),
Map.entry("vTpmEnabled", true)
))
))
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "windowsserver-gen2preview-preview"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "windows10-tvm"),
Map.entry("version", "18363.592.2001092016")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadOnly"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "StandardSSD_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D2s_v3",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
resource_group_name="myResourceGroup",
security_profile=azure_native.compute.SecurityProfileResponseArgs(
security_type="TrustedLaunch",
uefi_settings=azure_native.compute.UefiSettingsArgs(
secure_boot_enabled=True,
v_tpm_enabled=True,
),
),
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="windowsserver-gen2preview-preview",
publisher="MicrosoftWindowsServer",
sku="windows10-tvm",
version="18363.592.2001092016",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_ONLY,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="StandardSSD_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D2s_v3",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
resourceGroupName: "myResourceGroup",
securityProfile: {
securityType: "TrustedLaunch",
uefiSettings: {
secureBootEnabled: true,
vTpmEnabled: true,
},
},
storageProfile: {
imageReference: {
offer: "windowsserver-gen2preview-preview",
publisher: "MicrosoftWindowsServer",
sku: "windows10-tvm",
version: "18363.592.2001092016",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadOnly,
createOption: "FromImage",
managedDisk: {
storageAccountType: "StandardSSD_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D2s_v3
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
resourceGroupName: myResourceGroup
securityProfile:
securityType: TrustedLaunch
uefiSettings:
secureBootEnabled: true
vTpmEnabled: true
storageProfile:
imageReference:
offer: windowsserver-gen2preview-preview
publisher: MicrosoftWindowsServer
sku: windows10-tvm
version: 18363.592.2001092016
osDisk:
caching: ReadOnly
createOption: FromImage
managedDisk:
storageAccountType: StandardSSD_LRS
name: myVMosdisk
vmName: myVM
Create a VM with UserData
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
DiagnosticsProfile = new AzureNative.Compute.Inputs.DiagnosticsProfileArgs
{
BootDiagnostics = new AzureNative.Compute.Inputs.BootDiagnosticsArgs
{
Enabled = true,
StorageUri = "http://{existing-storage-account-name}.blob.core.windows.net",
},
},
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "{vm-name}",
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Standard_LRS",
},
Name = "vmOSdisk",
},
},
UserData = "RXhhbXBsZSBVc2VyRGF0YQ==",
VmName = "{vm-name}",
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := compute.NewVirtualMachine(ctx, "virtualMachine", &compute.VirtualMachineArgs{
DiagnosticsProfile: compute.DiagnosticsProfileResponse{
BootDiagnostics: &compute.BootDiagnosticsArgs{
Enabled: pulumi.Bool(true),
StorageUri: pulumi.String("http://{existing-storage-account-name}.blob.core.windows.net"),
},
},
HardwareProfile: &compute.HardwareProfileArgs{
VmSize: pulumi.String("Standard_D1_v2"),
},
Location: pulumi.String("westus"),
NetworkProfile: compute.NetworkProfileResponse{
NetworkInterfaces: compute.NetworkInterfaceReferenceArray{
&compute.NetworkInterfaceReferenceArgs{
Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Primary: pulumi.Bool(true),
},
},
},
OsProfile: &compute.OSProfileArgs{
AdminPassword: pulumi.String("{your-password}"),
AdminUsername: pulumi.String("{your-username}"),
ComputerName: pulumi.String("{vm-name}"),
},
ResourceGroupName: pulumi.String("myResourceGroup"),
StorageProfile: compute.StorageProfileResponse{
ImageReference: &compute.ImageReferenceArgs{
Offer: pulumi.String("WindowsServer"),
Publisher: pulumi.String("MicrosoftWindowsServer"),
Sku: pulumi.String("2016-Datacenter"),
Version: pulumi.String("latest"),
},
OsDisk: interface{}{
Caching: compute.CachingTypesReadWrite,
CreateOption: pulumi.String("FromImage"),
ManagedDisk: &compute.ManagedDiskParametersArgs{
StorageAccountType: pulumi.String("Standard_LRS"),
},
Name: pulumi.String("vmOSdisk"),
},
},
UserData: pulumi.String("RXhhbXBsZSBVc2VyRGF0YQ=="),
VmName: pulumi.String("{vm-name}"),
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.diagnosticsProfile(Map.of("bootDiagnostics", Map.ofEntries(
Map.entry("enabled", true),
Map.entry("storageUri", "http://{existing-storage-account-name}.blob.core.windows.net")
)))
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "{vm-name}")
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2016-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
Map.entry("name", "vmOSdisk")
))
))
.userData("RXhhbXBsZSBVc2VyRGF0YQ==")
.vmName("{vm-name}")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
diagnostics_profile=azure_native.compute.DiagnosticsProfileResponseArgs(
boot_diagnostics=azure_native.compute.BootDiagnosticsArgs(
enabled=True,
storage_uri="http://{existing-storage-account-name}.blob.core.windows.net",
),
),
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="{vm-name}",
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2016-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Standard_LRS",
),
"name": "vmOSdisk",
},
),
user_data="RXhhbXBsZSBVc2VyRGF0YQ==",
vm_name="{vm-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
diagnosticsProfile: {
bootDiagnostics: {
enabled: true,
storageUri: "http://{existing-storage-account-name}.blob.core.windows.net",
},
},
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "{vm-name}",
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2016-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Standard_LRS",
},
name: "vmOSdisk",
},
},
userData: "RXhhbXBsZSBVc2VyRGF0YQ==",
vmName: "{vm-name}",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
diagnosticsProfile:
bootDiagnostics:
enabled: true
storageUri: http://{existing-storage-account-name}.blob.core.windows.net
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: '{vm-name}'
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2016-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Standard_LRS
name: vmOSdisk
userData: RXhhbXBsZSBVc2VyRGF0YQ==
vmName: '{vm-name}'
Create a VM with VM Size Properties
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
DiagnosticsProfile = new AzureNative.Compute.Inputs.DiagnosticsProfileArgs
{
BootDiagnostics = new AzureNative.Compute.Inputs.BootDiagnosticsArgs
{
Enabled = true,
StorageUri = "http://{existing-storage-account-name}.blob.core.windows.net",
},
},
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D4_v3",
VmSizeProperties = new AzureNative.Compute.Inputs.VMSizePropertiesArgs
{
VCPUsAvailable = 1,
VCPUsPerCore = 1,
},
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Standard_LRS",
},
Name = "myVMosdisk",
},
},
UserData = "U29tZSBDdXN0b20gRGF0YQ==",
VmName = "myVM",
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := compute.NewVirtualMachine(ctx, "virtualMachine", &compute.VirtualMachineArgs{
DiagnosticsProfile: compute.DiagnosticsProfileResponse{
BootDiagnostics: &compute.BootDiagnosticsArgs{
Enabled: pulumi.Bool(true),
StorageUri: pulumi.String("http://{existing-storage-account-name}.blob.core.windows.net"),
},
},
HardwareProfile: compute.HardwareProfileResponse{
VmSize: pulumi.String("Standard_D4_v3"),
VmSizeProperties: &compute.VMSizePropertiesArgs{
VCPUsAvailable: pulumi.Int(1),
VCPUsPerCore: pulumi.Int(1),
},
},
Location: pulumi.String("westus"),
NetworkProfile: compute.NetworkProfileResponse{
NetworkInterfaces: compute.NetworkInterfaceReferenceArray{
&compute.NetworkInterfaceReferenceArgs{
Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Primary: pulumi.Bool(true),
},
},
},
OsProfile: &compute.OSProfileArgs{
AdminPassword: pulumi.String("{your-password}"),
AdminUsername: pulumi.String("{your-username}"),
ComputerName: pulumi.String("myVM"),
},
ResourceGroupName: pulumi.String("myResourceGroup"),
StorageProfile: compute.StorageProfileResponse{
ImageReference: &compute.ImageReferenceArgs{
Offer: pulumi.String("WindowsServer"),
Publisher: pulumi.String("MicrosoftWindowsServer"),
Sku: pulumi.String("2016-Datacenter"),
Version: pulumi.String("latest"),
},
OsDisk: interface{}{
Caching: compute.CachingTypesReadWrite,
CreateOption: pulumi.String("FromImage"),
ManagedDisk: &compute.ManagedDiskParametersArgs{
StorageAccountType: pulumi.String("Standard_LRS"),
},
Name: pulumi.String("myVMosdisk"),
},
},
UserData: pulumi.String("U29tZSBDdXN0b20gRGF0YQ=="),
VmName: pulumi.String("myVM"),
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.diagnosticsProfile(Map.of("bootDiagnostics", Map.ofEntries(
Map.entry("enabled", true),
Map.entry("storageUri", "http://{existing-storage-account-name}.blob.core.windows.net")
)))
.hardwareProfile(Map.ofEntries(
Map.entry("vmSize", "Standard_D4_v3"),
Map.entry("vmSizeProperties", Map.ofEntries(
Map.entry("vCPUsAvailable", 1),
Map.entry("vCPUsPerCore", 1)
))
))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2016-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.userData("U29tZSBDdXN0b20gRGF0YQ==")
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
diagnostics_profile=azure_native.compute.DiagnosticsProfileResponseArgs(
boot_diagnostics=azure_native.compute.BootDiagnosticsArgs(
enabled=True,
storage_uri="http://{existing-storage-account-name}.blob.core.windows.net",
),
),
hardware_profile=azure_native.compute.HardwareProfileResponseArgs(
vm_size="Standard_D4_v3",
vm_size_properties=azure_native.compute.VMSizePropertiesArgs(
v_cpus_available=1,
v_cpus_per_core=1,
),
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2016-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Standard_LRS",
),
"name": "myVMosdisk",
},
),
user_data="U29tZSBDdXN0b20gRGF0YQ==",
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
diagnosticsProfile: {
bootDiagnostics: {
enabled: true,
storageUri: "http://{existing-storage-account-name}.blob.core.windows.net",
},
},
hardwareProfile: {
vmSize: "Standard_D4_v3",
vmSizeProperties: {
vCPUsAvailable: 1,
vCPUsPerCore: 1,
},
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2016-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Standard_LRS",
},
name: "myVMosdisk",
},
},
userData: "U29tZSBDdXN0b20gRGF0YQ==",
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
diagnosticsProfile:
bootDiagnostics:
enabled: true
storageUri: http://{existing-storage-account-name}.blob.core.windows.net
hardwareProfile:
vmSize: Standard_D4_v3
vmSizeProperties:
vCPUsAvailable: 1
vCPUsPerCore: 1
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2016-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Standard_LRS
name: myVMosdisk
userData: U29tZSBDdXN0b20gRGF0YQ==
vmName: myVM
Create a VM with network interface configuration
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkApiVersion = "2020-11-01",
NetworkInterfaceConfigurations = new[]
{
new AzureNative.Compute.Inputs.VirtualMachineNetworkInterfaceConfigurationArgs
{
DeleteOption = "Delete",
IpConfigurations = new[]
{
new AzureNative.Compute.Inputs.VirtualMachineNetworkInterfaceIPConfigurationArgs
{
Name = "{ip-config-name}",
Primary = true,
PublicIPAddressConfiguration = new AzureNative.Compute.Inputs.VirtualMachinePublicIPAddressConfigurationArgs
{
DeleteOption = "Detach",
Name = "{publicIP-config-name}",
PublicIPAllocationMethod = "Static",
Sku = new AzureNative.Compute.Inputs.PublicIPAddressSkuArgs
{
Name = "Basic",
Tier = "Global",
},
},
},
},
Name = "{nic-config-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Standard_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := compute.NewVirtualMachine(ctx, "virtualMachine", &compute.VirtualMachineArgs{
HardwareProfile: &compute.HardwareProfileArgs{
VmSize: pulumi.String("Standard_D1_v2"),
},
Location: pulumi.String("westus"),
NetworkProfile: compute.NetworkProfileResponse{
NetworkApiVersion: pulumi.String("2020-11-01"),
NetworkInterfaceConfigurations: compute.VirtualMachineNetworkInterfaceConfigurationArray{
interface{}{
DeleteOption: pulumi.String("Delete"),
IpConfigurations: compute.VirtualMachineNetworkInterfaceIPConfigurationArray{
interface{}{
Name: pulumi.String("{ip-config-name}"),
Primary: pulumi.Bool(true),
PublicIPAddressConfiguration: interface{}{
DeleteOption: pulumi.String("Detach"),
Name: pulumi.String("{publicIP-config-name}"),
PublicIPAllocationMethod: pulumi.String("Static"),
Sku: &compute.PublicIPAddressSkuArgs{
Name: pulumi.String("Basic"),
Tier: pulumi.String("Global"),
},
},
},
},
Name: pulumi.String("{nic-config-name}"),
Primary: pulumi.Bool(true),
},
},
},
OsProfile: &compute.OSProfileArgs{
AdminPassword: pulumi.String("{your-password}"),
AdminUsername: pulumi.String("{your-username}"),
ComputerName: pulumi.String("myVM"),
},
ResourceGroupName: pulumi.String("myResourceGroup"),
StorageProfile: compute.StorageProfileResponse{
ImageReference: &compute.ImageReferenceArgs{
Offer: pulumi.String("WindowsServer"),
Publisher: pulumi.String("MicrosoftWindowsServer"),
Sku: pulumi.String("2016-Datacenter"),
Version: pulumi.String("latest"),
},
OsDisk: interface{}{
Caching: compute.CachingTypesReadWrite,
CreateOption: pulumi.String("FromImage"),
ManagedDisk: &compute.ManagedDiskParametersArgs{
StorageAccountType: pulumi.String("Standard_LRS"),
},
Name: pulumi.String("myVMosdisk"),
},
},
VmName: pulumi.String("myVM"),
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.ofEntries(
Map.entry("networkApiVersion", "2020-11-01"),
Map.entry("networkInterfaceConfigurations", Map.ofEntries(
Map.entry("deleteOption", "Delete"),
Map.entry("ipConfigurations", Map.ofEntries(
Map.entry("name", "{ip-config-name}"),
Map.entry("primary", true),
Map.entry("publicIPAddressConfiguration", Map.ofEntries(
Map.entry("deleteOption", "Detach"),
Map.entry("name", "{publicIP-config-name}"),
Map.entry("publicIPAllocationMethod", "Static"),
Map.entry("sku", Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Global")
))
))
)),
Map.entry("name", "{nic-config-name}"),
Map.entry("primary", true)
))
))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2016-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_api_version="2020-11-01",
network_interface_configurations=[{
"deleteOption": "Delete",
"ipConfigurations": [{
"name": "{ip-config-name}",
"primary": True,
"publicIPAddressConfiguration": {
"deleteOption": "Detach",
"name": "{publicIP-config-name}",
"publicIPAllocationMethod": "Static",
"sku": azure_native.compute.PublicIPAddressSkuArgs(
name="Basic",
tier="Global",
),
},
}],
"name": "{nic-config-name}",
"primary": True,
}],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2016-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Standard_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkApiVersion: "2020-11-01",
networkInterfaceConfigurations: [{
deleteOption: "Delete",
ipConfigurations: [{
name: "{ip-config-name}",
primary: true,
publicIPAddressConfiguration: {
deleteOption: "Detach",
name: "{publicIP-config-name}",
publicIPAllocationMethod: "Static",
sku: {
name: "Basic",
tier: "Global",
},
},
}],
name: "{nic-config-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2016-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Standard_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkApiVersion: 2020-11-01
networkInterfaceConfigurations:
- deleteOption: Delete
ipConfigurations:
- name: '{ip-config-name}'
primary: true
publicIPAddressConfiguration:
deleteOption: Detach
name: '{publicIP-config-name}'
publicIPAllocationMethod: Static
sku:
name: Basic
tier: Global
name: '{nic-config-name}'
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2016-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Standard_LRS
name: myVMosdisk
vmName: myVM
Create a VM with securityType ConfidentialVM with Customer Managed Keys
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_DC2as_v5",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
ResourceGroupName = "myResourceGroup",
SecurityProfile = new AzureNative.Compute.Inputs.SecurityProfileArgs
{
SecurityType = "ConfidentialVM",
UefiSettings = new AzureNative.Compute.Inputs.UefiSettingsArgs
{
SecureBootEnabled = true,
VTpmEnabled = true,
},
},
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "2019-datacenter-cvm",
Publisher = "MicrosoftWindowsServer",
Sku = "windows-cvm",
Version = "17763.2183.2109130127",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadOnly,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
SecurityProfile = new AzureNative.Compute.Inputs.VMDiskSecurityProfileArgs
{
DiskEncryptionSet = new AzureNative.Compute.Inputs.DiskEncryptionSetParametersArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
},
SecurityEncryptionType = "DiskWithVMGuestState",
},
StorageAccountType = "StandardSSD_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := compute.NewVirtualMachine(ctx, "virtualMachine", &compute.VirtualMachineArgs{
HardwareProfile: &compute.HardwareProfileArgs{
VmSize: pulumi.String("Standard_DC2as_v5"),
},
Location: pulumi.String("westus"),
NetworkProfile: compute.NetworkProfileResponse{
NetworkInterfaces: compute.NetworkInterfaceReferenceArray{
&compute.NetworkInterfaceReferenceArgs{
Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Primary: pulumi.Bool(true),
},
},
},
OsProfile: &compute.OSProfileArgs{
AdminPassword: pulumi.String("{your-password}"),
AdminUsername: pulumi.String("{your-username}"),
ComputerName: pulumi.String("myVM"),
},
ResourceGroupName: pulumi.String("myResourceGroup"),
SecurityProfile: compute.SecurityProfileResponse{
SecurityType: pulumi.String("ConfidentialVM"),
UefiSettings: &compute.UefiSettingsArgs{
SecureBootEnabled: pulumi.Bool(true),
VTpmEnabled: pulumi.Bool(true),
},
},
StorageProfile: compute.StorageProfileResponse{
ImageReference: &compute.ImageReferenceArgs{
Offer: pulumi.String("2019-datacenter-cvm"),
Publisher: pulumi.String("MicrosoftWindowsServer"),
Sku: pulumi.String("windows-cvm"),
Version: pulumi.String("17763.2183.2109130127"),
},
OsDisk: interface{}{
Caching: compute.CachingTypesReadOnly,
CreateOption: pulumi.String("FromImage"),
ManagedDisk: interface{}{
SecurityProfile: interface{}{
DiskEncryptionSet: &compute.DiskEncryptionSetParametersArgs{
Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}"),
},
SecurityEncryptionType: pulumi.String("DiskWithVMGuestState"),
},
StorageAccountType: pulumi.String("StandardSSD_LRS"),
},
Name: pulumi.String("myVMosdisk"),
},
},
VmName: pulumi.String("myVM"),
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_DC2as_v5"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.resourceGroupName("myResourceGroup")
.securityProfile(Map.ofEntries(
Map.entry("securityType", "ConfidentialVM"),
Map.entry("uefiSettings", Map.ofEntries(
Map.entry("secureBootEnabled", true),
Map.entry("vTpmEnabled", true)
))
))
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "2019-datacenter-cvm"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "windows-cvm"),
Map.entry("version", "17763.2183.2109130127")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadOnly"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.ofEntries(
Map.entry("securityProfile", Map.ofEntries(
Map.entry("diskEncryptionSet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}")),
Map.entry("securityEncryptionType", "DiskWithVMGuestState")
)),
Map.entry("storageAccountType", "StandardSSD_LRS")
)),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_DC2as_v5",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
resource_group_name="myResourceGroup",
security_profile=azure_native.compute.SecurityProfileResponseArgs(
security_type="ConfidentialVM",
uefi_settings=azure_native.compute.UefiSettingsArgs(
secure_boot_enabled=True,
v_tpm_enabled=True,
),
),
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="2019-datacenter-cvm",
publisher="MicrosoftWindowsServer",
sku="windows-cvm",
version="17763.2183.2109130127",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_ONLY,
"createOption": "FromImage",
"managedDisk": {
"securityProfile": {
"diskEncryptionSet": azure_native.compute.DiskEncryptionSetParametersArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
),
"securityEncryptionType": "DiskWithVMGuestState",
},
"storageAccountType": "StandardSSD_LRS",
},
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_DC2as_v5",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
resourceGroupName: "myResourceGroup",
securityProfile: {
securityType: "ConfidentialVM",
uefiSettings: {
secureBootEnabled: true,
vTpmEnabled: true,
},
},
storageProfile: {
imageReference: {
offer: "2019-datacenter-cvm",
publisher: "MicrosoftWindowsServer",
sku: "windows-cvm",
version: "17763.2183.2109130127",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadOnly,
createOption: "FromImage",
managedDisk: {
securityProfile: {
diskEncryptionSet: {
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
},
securityEncryptionType: "DiskWithVMGuestState",
},
storageAccountType: "StandardSSD_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_DC2as_v5
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
resourceGroupName: myResourceGroup
securityProfile:
securityType: ConfidentialVM
uefiSettings:
secureBootEnabled: true
vTpmEnabled: true
storageProfile:
imageReference:
offer: 2019-datacenter-cvm
publisher: MicrosoftWindowsServer
sku: windows-cvm
version: 17763.2183.2109130127
osDisk:
caching: ReadOnly
createOption: FromImage
managedDisk:
securityProfile:
diskEncryptionSet:
id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}
securityEncryptionType: DiskWithVMGuestState
storageAccountType: StandardSSD_LRS
name: myVMosdisk
vmName: myVM
Create a VM with securityType ConfidentialVM with Platform Managed Keys
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_DC2as_v5",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
ResourceGroupName = "myResourceGroup",
SecurityProfile = new AzureNative.Compute.Inputs.SecurityProfileArgs
{
SecurityType = "ConfidentialVM",
UefiSettings = new AzureNative.Compute.Inputs.UefiSettingsArgs
{
SecureBootEnabled = true,
VTpmEnabled = true,
},
},
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "2019-datacenter-cvm",
Publisher = "MicrosoftWindowsServer",
Sku = "windows-cvm",
Version = "17763.2183.2109130127",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadOnly,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
SecurityProfile = new AzureNative.Compute.Inputs.VMDiskSecurityProfileArgs
{
SecurityEncryptionType = "DiskWithVMGuestState",
},
StorageAccountType = "StandardSSD_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := compute.NewVirtualMachine(ctx, "virtualMachine", &compute.VirtualMachineArgs{
HardwareProfile: &compute.HardwareProfileArgs{
VmSize: pulumi.String("Standard_DC2as_v5"),
},
Location: pulumi.String("westus"),
NetworkProfile: compute.NetworkProfileResponse{
NetworkInterfaces: compute.NetworkInterfaceReferenceArray{
&compute.NetworkInterfaceReferenceArgs{
Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Primary: pulumi.Bool(true),
},
},
},
OsProfile: &compute.OSProfileArgs{
AdminPassword: pulumi.String("{your-password}"),
AdminUsername: pulumi.String("{your-username}"),
ComputerName: pulumi.String("myVM"),
},
ResourceGroupName: pulumi.String("myResourceGroup"),
SecurityProfile: compute.SecurityProfileResponse{
SecurityType: pulumi.String("ConfidentialVM"),
UefiSettings: &compute.UefiSettingsArgs{
SecureBootEnabled: pulumi.Bool(true),
VTpmEnabled: pulumi.Bool(true),
},
},
StorageProfile: compute.StorageProfileResponse{
ImageReference: &compute.ImageReferenceArgs{
Offer: pulumi.String("2019-datacenter-cvm"),
Publisher: pulumi.String("MicrosoftWindowsServer"),
Sku: pulumi.String("windows-cvm"),
Version: pulumi.String("17763.2183.2109130127"),
},
OsDisk: interface{}{
Caching: compute.CachingTypesReadOnly,
CreateOption: pulumi.String("FromImage"),
ManagedDisk: interface{}{
SecurityProfile: &compute.VMDiskSecurityProfileArgs{
SecurityEncryptionType: pulumi.String("DiskWithVMGuestState"),
},
StorageAccountType: pulumi.String("StandardSSD_LRS"),
},
Name: pulumi.String("myVMosdisk"),
},
},
VmName: pulumi.String("myVM"),
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_DC2as_v5"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.resourceGroupName("myResourceGroup")
.securityProfile(Map.ofEntries(
Map.entry("securityType", "ConfidentialVM"),
Map.entry("uefiSettings", Map.ofEntries(
Map.entry("secureBootEnabled", true),
Map.entry("vTpmEnabled", true)
))
))
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "2019-datacenter-cvm"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "windows-cvm"),
Map.entry("version", "17763.2183.2109130127")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadOnly"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.ofEntries(
Map.entry("securityProfile", Map.of("securityEncryptionType", "DiskWithVMGuestState")),
Map.entry("storageAccountType", "StandardSSD_LRS")
)),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_DC2as_v5",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
resource_group_name="myResourceGroup",
security_profile=azure_native.compute.SecurityProfileResponseArgs(
security_type="ConfidentialVM",
uefi_settings=azure_native.compute.UefiSettingsArgs(
secure_boot_enabled=True,
v_tpm_enabled=True,
),
),
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="2019-datacenter-cvm",
publisher="MicrosoftWindowsServer",
sku="windows-cvm",
version="17763.2183.2109130127",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_ONLY,
"createOption": "FromImage",
"managedDisk": {
"securityProfile": azure_native.compute.VMDiskSecurityProfileArgs(
security_encryption_type="DiskWithVMGuestState",
),
"storageAccountType": "StandardSSD_LRS",
},
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_DC2as_v5",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
resourceGroupName: "myResourceGroup",
securityProfile: {
securityType: "ConfidentialVM",
uefiSettings: {
secureBootEnabled: true,
vTpmEnabled: true,
},
},
storageProfile: {
imageReference: {
offer: "2019-datacenter-cvm",
publisher: "MicrosoftWindowsServer",
sku: "windows-cvm",
version: "17763.2183.2109130127",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadOnly,
createOption: "FromImage",
managedDisk: {
securityProfile: {
securityEncryptionType: "DiskWithVMGuestState",
},
storageAccountType: "StandardSSD_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_DC2as_v5
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
resourceGroupName: myResourceGroup
securityProfile:
securityType: ConfidentialVM
uefiSettings:
secureBootEnabled: true
vTpmEnabled: true
storageProfile:
imageReference:
offer: 2019-datacenter-cvm
publisher: MicrosoftWindowsServer
sku: windows-cvm
version: 17763.2183.2109130127
osDisk:
caching: ReadOnly
createOption: FromImage
managedDisk:
securityProfile:
securityEncryptionType: DiskWithVMGuestState
storageAccountType: StandardSSD_LRS
name: myVMosdisk
vmName: myVM
Create a Windows vm with a patch setting assessmentMode of ImageDefault.
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
WindowsConfiguration = new AzureNative.Compute.Inputs.WindowsConfigurationArgs
{
EnableAutomaticUpdates = true,
PatchSettings = new AzureNative.Compute.Inputs.PatchSettingsArgs
{
AssessmentMode = "ImageDefault",
},
ProvisionVMAgent = true,
},
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Premium_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := compute.NewVirtualMachine(ctx, "virtualMachine", &compute.VirtualMachineArgs{
HardwareProfile: &compute.HardwareProfileArgs{
VmSize: pulumi.String("Standard_D1_v2"),
},
Location: pulumi.String("westus"),
NetworkProfile: compute.NetworkProfileResponse{
NetworkInterfaces: compute.NetworkInterfaceReferenceArray{
&compute.NetworkInterfaceReferenceArgs{
Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Primary: pulumi.Bool(true),
},
},
},
OsProfile: compute.OSProfileResponse{
AdminPassword: pulumi.String("{your-password}"),
AdminUsername: pulumi.String("{your-username}"),
ComputerName: pulumi.String("myVM"),
WindowsConfiguration: interface{}{
EnableAutomaticUpdates: pulumi.Bool(true),
PatchSettings: &compute.PatchSettingsArgs{
AssessmentMode: pulumi.String("ImageDefault"),
},
ProvisionVMAgent: pulumi.Bool(true),
},
},
ResourceGroupName: pulumi.String("myResourceGroup"),
StorageProfile: compute.StorageProfileResponse{
ImageReference: &compute.ImageReferenceArgs{
Offer: pulumi.String("WindowsServer"),
Publisher: pulumi.String("MicrosoftWindowsServer"),
Sku: pulumi.String("2016-Datacenter"),
Version: pulumi.String("latest"),
},
OsDisk: interface{}{
Caching: compute.CachingTypesReadWrite,
CreateOption: pulumi.String("FromImage"),
ManagedDisk: &compute.ManagedDiskParametersArgs{
StorageAccountType: pulumi.String("Premium_LRS"),
},
Name: pulumi.String("myVMosdisk"),
},
},
VmName: pulumi.String("myVM"),
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM"),
Map.entry("windowsConfiguration", Map.ofEntries(
Map.entry("enableAutomaticUpdates", true),
Map.entry("patchSettings", Map.of("assessmentMode", "ImageDefault")),
Map.entry("provisionVMAgent", true)
))
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2016-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileResponseArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
windows_configuration={
"enableAutomaticUpdates": True,
"patchSettings": azure_native.compute.PatchSettingsArgs(
assessment_mode="ImageDefault",
),
"provisionVMAgent": True,
},
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2016-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Premium_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
windowsConfiguration: {
enableAutomaticUpdates: true,
patchSettings: {
assessmentMode: "ImageDefault",
},
provisionVMAgent: true,
},
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2016-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Premium_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
windowsConfiguration:
enableAutomaticUpdates: true
patchSettings:
assessmentMode: ImageDefault
provisionVMAgent: true
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2016-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Premium_LRS
name: myVMosdisk
vmName: myVM
Create a Windows vm with a patch setting patchMode of AutomaticByOS.
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/nsgExistingNic",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
WindowsConfiguration = new AzureNative.Compute.Inputs.WindowsConfigurationArgs
{
EnableAutomaticUpdates = true,
PatchSettings = new AzureNative.Compute.Inputs.PatchSettingsArgs
{
PatchMode = "AutomaticByOS",
},
ProvisionVMAgent = true,
},
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Premium_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := compute.NewVirtualMachine(ctx, "virtualMachine", &compute.VirtualMachineArgs{
HardwareProfile: &compute.HardwareProfileArgs{
VmSize: pulumi.String("Standard_D1_v2"),
},
Location: pulumi.String("westus"),
NetworkProfile: compute.NetworkProfileResponse{
NetworkInterfaces: compute.NetworkInterfaceReferenceArray{
&compute.NetworkInterfaceReferenceArgs{
Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/nsgExistingNic"),
Primary: pulumi.Bool(true),
},
},
},
OsProfile: compute.OSProfileResponse{
AdminPassword: pulumi.String("{your-password}"),
AdminUsername: pulumi.String("{your-username}"),
ComputerName: pulumi.String("myVM"),
WindowsConfiguration: interface{}{
EnableAutomaticUpdates: pulumi.Bool(true),
PatchSettings: &compute.PatchSettingsArgs{
PatchMode: pulumi.String("AutomaticByOS"),
},
ProvisionVMAgent: pulumi.Bool(true),
},
},
ResourceGroupName: pulumi.String("myResourceGroup"),
StorageProfile: compute.StorageProfileResponse{
ImageReference: &compute.ImageReferenceArgs{
Offer: pulumi.String("WindowsServer"),
Publisher: pulumi.String("MicrosoftWindowsServer"),
Sku: pulumi.String("2016-Datacenter"),
Version: pulumi.String("latest"),
},
OsDisk: interface{}{
Caching: compute.CachingTypesReadWrite,
CreateOption: pulumi.String("FromImage"),
ManagedDisk: &compute.ManagedDiskParametersArgs{
StorageAccountType: pulumi.String("Premium_LRS"),
},
Name: pulumi.String("myVMosdisk"),
},
},
VmName: pulumi.String("myVM"),
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/nsgExistingNic"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM"),
Map.entry("windowsConfiguration", Map.ofEntries(
Map.entry("enableAutomaticUpdates", true),
Map.entry("patchSettings", Map.of("patchMode", "AutomaticByOS")),
Map.entry("provisionVMAgent", true)
))
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2016-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/nsgExistingNic",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileResponseArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
windows_configuration={
"enableAutomaticUpdates": True,
"patchSettings": azure_native.compute.PatchSettingsArgs(
patch_mode="AutomaticByOS",
),
"provisionVMAgent": True,
},
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2016-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Premium_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/nsgExistingNic",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
windowsConfiguration: {
enableAutomaticUpdates: true,
patchSettings: {
patchMode: "AutomaticByOS",
},
provisionVMAgent: true,
},
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2016-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Premium_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/nsgExistingNic
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
windowsConfiguration:
enableAutomaticUpdates: true
patchSettings:
patchMode: AutomaticByOS
provisionVMAgent: true
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2016-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Premium_LRS
name: myVMosdisk
vmName: myVM
Create a Windows vm with a patch setting patchMode of AutomaticByPlatform and AutomaticByPlatformSettings.
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
WindowsConfiguration = new AzureNative.Compute.Inputs.WindowsConfigurationArgs
{
EnableAutomaticUpdates = true,
PatchSettings = new AzureNative.Compute.Inputs.PatchSettingsArgs
{
AssessmentMode = "AutomaticByPlatform",
AutomaticByPlatformSettings = new AzureNative.Compute.Inputs.WindowsVMGuestPatchAutomaticByPlatformSettingsArgs
{
BypassPlatformSafetyChecksOnUserSchedule = false,
RebootSetting = "Never",
},
PatchMode = "AutomaticByPlatform",
},
ProvisionVMAgent = true,
},
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Premium_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := compute.NewVirtualMachine(ctx, "virtualMachine", &compute.VirtualMachineArgs{
HardwareProfile: &compute.HardwareProfileArgs{
VmSize: pulumi.String("Standard_D1_v2"),
},
Location: pulumi.String("westus"),
NetworkProfile: compute.NetworkProfileResponse{
NetworkInterfaces: compute.NetworkInterfaceReferenceArray{
&compute.NetworkInterfaceReferenceArgs{
Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Primary: pulumi.Bool(true),
},
},
},
OsProfile: compute.OSProfileResponse{
AdminPassword: pulumi.String("{your-password}"),
AdminUsername: pulumi.String("{your-username}"),
ComputerName: pulumi.String("myVM"),
WindowsConfiguration: interface{}{
EnableAutomaticUpdates: pulumi.Bool(true),
PatchSettings: interface{}{
AssessmentMode: pulumi.String("AutomaticByPlatform"),
AutomaticByPlatformSettings: &compute.WindowsVMGuestPatchAutomaticByPlatformSettingsArgs{
BypassPlatformSafetyChecksOnUserSchedule: pulumi.Bool(false),
RebootSetting: pulumi.String("Never"),
},
PatchMode: pulumi.String("AutomaticByPlatform"),
},
ProvisionVMAgent: pulumi.Bool(true),
},
},
ResourceGroupName: pulumi.String("myResourceGroup"),
StorageProfile: compute.StorageProfileResponse{
ImageReference: &compute.ImageReferenceArgs{
Offer: pulumi.String("WindowsServer"),
Publisher: pulumi.String("MicrosoftWindowsServer"),
Sku: pulumi.String("2016-Datacenter"),
Version: pulumi.String("latest"),
},
OsDisk: interface{}{
Caching: compute.CachingTypesReadWrite,
CreateOption: pulumi.String("FromImage"),
ManagedDisk: &compute.ManagedDiskParametersArgs{
StorageAccountType: pulumi.String("Premium_LRS"),
},
Name: pulumi.String("myVMosdisk"),
},
},
VmName: pulumi.String("myVM"),
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM"),
Map.entry("windowsConfiguration", Map.ofEntries(
Map.entry("enableAutomaticUpdates", true),
Map.entry("patchSettings", Map.ofEntries(
Map.entry("assessmentMode", "AutomaticByPlatform"),
Map.entry("automaticByPlatformSettings", Map.ofEntries(
Map.entry("bypassPlatformSafetyChecksOnUserSchedule", false),
Map.entry("rebootSetting", "Never")
)),
Map.entry("patchMode", "AutomaticByPlatform")
)),
Map.entry("provisionVMAgent", true)
))
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2016-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileResponseArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
windows_configuration={
"enableAutomaticUpdates": True,
"patchSettings": {
"assessmentMode": "AutomaticByPlatform",
"automaticByPlatformSettings": azure_native.compute.WindowsVMGuestPatchAutomaticByPlatformSettingsArgs(
bypass_platform_safety_checks_on_user_schedule=False,
reboot_setting="Never",
),
"patchMode": "AutomaticByPlatform",
},
"provisionVMAgent": True,
},
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2016-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Premium_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
windowsConfiguration: {
enableAutomaticUpdates: true,
patchSettings: {
assessmentMode: "AutomaticByPlatform",
automaticByPlatformSettings: {
bypassPlatformSafetyChecksOnUserSchedule: false,
rebootSetting: "Never",
},
patchMode: "AutomaticByPlatform",
},
provisionVMAgent: true,
},
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2016-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Premium_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
windowsConfiguration:
enableAutomaticUpdates: true
patchSettings:
assessmentMode: AutomaticByPlatform
automaticByPlatformSettings:
bypassPlatformSafetyChecksOnUserSchedule: false
rebootSetting: Never
patchMode: AutomaticByPlatform
provisionVMAgent: true
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2016-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Premium_LRS
name: myVMosdisk
vmName: myVM
Create a Windows vm with a patch setting patchMode of AutomaticByPlatform and enableHotpatching set to true.
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
WindowsConfiguration = new AzureNative.Compute.Inputs.WindowsConfigurationArgs
{
EnableAutomaticUpdates = true,
PatchSettings = new AzureNative.Compute.Inputs.PatchSettingsArgs
{
EnableHotpatching = true,
PatchMode = "AutomaticByPlatform",
},
ProvisionVMAgent = true,
},
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Premium_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
package main
import (
"github.com/pulumi/pulumi-azure-native-sdk/compute/v2"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := compute.NewVirtualMachine(ctx, "virtualMachine", &compute.VirtualMachineArgs{
HardwareProfile: &compute.HardwareProfileArgs{
VmSize: pulumi.String("Standard_D1_v2"),
},
Location: pulumi.String("westus"),
NetworkProfile: compute.NetworkProfileResponse{
NetworkInterfaces: compute.NetworkInterfaceReferenceArray{
&compute.NetworkInterfaceReferenceArgs{
Id: pulumi.String("/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Primary: pulumi.Bool(true),
},
},
},
OsProfile: compute.OSProfileResponse{
AdminPassword: pulumi.String("{your-password}"),
AdminUsername: pulumi.String("{your-username}"),
ComputerName: pulumi.String("myVM"),
WindowsConfiguration: interface{}{
EnableAutomaticUpdates: pulumi.Bool(true),
PatchSettings: &compute.PatchSettingsArgs{
EnableHotpatching: pulumi.Bool(true),
PatchMode: pulumi.String("AutomaticByPlatform"),
},
ProvisionVMAgent: pulumi.Bool(true),
},
},
ResourceGroupName: pulumi.String("myResourceGroup"),
StorageProfile: compute.StorageProfileResponse{
ImageReference: &compute.ImageReferenceArgs{
Offer: pulumi.String("WindowsServer"),
Publisher: pulumi.String("MicrosoftWindowsServer"),
Sku: pulumi.String("2016-Datacenter"),
Version: pulumi.String("latest"),
},
OsDisk: interface{}{
Caching: compute.CachingTypesReadWrite,
CreateOption: pulumi.String("FromImage"),
ManagedDisk: &compute.ManagedDiskParametersArgs{
StorageAccountType: pulumi.String("Premium_LRS"),
},
Name: pulumi.String("myVMosdisk"),
},
},
VmName: pulumi.String("myVM"),
})
if err != nil {
return err
}
return nil
})
}
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM"),
Map.entry("windowsConfiguration", Map.ofEntries(
Map.entry("enableAutomaticUpdates", true),
Map.entry("patchSettings", Map.ofEntries(
Map.entry("enableHotpatching", true),
Map.entry("patchMode", "AutomaticByPlatform")
)),
Map.entry("provisionVMAgent", true)
))
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2016-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileResponseArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
windows_configuration={
"enableAutomaticUpdates": True,
"patchSettings": azure_native.compute.PatchSettingsArgs(
enable_hotpatching=True,
patch_mode="AutomaticByPlatform",
),
"provisionVMAgent": True,
},
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2016-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Premium_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
windowsConfiguration: {
enableAutomaticUpdates: true,
patchSettings: {
enableHotpatching: true,
patchMode: "AutomaticByPlatform",
},
provisionVMAgent: true,
},
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2016-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Premium_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
windowsConfiguration:
enableAutomaticUpdates: true
patchSettings:
enableHotpatching: true
patchMode: AutomaticByPlatform
provisionVMAgent: true
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2016-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Premium_LRS
name: myVMosdisk
vmName: myVM
Create a Windows vm with a patch setting patchMode of Manual.
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
WindowsConfiguration = new AzureNative.Compute.Inputs.WindowsConfigurationArgs
{
EnableAutomaticUpdates = true,
PatchSettings = new AzureNative.Compute.Inputs.PatchSettingsArgs
{
PatchMode = "Manual",
},
ProvisionVMAgent = true,
},
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.