Azure Native v1.102.0, May 2 23
Azure Native v1.102.0, May 2 23
azure-native.compute.VirtualMachine
Explore with Pulumi AI
Describes a Virtual Machine. API Version: 2021-03-01.
Example Usage
Create a Linux vm with a patch setting assessmentMode of ImageDefault.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D2s_v3",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
LinuxConfiguration = new AzureNative.Compute.Inputs.LinuxConfigurationArgs
{
PatchSettings = new AzureNative.Compute.Inputs.LinuxPatchSettingsArgs
{
AssessmentMode = "ImageDefault",
},
ProvisionVMAgent = true,
},
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "UbuntuServer",
Publisher = "Canonical",
Sku = "16.04-LTS",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Premium_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D2s_v3"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM"),
Map.entry("linuxConfiguration", Map.ofEntries(
Map.entry("patchSettings", Map.of("assessmentMode", "ImageDefault")),
Map.entry("provisionVMAgent", true)
))
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "UbuntuServer"),
Map.entry("publisher", "Canonical"),
Map.entry("sku", "16.04-LTS"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D2s_v3",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileResponseArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
linux_configuration={
"patchSettings": azure_native.compute.LinuxPatchSettingsArgs(
assessment_mode="ImageDefault",
),
"provisionVMAgent": True,
},
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="UbuntuServer",
publisher="Canonical",
sku="16.04-LTS",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Premium_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D2s_v3",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
linuxConfiguration: {
patchSettings: {
assessmentMode: "ImageDefault",
},
provisionVMAgent: true,
},
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "UbuntuServer",
publisher: "Canonical",
sku: "16.04-LTS",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Premium_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D2s_v3
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
linuxConfiguration:
patchSettings:
assessmentMode: ImageDefault
provisionVMAgent: true
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: UbuntuServer
publisher: Canonical
sku: 16.04-LTS
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Premium_LRS
name: myVMosdisk
vmName: myVM
Create a Linux vm with a patch setting patchMode of ImageDefault.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D2s_v3",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
LinuxConfiguration = new AzureNative.Compute.Inputs.LinuxConfigurationArgs
{
PatchSettings = new AzureNative.Compute.Inputs.LinuxPatchSettingsArgs
{
PatchMode = "ImageDefault",
},
ProvisionVMAgent = true,
},
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "UbuntuServer",
Publisher = "Canonical",
Sku = "16.04-LTS",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Premium_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D2s_v3"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM"),
Map.entry("linuxConfiguration", Map.ofEntries(
Map.entry("patchSettings", Map.of("patchMode", "ImageDefault")),
Map.entry("provisionVMAgent", true)
))
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "UbuntuServer"),
Map.entry("publisher", "Canonical"),
Map.entry("sku", "16.04-LTS"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D2s_v3",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileResponseArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
linux_configuration={
"patchSettings": azure_native.compute.LinuxPatchSettingsArgs(
patch_mode="ImageDefault",
),
"provisionVMAgent": True,
},
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="UbuntuServer",
publisher="Canonical",
sku="16.04-LTS",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Premium_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D2s_v3",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
linuxConfiguration: {
patchSettings: {
patchMode: "ImageDefault",
},
provisionVMAgent: true,
},
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "UbuntuServer",
publisher: "Canonical",
sku: "16.04-LTS",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Premium_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D2s_v3
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
linuxConfiguration:
patchSettings:
patchMode: ImageDefault
provisionVMAgent: true
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: UbuntuServer
publisher: Canonical
sku: 16.04-LTS
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Premium_LRS
name: myVMosdisk
vmName: myVM
Create a Linux vm with a patch settings patchMode and assessmentMode set to AutomaticByPlatform.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D2s_v3",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
LinuxConfiguration = new AzureNative.Compute.Inputs.LinuxConfigurationArgs
{
PatchSettings = new AzureNative.Compute.Inputs.LinuxPatchSettingsArgs
{
AssessmentMode = "AutomaticByPlatform",
PatchMode = "AutomaticByPlatform",
},
ProvisionVMAgent = true,
},
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "UbuntuServer",
Publisher = "Canonical",
Sku = "16.04-LTS",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Premium_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D2s_v3"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM"),
Map.entry("linuxConfiguration", Map.ofEntries(
Map.entry("patchSettings", Map.ofEntries(
Map.entry("assessmentMode", "AutomaticByPlatform"),
Map.entry("patchMode", "AutomaticByPlatform")
)),
Map.entry("provisionVMAgent", true)
))
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "UbuntuServer"),
Map.entry("publisher", "Canonical"),
Map.entry("sku", "16.04-LTS"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D2s_v3",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileResponseArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
linux_configuration={
"patchSettings": azure_native.compute.LinuxPatchSettingsArgs(
assessment_mode="AutomaticByPlatform",
patch_mode="AutomaticByPlatform",
),
"provisionVMAgent": True,
},
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="UbuntuServer",
publisher="Canonical",
sku="16.04-LTS",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Premium_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D2s_v3",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
linuxConfiguration: {
patchSettings: {
assessmentMode: "AutomaticByPlatform",
patchMode: "AutomaticByPlatform",
},
provisionVMAgent: true,
},
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "UbuntuServer",
publisher: "Canonical",
sku: "16.04-LTS",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Premium_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D2s_v3
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
linuxConfiguration:
patchSettings:
assessmentMode: AutomaticByPlatform
patchMode: AutomaticByPlatform
provisionVMAgent: true
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: UbuntuServer
publisher: Canonical
sku: 16.04-LTS
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Premium_LRS
name: myVMosdisk
vmName: myVM
Create a VM with Uefi Settings of secureBoot and vTPM.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D2s_v3",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
ResourceGroupName = "myResourceGroup",
SecurityProfile = new AzureNative.Compute.Inputs.SecurityProfileArgs
{
SecurityType = "TrustedLaunch",
UefiSettings = new AzureNative.Compute.Inputs.UefiSettingsArgs
{
SecureBootEnabled = true,
VTpmEnabled = true,
},
},
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "windowsserver-gen2preview-preview",
Publisher = "MicrosoftWindowsServer",
Sku = "windows10-tvm",
Version = "18363.592.2001092016",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadOnly,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "StandardSSD_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D2s_v3"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.resourceGroupName("myResourceGroup")
.securityProfile(Map.ofEntries(
Map.entry("securityType", "TrustedLaunch"),
Map.entry("uefiSettings", Map.ofEntries(
Map.entry("secureBootEnabled", true),
Map.entry("vTpmEnabled", true)
))
))
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "windowsserver-gen2preview-preview"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "windows10-tvm"),
Map.entry("version", "18363.592.2001092016")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadOnly"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "StandardSSD_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D2s_v3",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
resource_group_name="myResourceGroup",
security_profile=azure_native.compute.SecurityProfileResponseArgs(
security_type="TrustedLaunch",
uefi_settings=azure_native.compute.UefiSettingsArgs(
secure_boot_enabled=True,
v_tpm_enabled=True,
),
),
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="windowsserver-gen2preview-preview",
publisher="MicrosoftWindowsServer",
sku="windows10-tvm",
version="18363.592.2001092016",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_ONLY,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="StandardSSD_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D2s_v3",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
resourceGroupName: "myResourceGroup",
securityProfile: {
securityType: "TrustedLaunch",
uefiSettings: {
secureBootEnabled: true,
vTpmEnabled: true,
},
},
storageProfile: {
imageReference: {
offer: "windowsserver-gen2preview-preview",
publisher: "MicrosoftWindowsServer",
sku: "windows10-tvm",
version: "18363.592.2001092016",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadOnly,
createOption: "FromImage",
managedDisk: {
storageAccountType: "StandardSSD_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D2s_v3
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
resourceGroupName: myResourceGroup
securityProfile:
securityType: TrustedLaunch
uefiSettings:
secureBootEnabled: true
vTpmEnabled: true
storageProfile:
imageReference:
offer: windowsserver-gen2preview-preview
publisher: MicrosoftWindowsServer
sku: windows10-tvm
version: 18363.592.2001092016
osDisk:
caching: ReadOnly
createOption: FromImage
managedDisk:
storageAccountType: StandardSSD_LRS
name: myVMosdisk
vmName: myVM
Create a VM with UserData
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
DiagnosticsProfile = new AzureNative.Compute.Inputs.DiagnosticsProfileArgs
{
BootDiagnostics = new AzureNative.Compute.Inputs.BootDiagnosticsArgs
{
Enabled = true,
StorageUri = "http://{existing-storage-account-name}.blob.core.windows.net",
},
},
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "{vm-name}",
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Standard_LRS",
},
Name = "vmOSdisk",
},
},
UserData = "RXhhbXBsZSBVc2VyRGF0YQ==",
VmName = "{vm-name}",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.diagnosticsProfile(Map.of("bootDiagnostics", Map.ofEntries(
Map.entry("enabled", true),
Map.entry("storageUri", "http://{existing-storage-account-name}.blob.core.windows.net")
)))
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "{vm-name}")
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2016-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
Map.entry("name", "vmOSdisk")
))
))
.userData("RXhhbXBsZSBVc2VyRGF0YQ==")
.vmName("{vm-name}")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
diagnostics_profile=azure_native.compute.DiagnosticsProfileResponseArgs(
boot_diagnostics=azure_native.compute.BootDiagnosticsArgs(
enabled=True,
storage_uri="http://{existing-storage-account-name}.blob.core.windows.net",
),
),
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="{vm-name}",
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2016-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Standard_LRS",
),
"name": "vmOSdisk",
},
),
user_data="RXhhbXBsZSBVc2VyRGF0YQ==",
vm_name="{vm-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
diagnosticsProfile: {
bootDiagnostics: {
enabled: true,
storageUri: "http://{existing-storage-account-name}.blob.core.windows.net",
},
},
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "{vm-name}",
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2016-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Standard_LRS",
},
name: "vmOSdisk",
},
},
userData: "RXhhbXBsZSBVc2VyRGF0YQ==",
vmName: "{vm-name}",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
diagnosticsProfile:
bootDiagnostics:
enabled: true
storageUri: http://{existing-storage-account-name}.blob.core.windows.net
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: '{vm-name}'
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2016-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Standard_LRS
name: vmOSdisk
userData: RXhhbXBsZSBVc2VyRGF0YQ==
vmName: '{vm-name}'
Create a VM with network interface configuration
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkApiVersion = "2020-11-01",
NetworkInterfaceConfigurations = new[]
{
new AzureNative.Compute.Inputs.VirtualMachineNetworkInterfaceConfigurationArgs
{
DeleteOption = "Delete",
IpConfigurations = new[]
{
new AzureNative.Compute.Inputs.VirtualMachineNetworkInterfaceIPConfigurationArgs
{
Name = "{ip-config-name}",
Primary = true,
PublicIPAddressConfiguration = new AzureNative.Compute.Inputs.VirtualMachinePublicIPAddressConfigurationArgs
{
DeleteOption = "Detach",
Name = "{publicIP-config-name}",
PublicIPAllocationMethod = "Static",
Sku = new AzureNative.Compute.Inputs.PublicIPAddressSkuArgs
{
Name = "Basic",
Tier = "Global",
},
},
},
},
Name = "{nic-config-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Standard_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.ofEntries(
Map.entry("networkApiVersion", "2020-11-01"),
Map.entry("networkInterfaceConfigurations", Map.ofEntries(
Map.entry("deleteOption", "Delete"),
Map.entry("ipConfigurations", Map.ofEntries(
Map.entry("name", "{ip-config-name}"),
Map.entry("primary", true),
Map.entry("publicIPAddressConfiguration", Map.ofEntries(
Map.entry("deleteOption", "Detach"),
Map.entry("name", "{publicIP-config-name}"),
Map.entry("publicIPAllocationMethod", "Static"),
Map.entry("sku", Map.ofEntries(
Map.entry("name", "Basic"),
Map.entry("tier", "Global")
))
))
)),
Map.entry("name", "{nic-config-name}"),
Map.entry("primary", true)
))
))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2016-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_api_version="2020-11-01",
network_interface_configurations=[{
"deleteOption": "Delete",
"ipConfigurations": [{
"name": "{ip-config-name}",
"primary": True,
"publicIPAddressConfiguration": {
"deleteOption": "Detach",
"name": "{publicIP-config-name}",
"publicIPAllocationMethod": "Static",
"sku": azure_native.compute.PublicIPAddressSkuArgs(
name="Basic",
tier="Global",
),
},
}],
"name": "{nic-config-name}",
"primary": True,
}],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2016-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Standard_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkApiVersion: "2020-11-01",
networkInterfaceConfigurations: [{
deleteOption: "Delete",
ipConfigurations: [{
name: "{ip-config-name}",
primary: true,
publicIPAddressConfiguration: {
deleteOption: "Detach",
name: "{publicIP-config-name}",
publicIPAllocationMethod: "Static",
sku: {
name: "Basic",
tier: "Global",
},
},
}],
name: "{nic-config-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2016-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Standard_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkApiVersion: 2020-11-01
networkInterfaceConfigurations:
- deleteOption: Delete
ipConfigurations:
- name: '{ip-config-name}'
primary: true
publicIPAddressConfiguration:
deleteOption: Detach
name: '{publicIP-config-name}'
publicIPAllocationMethod: Static
sku:
name: Basic
tier: Global
name: '{nic-config-name}'
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2016-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Standard_LRS
name: myVMosdisk
vmName: myVM
Create a Windows vm with a patch setting assessmentMode of ImageDefault.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
WindowsConfiguration = new AzureNative.Compute.Inputs.WindowsConfigurationArgs
{
EnableAutomaticUpdates = true,
PatchSettings = new AzureNative.Compute.Inputs.PatchSettingsArgs
{
AssessmentMode = "ImageDefault",
},
ProvisionVMAgent = true,
},
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Premium_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM"),
Map.entry("windowsConfiguration", Map.ofEntries(
Map.entry("enableAutomaticUpdates", true),
Map.entry("patchSettings", Map.of("assessmentMode", "ImageDefault")),
Map.entry("provisionVMAgent", true)
))
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2016-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileResponseArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
windows_configuration={
"enableAutomaticUpdates": True,
"patchSettings": azure_native.compute.PatchSettingsArgs(
assessment_mode="ImageDefault",
),
"provisionVMAgent": True,
},
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2016-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Premium_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
windowsConfiguration: {
enableAutomaticUpdates: true,
patchSettings: {
assessmentMode: "ImageDefault",
},
provisionVMAgent: true,
},
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2016-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Premium_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
windowsConfiguration:
enableAutomaticUpdates: true
patchSettings:
assessmentMode: ImageDefault
provisionVMAgent: true
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2016-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Premium_LRS
name: myVMosdisk
vmName: myVM
Create a Windows vm with a patch setting patchMode of AutomaticByOS.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/nsgExistingNic",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
WindowsConfiguration = new AzureNative.Compute.Inputs.WindowsConfigurationArgs
{
EnableAutomaticUpdates = true,
PatchSettings = new AzureNative.Compute.Inputs.PatchSettingsArgs
{
PatchMode = "AutomaticByOS",
},
ProvisionVMAgent = true,
},
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Premium_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/nsgExistingNic"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM"),
Map.entry("windowsConfiguration", Map.ofEntries(
Map.entry("enableAutomaticUpdates", true),
Map.entry("patchSettings", Map.of("patchMode", "AutomaticByOS")),
Map.entry("provisionVMAgent", true)
))
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2016-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/nsgExistingNic",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileResponseArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
windows_configuration={
"enableAutomaticUpdates": True,
"patchSettings": azure_native.compute.PatchSettingsArgs(
patch_mode="AutomaticByOS",
),
"provisionVMAgent": True,
},
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2016-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Premium_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/nsgExistingNic",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
windowsConfiguration: {
enableAutomaticUpdates: true,
patchSettings: {
patchMode: "AutomaticByOS",
},
provisionVMAgent: true,
},
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2016-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Premium_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/nsgExistingNic
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
windowsConfiguration:
enableAutomaticUpdates: true
patchSettings:
patchMode: AutomaticByOS
provisionVMAgent: true
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2016-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Premium_LRS
name: myVMosdisk
vmName: myVM
Create a Windows vm with a patch setting patchMode of AutomaticByPlatform and enableHotpatching set to true.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
WindowsConfiguration = new AzureNative.Compute.Inputs.WindowsConfigurationArgs
{
EnableAutomaticUpdates = true,
PatchSettings = new AzureNative.Compute.Inputs.PatchSettingsArgs
{
EnableHotpatching = true,
PatchMode = "AutomaticByPlatform",
},
ProvisionVMAgent = true,
},
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Premium_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM"),
Map.entry("windowsConfiguration", Map.ofEntries(
Map.entry("enableAutomaticUpdates", true),
Map.entry("patchSettings", Map.ofEntries(
Map.entry("enableHotpatching", true),
Map.entry("patchMode", "AutomaticByPlatform")
)),
Map.entry("provisionVMAgent", true)
))
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2016-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileResponseArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
windows_configuration={
"enableAutomaticUpdates": True,
"patchSettings": azure_native.compute.PatchSettingsArgs(
enable_hotpatching=True,
patch_mode="AutomaticByPlatform",
),
"provisionVMAgent": True,
},
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2016-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Premium_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
windowsConfiguration: {
enableAutomaticUpdates: true,
patchSettings: {
enableHotpatching: true,
patchMode: "AutomaticByPlatform",
},
provisionVMAgent: true,
},
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2016-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Premium_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
windowsConfiguration:
enableAutomaticUpdates: true
patchSettings:
enableHotpatching: true
patchMode: AutomaticByPlatform
provisionVMAgent: true
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2016-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Premium_LRS
name: myVMosdisk
vmName: myVM
Create a Windows vm with a patch setting patchMode of Manual.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
WindowsConfiguration = new AzureNative.Compute.Inputs.WindowsConfigurationArgs
{
EnableAutomaticUpdates = true,
PatchSettings = new AzureNative.Compute.Inputs.PatchSettingsArgs
{
PatchMode = "Manual",
},
ProvisionVMAgent = true,
},
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Premium_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM"),
Map.entry("windowsConfiguration", Map.ofEntries(
Map.entry("enableAutomaticUpdates", true),
Map.entry("patchSettings", Map.of("patchMode", "Manual")),
Map.entry("provisionVMAgent", true)
))
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2016-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileResponseArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
windows_configuration={
"enableAutomaticUpdates": True,
"patchSettings": azure_native.compute.PatchSettingsArgs(
patch_mode="Manual",
),
"provisionVMAgent": True,
},
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2016-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Premium_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
windowsConfiguration: {
enableAutomaticUpdates: true,
patchSettings: {
patchMode: "Manual",
},
provisionVMAgent: true,
},
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2016-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Premium_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
windowsConfiguration:
enableAutomaticUpdates: true
patchSettings:
patchMode: Manual
provisionVMAgent: true
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2016-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Premium_LRS
name: myVMosdisk
vmName: myVM
Create a Windows vm with patch settings patchMode and assessmentMode set to AutomaticByPlatform.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
WindowsConfiguration = new AzureNative.Compute.Inputs.WindowsConfigurationArgs
{
EnableAutomaticUpdates = true,
PatchSettings = new AzureNative.Compute.Inputs.PatchSettingsArgs
{
AssessmentMode = "AutomaticByPlatform",
PatchMode = "AutomaticByPlatform",
},
ProvisionVMAgent = true,
},
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Premium_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM"),
Map.entry("windowsConfiguration", Map.ofEntries(
Map.entry("enableAutomaticUpdates", true),
Map.entry("patchSettings", Map.ofEntries(
Map.entry("assessmentMode", "AutomaticByPlatform"),
Map.entry("patchMode", "AutomaticByPlatform")
)),
Map.entry("provisionVMAgent", true)
))
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2016-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Premium_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileResponseArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
windows_configuration={
"enableAutomaticUpdates": True,
"patchSettings": azure_native.compute.PatchSettingsArgs(
assessment_mode="AutomaticByPlatform",
patch_mode="AutomaticByPlatform",
),
"provisionVMAgent": True,
},
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2016-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Premium_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
windowsConfiguration: {
enableAutomaticUpdates: true,
patchSettings: {
assessmentMode: "AutomaticByPlatform",
patchMode: "AutomaticByPlatform",
},
provisionVMAgent: true,
},
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2016-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Premium_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
windowsConfiguration:
enableAutomaticUpdates: true
patchSettings:
assessmentMode: AutomaticByPlatform
patchMode: AutomaticByPlatform
provisionVMAgent: true
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2016-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Premium_LRS
name: myVMosdisk
vmName: myVM
Create a custom-image vm from an unmanaged generalized os image.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
Image = new AzureNative.Compute.Inputs.VirtualHardDiskArgs
{
Uri = "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/{existing-generalized-os-image-blob-name}.vhd",
},
Name = "myVMosdisk",
OsType = AzureNative.Compute.OperatingSystemTypes.Windows,
Vhd = new AzureNative.Compute.Inputs.VirtualHardDiskArgs
{
Uri = "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd",
},
},
},
VmName = "{vm-name}",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.of("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("image", Map.of("uri", "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/{existing-generalized-os-image-blob-name}.vhd")),
Map.entry("name", "myVMosdisk"),
Map.entry("osType", "Windows"),
Map.entry("vhd", Map.of("uri", "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd"))
)))
.vmName("{vm-name}")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"image": azure_native.compute.VirtualHardDiskArgs(
uri="http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/{existing-generalized-os-image-blob-name}.vhd",
),
"name": "myVMosdisk",
"osType": azure_native.compute.OperatingSystemTypes.WINDOWS,
"vhd": azure_native.compute.VirtualHardDiskArgs(
uri="http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd",
),
},
),
vm_name="{vm-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
resourceGroupName: "myResourceGroup",
storageProfile: {
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
image: {
uri: "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/{existing-generalized-os-image-blob-name}.vhd",
},
name: "myVMosdisk",
osType: azure_native.compute.OperatingSystemTypes.Windows,
vhd: {
uri: "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd",
},
},
},
vmName: "{vm-name}",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
resourceGroupName: myResourceGroup
storageProfile:
osDisk:
caching: ReadWrite
createOption: FromImage
image:
uri: http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/{existing-generalized-os-image-blob-name}.vhd
name: myVMosdisk
osType: Windows
vhd:
uri: http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd
vmName: '{vm-name}'
Create a platform-image vm with unmanaged os and data disks.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D2_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
DataDisks = new[]
{
new AzureNative.Compute.Inputs.DataDiskArgs
{
CreateOption = "Empty",
DiskSizeGB = 1023,
Lun = 0,
Vhd = new AzureNative.Compute.Inputs.VirtualHardDiskArgs
{
Uri = "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk0.vhd",
},
},
new AzureNative.Compute.Inputs.DataDiskArgs
{
CreateOption = "Empty",
DiskSizeGB = 1023,
Lun = 1,
Vhd = new AzureNative.Compute.Inputs.VirtualHardDiskArgs
{
Uri = "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk1.vhd",
},
},
},
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
Name = "myVMosdisk",
Vhd = new AzureNative.Compute.Inputs.VirtualHardDiskArgs
{
Uri = "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd",
},
},
},
VmName = "{vm-name}",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D2_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("dataDisks",
Map.ofEntries(
Map.entry("createOption", "Empty"),
Map.entry("diskSizeGB", 1023),
Map.entry("lun", 0),
Map.entry("vhd", Map.of("uri", "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk0.vhd"))
),
Map.ofEntries(
Map.entry("createOption", "Empty"),
Map.entry("diskSizeGB", 1023),
Map.entry("lun", 1),
Map.entry("vhd", Map.of("uri", "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk1.vhd"))
)),
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2016-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("name", "myVMosdisk"),
Map.entry("vhd", Map.of("uri", "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd"))
))
))
.vmName("{vm-name}")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D2_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
data_disks=[
{
"createOption": "Empty",
"diskSizeGB": 1023,
"lun": 0,
"vhd": azure_native.compute.VirtualHardDiskArgs(
uri="http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk0.vhd",
),
},
{
"createOption": "Empty",
"diskSizeGB": 1023,
"lun": 1,
"vhd": azure_native.compute.VirtualHardDiskArgs(
uri="http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk1.vhd",
),
},
],
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2016-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"name": "myVMosdisk",
"vhd": azure_native.compute.VirtualHardDiskArgs(
uri="http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd",
),
},
),
vm_name="{vm-name}")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D2_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
resourceGroupName: "myResourceGroup",
storageProfile: {
dataDisks: [
{
createOption: "Empty",
diskSizeGB: 1023,
lun: 0,
vhd: {
uri: "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk0.vhd",
},
},
{
createOption: "Empty",
diskSizeGB: 1023,
lun: 1,
vhd: {
uri: "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk1.vhd",
},
},
],
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2016-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
name: "myVMosdisk",
vhd: {
uri: "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd",
},
},
},
vmName: "{vm-name}",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D2_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
resourceGroupName: myResourceGroup
storageProfile:
dataDisks:
- createOption: Empty
diskSizeGB: 1023
lun: 0
vhd:
uri: http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk0.vhd
- createOption: Empty
diskSizeGB: 1023
lun: 1
vhd:
uri: http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk1.vhd
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2016-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
name: myVMosdisk
vhd:
uri: http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd
vmName: '{vm-name}'
Create a vm from a custom image.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Standard_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}")),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Standard_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Standard_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Standard_LRS
name: myVMosdisk
vmName: myVM
Create a vm from a generalized shared image.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Standard_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage")),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Standard_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Standard_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Standard_LRS
name: myVMosdisk
vmName: myVM
Create a vm from a specialized shared image.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Standard_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage")),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Standard_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Standard_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Standard_LRS
name: myVMosdisk
vmName: myVM
Create a vm in a Virtual Machine Scale Set with customer assigned platformFaultDomain.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
PlatformFaultDomain = 1,
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Standard_LRS",
},
Name = "myVMosdisk",
},
},
VirtualMachineScaleSet = new AzureNative.Compute.Inputs.SubResourceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachineScaleSets/{existing-flex-vmss-name-with-platformFaultDomainCount-greater-than-1}",
},
VmName = "myVM",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.platformFaultDomain(1)
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2016-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.virtualMachineScaleSet(Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachineScaleSets/{existing-flex-vmss-name-with-platformFaultDomainCount-greater-than-1}"))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
platform_fault_domain=1,
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2016-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Standard_LRS",
),
"name": "myVMosdisk",
},
),
virtual_machine_scale_set=azure_native.compute.SubResourceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachineScaleSets/{existing-flex-vmss-name-with-platformFaultDomainCount-greater-than-1}",
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
platformFaultDomain: 1,
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2016-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Standard_LRS",
},
name: "myVMosdisk",
},
},
virtualMachineScaleSet: {
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachineScaleSets/{existing-flex-vmss-name-with-platformFaultDomainCount-greater-than-1}",
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
platformFaultDomain: 1
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2016-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Standard_LRS
name: myVMosdisk
virtualMachineScaleSet:
id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachineScaleSets/{existing-flex-vmss-name-with-platformFaultDomainCount-greater-than-1}
vmName: myVM
Create a vm in an availability set.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
AvailabilitySet = new AzureNative.Compute.Inputs.SubResourceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/availabilitySets/{existing-availability-set-name}",
},
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Standard_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.availabilitySet(Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/availabilitySets/{existing-availability-set-name}"))
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2016-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
availability_set=azure_native.compute.SubResourceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/availabilitySets/{existing-availability-set-name}",
),
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2016-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Standard_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
availabilitySet: {
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/availabilitySets/{existing-availability-set-name}",
},
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2016-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Standard_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
availabilitySet:
id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/availabilitySets/{existing-availability-set-name}
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2016-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Standard_LRS
name: myVMosdisk
vmName: myVM
Create a vm with DiskEncryptionSet resource id in the os disk and data disk.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
DataDisks = new[]
{
new AzureNative.Compute.Inputs.DataDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "Empty",
DiskSizeGB = 1023,
Lun = 0,
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
DiskEncryptionSet = new AzureNative.Compute.Inputs.DiskEncryptionSetParametersArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
},
StorageAccountType = "Standard_LRS",
},
},
new AzureNative.Compute.Inputs.DataDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "Attach",
DiskSizeGB = 1023,
Lun = 1,
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
DiskEncryptionSet = new AzureNative.Compute.Inputs.DiskEncryptionSetParametersArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
},
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/{existing-managed-disk-name}",
StorageAccountType = "Standard_LRS",
},
},
},
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
DiskEncryptionSet = new AzureNative.Compute.Inputs.DiskEncryptionSetParametersArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
},
StorageAccountType = "Standard_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("dataDisks",
Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "Empty"),
Map.entry("diskSizeGB", 1023),
Map.entry("lun", 0),
Map.entry("managedDisk", Map.ofEntries(
Map.entry("diskEncryptionSet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}")),
Map.entry("storageAccountType", "Standard_LRS")
))
),
Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "Attach"),
Map.entry("diskSizeGB", 1023),
Map.entry("lun", 1),
Map.entry("managedDisk", Map.ofEntries(
Map.entry("diskEncryptionSet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}")),
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/{existing-managed-disk-name}"),
Map.entry("storageAccountType", "Standard_LRS")
))
)),
Map.entry("imageReference", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}")),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.ofEntries(
Map.entry("diskEncryptionSet", Map.of("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}")),
Map.entry("storageAccountType", "Standard_LRS")
)),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
data_disks=[
{
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "Empty",
"diskSizeGB": 1023,
"lun": 0,
"managedDisk": {
"diskEncryptionSet": azure_native.compute.DiskEncryptionSetParametersArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
),
"storageAccountType": "Standard_LRS",
},
},
{
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "Attach",
"diskSizeGB": 1023,
"lun": 1,
"managedDisk": {
"diskEncryptionSet": azure_native.compute.DiskEncryptionSetParametersArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
),
"id": "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/{existing-managed-disk-name}",
"storageAccountType": "Standard_LRS",
},
},
],
image_reference=azure_native.compute.ImageReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": {
"diskEncryptionSet": azure_native.compute.DiskEncryptionSetParametersArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
),
"storageAccountType": "Standard_LRS",
},
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
resourceGroupName: "myResourceGroup",
storageProfile: {
dataDisks: [
{
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "Empty",
diskSizeGB: 1023,
lun: 0,
managedDisk: {
diskEncryptionSet: {
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
},
storageAccountType: "Standard_LRS",
},
},
{
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "Attach",
diskSizeGB: 1023,
lun: 1,
managedDisk: {
diskEncryptionSet: {
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
},
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/{existing-managed-disk-name}",
storageAccountType: "Standard_LRS",
},
},
],
imageReference: {
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
diskEncryptionSet: {
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
},
storageAccountType: "Standard_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
resourceGroupName: myResourceGroup
storageProfile:
dataDisks:
- caching: ReadWrite
createOption: Empty
diskSizeGB: 1023
lun: 0
managedDisk:
diskEncryptionSet:
id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}
storageAccountType: Standard_LRS
- caching: ReadWrite
createOption: Attach
diskSizeGB: 1023
lun: 1
managedDisk:
diskEncryptionSet:
id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}
id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/{existing-managed-disk-name}
storageAccountType: Standard_LRS
imageReference:
id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
diskEncryptionSet:
id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}
storageAccountType: Standard_LRS
name: myVMosdisk
vmName: myVM
Create a vm with Host Encryption using encryptionAtHost property.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_DS1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
Plan = new AzureNative.Compute.Inputs.PlanArgs
{
Name = "windows2016",
Product = "windows-data-science-vm",
Publisher = "microsoft-ads",
},
ResourceGroupName = "myResourceGroup",
SecurityProfile = new AzureNative.Compute.Inputs.SecurityProfileArgs
{
EncryptionAtHost = true,
},
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "windows-data-science-vm",
Publisher = "microsoft-ads",
Sku = "windows2016",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadOnly,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Standard_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_DS1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.plan(Map.ofEntries(
Map.entry("name", "windows2016"),
Map.entry("product", "windows-data-science-vm"),
Map.entry("publisher", "microsoft-ads")
))
.resourceGroupName("myResourceGroup")
.securityProfile(Map.of("encryptionAtHost", true))
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "windows-data-science-vm"),
Map.entry("publisher", "microsoft-ads"),
Map.entry("sku", "windows2016"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadOnly"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_DS1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
plan=azure_native.compute.PlanArgs(
name="windows2016",
product="windows-data-science-vm",
publisher="microsoft-ads",
),
resource_group_name="myResourceGroup",
security_profile=azure_native.compute.SecurityProfileArgs(
encryption_at_host=True,
),
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="windows-data-science-vm",
publisher="microsoft-ads",
sku="windows2016",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_ONLY,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Standard_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_DS1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
plan: {
name: "windows2016",
product: "windows-data-science-vm",
publisher: "microsoft-ads",
},
resourceGroupName: "myResourceGroup",
securityProfile: {
encryptionAtHost: true,
},
storageProfile: {
imageReference: {
offer: "windows-data-science-vm",
publisher: "microsoft-ads",
sku: "windows2016",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadOnly,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Standard_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_DS1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
plan:
name: windows2016
product: windows-data-science-vm
publisher: microsoft-ads
resourceGroupName: myResourceGroup
securityProfile:
encryptionAtHost: true
storageProfile:
imageReference:
offer: windows-data-science-vm
publisher: microsoft-ads
sku: windows2016
version: latest
osDisk:
caching: ReadOnly
createOption: FromImage
managedDisk:
storageAccountType: Standard_LRS
name: myVMosdisk
vmName: myVM
Create a vm with Scheduled Events Profile
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
DiagnosticsProfile = new AzureNative.Compute.Inputs.DiagnosticsProfileArgs
{
BootDiagnostics = new AzureNative.Compute.Inputs.BootDiagnosticsArgs
{
Enabled = true,
StorageUri = "http://{existing-storage-account-name}.blob.core.windows.net",
},
},
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
ResourceGroupName = "myResourceGroup",
ScheduledEventsProfile = new AzureNative.Compute.Inputs.ScheduledEventsProfileArgs
{
TerminateNotificationProfile = new AzureNative.Compute.Inputs.TerminateNotificationProfileArgs
{
Enable = true,
NotBeforeTimeout = "PT10M",
},
},
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Standard_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.diagnosticsProfile(Map.of("bootDiagnostics", Map.ofEntries(
Map.entry("enabled", true),
Map.entry("storageUri", "http://{existing-storage-account-name}.blob.core.windows.net")
)))
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.resourceGroupName("myResourceGroup")
.scheduledEventsProfile(Map.of("terminateNotificationProfile", Map.ofEntries(
Map.entry("enable", true),
Map.entry("notBeforeTimeout", "PT10M")
)))
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2016-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
diagnostics_profile=azure_native.compute.DiagnosticsProfileResponseArgs(
boot_diagnostics=azure_native.compute.BootDiagnosticsArgs(
enabled=True,
storage_uri="http://{existing-storage-account-name}.blob.core.windows.net",
),
),
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
resource_group_name="myResourceGroup",
scheduled_events_profile=azure_native.compute.ScheduledEventsProfileResponseArgs(
terminate_notification_profile=azure_native.compute.TerminateNotificationProfileArgs(
enable=True,
not_before_timeout="PT10M",
),
),
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2016-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Standard_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
diagnosticsProfile: {
bootDiagnostics: {
enabled: true,
storageUri: "http://{existing-storage-account-name}.blob.core.windows.net",
},
},
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
resourceGroupName: "myResourceGroup",
scheduledEventsProfile: {
terminateNotificationProfile: {
enable: true,
notBeforeTimeout: "PT10M",
},
},
storageProfile: {
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2016-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Standard_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
diagnosticsProfile:
bootDiagnostics:
enabled: true
storageUri: http://{existing-storage-account-name}.blob.core.windows.net
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
resourceGroupName: myResourceGroup
scheduledEventsProfile:
terminateNotificationProfile:
enable: true
notBeforeTimeout: PT10M
storageProfile:
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2016-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Standard_LRS
name: myVMosdisk
vmName: myVM
Create a vm with a marketplace image plan.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
Plan = new AzureNative.Compute.Inputs.PlanArgs
{
Name = "windows2016",
Product = "windows-data-science-vm",
Publisher = "microsoft-ads",
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "windows-data-science-vm",
Publisher = "microsoft-ads",
Sku = "windows2016",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Standard_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.plan(Map.ofEntries(
Map.entry("name", "windows2016"),
Map.entry("product", "windows-data-science-vm"),
Map.entry("publisher", "microsoft-ads")
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "windows-data-science-vm"),
Map.entry("publisher", "microsoft-ads"),
Map.entry("sku", "windows2016"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
plan=azure_native.compute.PlanArgs(
name="windows2016",
product="windows-data-science-vm",
publisher="microsoft-ads",
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="windows-data-science-vm",
publisher="microsoft-ads",
sku="windows2016",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Standard_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
plan: {
name: "windows2016",
product: "windows-data-science-vm",
publisher: "microsoft-ads",
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "windows-data-science-vm",
publisher: "microsoft-ads",
sku: "windows2016",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Standard_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
plan:
name: windows2016
product: windows-data-science-vm
publisher: microsoft-ads
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: windows-data-science-vm
publisher: microsoft-ads
sku: windows2016
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Standard_LRS
name: myVMosdisk
vmName: myVM
Create a vm with an extensions time budget.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
DiagnosticsProfile = new AzureNative.Compute.Inputs.DiagnosticsProfileArgs
{
BootDiagnostics = new AzureNative.Compute.Inputs.BootDiagnosticsArgs
{
Enabled = true,
StorageUri = "http://{existing-storage-account-name}.blob.core.windows.net",
},
},
ExtensionsTimeBudget = "PT30M",
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version = "latest",
},
OsDisk = new AzureNative.Compute.Inputs.OSDiskArgs
{
Caching = AzureNative.Compute.CachingTypes.ReadWrite,
CreateOption = "FromImage",
ManagedDisk = new AzureNative.Compute.Inputs.ManagedDiskParametersArgs
{
StorageAccountType = "Standard_LRS",
},
Name = "myVMosdisk",
},
},
VmName = "myVM",
});
});
Coming soon!
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azurenative.compute.VirtualMachine;
import com.pulumi.azurenative.compute.VirtualMachineArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
public static void main(String[] args) {
Pulumi.run(App::stack);
}
public static void stack(Context ctx) {
var virtualMachine = new VirtualMachine("virtualMachine", VirtualMachineArgs.builder()
.diagnosticsProfile(Map.of("bootDiagnostics", Map.ofEntries(
Map.entry("enabled", true),
Map.entry("storageUri", "http://{existing-storage-account-name}.blob.core.windows.net")
)))
.extensionsTimeBudget("PT30M")
.hardwareProfile(Map.of("vmSize", "Standard_D1_v2"))
.location("westus")
.networkProfile(Map.of("networkInterfaces", Map.ofEntries(
Map.entry("id", "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}"),
Map.entry("primary", true)
)))
.osProfile(Map.ofEntries(
Map.entry("adminPassword", "{your-password}"),
Map.entry("adminUsername", "{your-username}"),
Map.entry("computerName", "myVM")
))
.resourceGroupName("myResourceGroup")
.storageProfile(Map.ofEntries(
Map.entry("imageReference", Map.ofEntries(
Map.entry("offer", "WindowsServer"),
Map.entry("publisher", "MicrosoftWindowsServer"),
Map.entry("sku", "2016-Datacenter"),
Map.entry("version", "latest")
)),
Map.entry("osDisk", Map.ofEntries(
Map.entry("caching", "ReadWrite"),
Map.entry("createOption", "FromImage"),
Map.entry("managedDisk", Map.of("storageAccountType", "Standard_LRS")),
Map.entry("name", "myVMosdisk")
))
))
.vmName("myVM")
.build());
}
}
import pulumi
import pulumi_azure_native as azure_native
virtual_machine = azure_native.compute.VirtualMachine("virtualMachine",
diagnostics_profile=azure_native.compute.DiagnosticsProfileResponseArgs(
boot_diagnostics=azure_native.compute.BootDiagnosticsArgs(
enabled=True,
storage_uri="http://{existing-storage-account-name}.blob.core.windows.net",
),
),
extensions_time_budget="PT30M",
hardware_profile=azure_native.compute.HardwareProfileArgs(
vm_size="Standard_D1_v2",
),
location="westus",
network_profile=azure_native.compute.NetworkProfileResponseArgs(
network_interfaces=[azure_native.compute.NetworkInterfaceReferenceArgs(
id="/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary=True,
)],
),
os_profile=azure_native.compute.OSProfileArgs(
admin_password="{your-password}",
admin_username="{your-username}",
computer_name="myVM",
),
resource_group_name="myResourceGroup",
storage_profile=azure_native.compute.StorageProfileResponseArgs(
image_reference=azure_native.compute.ImageReferenceArgs(
offer="WindowsServer",
publisher="MicrosoftWindowsServer",
sku="2016-Datacenter",
version="latest",
),
os_disk={
"caching": azure_native.compute.CachingTypes.READ_WRITE,
"createOption": "FromImage",
"managedDisk": azure_native.compute.ManagedDiskParametersArgs(
storage_account_type="Standard_LRS",
),
"name": "myVMosdisk",
},
),
vm_name="myVM")
import * as pulumi from "@pulumi/pulumi";
import * as azure_native from "@pulumi/azure-native";
const virtualMachine = new azure_native.compute.VirtualMachine("virtualMachine", {
diagnosticsProfile: {
bootDiagnostics: {
enabled: true,
storageUri: "http://{existing-storage-account-name}.blob.core.windows.net",
},
},
extensionsTimeBudget: "PT30M",
hardwareProfile: {
vmSize: "Standard_D1_v2",
},
location: "westus",
networkProfile: {
networkInterfaces: [{
id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
primary: true,
}],
},
osProfile: {
adminPassword: "{your-password}",
adminUsername: "{your-username}",
computerName: "myVM",
},
resourceGroupName: "myResourceGroup",
storageProfile: {
imageReference: {
offer: "WindowsServer",
publisher: "MicrosoftWindowsServer",
sku: "2016-Datacenter",
version: "latest",
},
osDisk: {
caching: azure_native.compute.CachingTypes.ReadWrite,
createOption: "FromImage",
managedDisk: {
storageAccountType: "Standard_LRS",
},
name: "myVMosdisk",
},
},
vmName: "myVM",
});
resources:
virtualMachine:
type: azure-native:compute:VirtualMachine
properties:
diagnosticsProfile:
bootDiagnostics:
enabled: true
storageUri: http://{existing-storage-account-name}.blob.core.windows.net
extensionsTimeBudget: PT30M
hardwareProfile:
vmSize: Standard_D1_v2
location: westus
networkProfile:
networkInterfaces:
- id: /subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}
primary: true
osProfile:
adminPassword: '{your-password}'
adminUsername: '{your-username}'
computerName: myVM
resourceGroupName: myResourceGroup
storageProfile:
imageReference:
offer: WindowsServer
publisher: MicrosoftWindowsServer
sku: 2016-Datacenter
version: latest
osDisk:
caching: ReadWrite
createOption: FromImage
managedDisk:
storageAccountType: Standard_LRS
name: myVMosdisk
vmName: myVM
Create a vm with boot diagnostics.
using System.Collections.Generic;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
var virtualMachine = new AzureNative.Compute.VirtualMachine("virtualMachine", new()
{
DiagnosticsProfile = new AzureNative.Compute.Inputs.DiagnosticsProfileArgs
{
BootDiagnostics = new AzureNative.Compute.Inputs.BootDiagnosticsArgs
{
Enabled = true,
StorageUri = "http://{existing-storage-account-name}.blob.core.windows.net",
},
},
HardwareProfile = new AzureNative.Compute.Inputs.HardwareProfileArgs
{
VmSize = "Standard_D1_v2",
},
Location = "westus",
NetworkProfile = new AzureNative.Compute.Inputs.NetworkProfileArgs
{
NetworkInterfaces = new[]
{
new AzureNative.Compute.Inputs.NetworkInterfaceReferenceArgs
{
Id = "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
Primary = true,
},
},
},
OsProfile = new AzureNative.Compute.Inputs.OSProfileArgs
{
AdminPassword = "{your-password}",
AdminUsername = "{your-username}",
ComputerName = "myVM",
},
ResourceGroupName = "myResourceGroup",
StorageProfile = new AzureNative.Compute.Inputs.StorageProfileArgs
{
ImageReference = new AzureNative.Compute.Inputs.ImageReferenceArgs
{
Offer = "WindowsServer",
Publisher = "MicrosoftWindowsServer",
Sku = "2016-Datacenter",
Version <