VirtualMachine

Provides a VirtualMachine from the Compute group

Examples

Create a vm with password authentication.

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            sku: "2016-Datacenter",
            publisher: "MicrosoftWindowsServer",
            version: "latest",
            offer: "WindowsServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Standard_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a vm with ssh authentication.

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            sku: "{image_sku}",
            publisher: "{image_publisher}",
            version: "latest",
            offer: "{image_offer}",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Standard_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          linuxConfiguration: {
            ssh: {
              publicKeys: [
                {
                  path: "/home/{your-username}/.ssh/authorized_keys",
                  keyData:
                    "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCeClRAk2ipUs/l5voIsDC5q9RI+YSRd1Bvd/O+axgY4WiBzG+4FwJWZm/mLLe5DoOdHQwmU2FrKXZSW4w2sYE70KeWnrFViCOX5MTVvJgPE8ClugNl8RWth/tU849DvM9sT7vFgfVSHcAS2yDRyDlueii+8nF2ym8XWAPltFVCyLHRsyBp5YPqK8JFYIa1eybKsY3hEAxRCA+/7bq8et+Gj3coOsuRmrehav7rE6N12Pb80I6ofa6SM5XNYq4Xk0iYNx7R3kdz0Jj9XgZYWjAHjJmT0gTRoOnt6upOuxK7xI/ykWrllgpXrCPu3Ymz+c+ujaqcxDopnAl2lmf69/J1",
                },
              ],
            },
            disablePasswordAuthentication: true,
          },
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a vm with premium storage.

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            sku: "2016-Datacenter",
            publisher: "MicrosoftWindowsServer",
            version: "latest",
            offer: "WindowsServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Premium_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

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

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            sku: "2016-Datacenter",
            publisher: "MicrosoftWindowsServer",
            version: "latest",
            offer: "WindowsServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Standard_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        virtualMachineScaleSet: {
          id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/virtualMachineScaleSets/{existing-flex-vmss-name-with-platformFaultDomainCount-greater-than-1}",
        },
        platformFaultDomain: 1,
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a vm in an availability set.

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            sku: "2016-Datacenter",
            publisher: "MicrosoftWindowsServer",
            version: "latest",
            offer: "WindowsServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Standard_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        availabilitySet: {
          id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/availabilitySets/{existing-availability-set-name}",
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a vm with Scheduled Events Profile

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            sku: "2016-Datacenter",
            publisher: "MicrosoftWindowsServer",
            version: "latest",
            offer: "WindowsServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Standard_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        diagnosticsProfile: {
          bootDiagnostics: {
            storageUri:
              "http://{existing-storage-account-name}.blob.core.windows.net",
            enabled: true,
          },
        },
        scheduledEventsProfile: {
          terminateNotificationProfile: {
            notBeforeTimeout: "PT10M",
            enable: true,
          },
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a vm with boot diagnostics.

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            sku: "2016-Datacenter",
            publisher: "MicrosoftWindowsServer",
            version: "latest",
            offer: "WindowsServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Standard_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        diagnosticsProfile: {
          bootDiagnostics: {
            storageUri:
              "http://{existing-storage-account-name}.blob.core.windows.net",
            enabled: true,
          },
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a vm with managed boot diagnostics.

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            sku: "2016-Datacenter",
            publisher: "MicrosoftWindowsServer",
            version: "latest",
            offer: "WindowsServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Standard_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        diagnosticsProfile: { bootDiagnostics: { enabled: true } },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a vm with empty data disks.

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D2_v2" },
        storageProfile: {
          imageReference: {
            sku: "2016-Datacenter",
            publisher: "MicrosoftWindowsServer",
            version: "latest",
            offer: "WindowsServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Standard_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
          dataDisks: [
            { diskSizeGB: 1023, createOption: "Empty", lun: 0 },
            { diskSizeGB: 1023, createOption: "Empty", lun: 1 },
          ],
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a vm with a marketplace image plan.

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      plan: {
        publisher: "microsoft-ads",
        product: "windows-data-science-vm",
        name: "windows2016",
      },
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            sku: "windows2016",
            publisher: "microsoft-ads",
            version: "latest",
            offer: "windows-data-science-vm",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Standard_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a vm from a custom image.

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Standard_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

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

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D2_v2" },
        storageProfile: {
          imageReference: {
            sku: "2016-Datacenter",
            publisher: "MicrosoftWindowsServer",
            version: "latest",
            offer: "WindowsServer",
          },
          osDisk: {
            caching: "ReadWrite",
            vhd: {
              uri: "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd",
            },
            createOption: "FromImage",
            name: "myVMosdisk",
          },
          dataDisks: [
            {
              diskSizeGB: 1023,
              createOption: "Empty",
              lun: 0,
              vhd: {
                uri: "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk0.vhd",
              },
            },
            {
              diskSizeGB: 1023,
              createOption: "Empty",
              lun: 1,
              vhd: {
                uri: "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk1.vhd",
              },
            },
          ],
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

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

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          osDisk: {
            name: "myVMosdisk",
            image: {
              uri: "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/{existing-generalized-os-image-blob-name}.vhd",
            },
            osType: "Windows",
            createOption: "FromImage",
            caching: "ReadWrite",
            vhd: {
              uri: "http://{existing-storage-account-name}.blob.core.windows.net/{existing-container-name}/myDisk.vhd",
            },
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a vm with ephemeral os disk.

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      plan: {
        publisher: "microsoft-ads",
        product: "windows-data-science-vm",
        name: "windows2016",
      },
      properties: {
        hardwareProfile: { vmSize: "Standard_DS1_v2" },
        storageProfile: {
          imageReference: {
            sku: "windows2016",
            publisher: "microsoft-ads",
            version: "latest",
            offer: "windows-data-science-vm",
          },
          osDisk: {
            caching: "ReadOnly",
            diffDiskSettings: { option: "Local" },
            managedDisk: { storageAccountType: "Standard_LRS" },
            createOption: "FromImage",
            name: "myVMosdisk",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

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

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/images/{existing-custom-image-name}",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: {
              storageAccountType: "Standard_LRS",
              diskEncryptionSet: {
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
              },
            },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
          dataDisks: [
            {
              caching: "ReadWrite",
              managedDisk: {
                storageAccountType: "Standard_LRS",
                diskEncryptionSet: {
                  id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                },
              },
              diskSizeGB: 1023,
              createOption: "Empty",
              lun: 0,
            },
            {
              caching: "ReadWrite",
              managedDisk: {
                id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/disks/{existing-managed-disk-name}",
                storageAccountType: "Standard_LRS",
                diskEncryptionSet: {
                  id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/diskEncryptionSets/{existing-diskEncryptionSet-name}",
                },
              },
              diskSizeGB: 1023,
              createOption: "Attach",
              lun: 1,
            },
          ],
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a vm with ephemeral os disk provisioning in Resource disk using placement property.

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      plan: {
        publisher: "microsoft-ads",
        product: "windows-data-science-vm",
        name: "windows2016",
      },
      properties: {
        hardwareProfile: { vmSize: "Standard_DS1_v2" },
        storageProfile: {
          imageReference: {
            sku: "windows2016",
            publisher: "microsoft-ads",
            version: "latest",
            offer: "windows-data-science-vm",
          },
          osDisk: {
            caching: "ReadOnly",
            diffDiskSettings: { option: "Local", placement: "ResourceDisk" },
            managedDisk: { storageAccountType: "Standard_LRS" },
            createOption: "FromImage",
            name: "myVMosdisk",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a vm with ephemeral os disk provisioning in Cache disk using placement property.

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      plan: {
        publisher: "microsoft-ads",
        product: "windows-data-science-vm",
        name: "windows2016",
      },
      properties: {
        hardwareProfile: { vmSize: "Standard_DS1_v2" },
        storageProfile: {
          imageReference: {
            sku: "windows2016",
            publisher: "microsoft-ads",
            version: "latest",
            offer: "windows-data-science-vm",
          },
          osDisk: {
            caching: "ReadOnly",
            diffDiskSettings: { option: "Local", placement: "CacheDisk" },
            managedDisk: { storageAccountType: "Standard_LRS" },
            createOption: "FromImage",
            name: "myVMosdisk",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a vm with Host Encryption using encryptionAtHost property.

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      plan: {
        publisher: "microsoft-ads",
        product: "windows-data-science-vm",
        name: "windows2016",
      },
      properties: {
        hardwareProfile: { vmSize: "Standard_DS1_v2" },
        securityProfile: { encryptionAtHost: true },
        storageProfile: {
          imageReference: {
            sku: "windows2016",
            publisher: "microsoft-ads",
            version: "latest",
            offer: "windows-data-science-vm",
          },
          osDisk: {
            caching: "ReadOnly",
            managedDisk: { storageAccountType: "Standard_LRS" },
            createOption: "FromImage",
            name: "myVMosdisk",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

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

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            sku: "2016-Datacenter",
            publisher: "MicrosoftWindowsServer",
            version: "latest",
            offer: "WindowsServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Premium_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
          windowsConfiguration: {
            provisionVMAgent: true,
            enableAutomaticUpdates: true,
            patchSettings: { patchMode: "AutomaticByOS" },
          },
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/nsgExistingNic",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a Windows vm with a patch setting patchMode of AutomaticByPlatform and AutomaticByPlatformSettings.

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            sku: "2016-Datacenter",
            publisher: "MicrosoftWindowsServer",
            version: "latest",
            offer: "WindowsServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Premium_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
          windowsConfiguration: {
            provisionVMAgent: true,
            enableAutomaticUpdates: true,
            patchSettings: {
              patchMode: "AutomaticByPlatform",
              assessmentMode: "AutomaticByPlatform",
              automaticByPlatformSettings: { rebootSetting: "Never" },
            },
          },
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

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

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            sku: "2016-Datacenter",
            publisher: "MicrosoftWindowsServer",
            version: "latest",
            offer: "WindowsServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Premium_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
          windowsConfiguration: {
            provisionVMAgent: true,
            enableAutomaticUpdates: true,
            patchSettings: {
              patchMode: "AutomaticByPlatform",
              assessmentMode: "AutomaticByPlatform",
            },
          },
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

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

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            sku: "2016-Datacenter",
            publisher: "MicrosoftWindowsServer",
            version: "latest",
            offer: "WindowsServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Premium_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
          windowsConfiguration: {
            provisionVMAgent: true,
            enableAutomaticUpdates: true,
            patchSettings: { patchMode: "Manual" },
          },
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

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

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            sku: "2016-Datacenter",
            publisher: "MicrosoftWindowsServer",
            version: "latest",
            offer: "WindowsServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Premium_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
          windowsConfiguration: {
            provisionVMAgent: true,
            enableAutomaticUpdates: true,
            patchSettings: { assessmentMode: "ImageDefault" },
          },
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

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

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            sku: "2016-Datacenter",
            publisher: "MicrosoftWindowsServer",
            version: "latest",
            offer: "WindowsServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Premium_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
          windowsConfiguration: {
            provisionVMAgent: true,
            enableAutomaticUpdates: true,
            patchSettings: {
              patchMode: "AutomaticByPlatform",
              enableHotpatching: true,
            },
          },
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

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

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D2s_v3" },
        storageProfile: {
          imageReference: {
            sku: "16.04-LTS",
            publisher: "Canonical",
            version: "latest",
            offer: "UbuntuServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Premium_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
          linuxConfiguration: {
            provisionVMAgent: true,
            patchSettings: {
              patchMode: "AutomaticByPlatform",
              assessmentMode: "AutomaticByPlatform",
            },
          },
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

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

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D2s_v3" },
        storageProfile: {
          imageReference: {
            sku: "16.04-LTS",
            publisher: "Canonical",
            version: "latest",
            offer: "UbuntuServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Premium_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
          linuxConfiguration: {
            provisionVMAgent: true,
            patchSettings: { patchMode: "ImageDefault" },
          },
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a Linux vm with a patch setting patchMode of AutomaticByPlatform and AutomaticByPlatformSettings.

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D2s_v3" },
        storageProfile: {
          imageReference: {
            sku: "16.04-LTS",
            publisher: "Canonical",
            version: "latest",
            offer: "UbuntuServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Premium_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
          linuxConfiguration: {
            provisionVMAgent: true,
            patchSettings: {
              patchMode: "AutomaticByPlatform",
              assessmentMode: "AutomaticByPlatform",
              automaticByPlatformSettings: { rebootSetting: "Never" },
            },
          },
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

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

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D2s_v3" },
        storageProfile: {
          imageReference: {
            sku: "16.04-LTS",
            publisher: "Canonical",
            version: "latest",
            offer: "UbuntuServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Premium_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
          linuxConfiguration: {
            provisionVMAgent: true,
            patchSettings: { assessmentMode: "ImageDefault" },
          },
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a vm with an extensions time budget.

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            sku: "2016-Datacenter",
            publisher: "MicrosoftWindowsServer",
            version: "latest",
            offer: "WindowsServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Standard_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        diagnosticsProfile: {
          bootDiagnostics: {
            storageUri:
              "http://{existing-storage-account-name}.blob.core.windows.net",
            enabled: true,
          },
        },
        extensionsTimeBudget: "PT30M",
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a VM with Uefi Settings of secureBoot and vTPM.

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D2s_v3" },
        securityProfile: {
          uefiSettings: { secureBootEnabled: true, vTpmEnabled: true },
          securityType: "TrustedLaunch",
        },
        storageProfile: {
          imageReference: {
            sku: "windows10-tvm",
            publisher: "MicrosoftWindowsServer",
            version: "18363.592.2001092016",
            offer: "windowsserver-gen2preview-preview",
          },
          osDisk: {
            caching: "ReadOnly",
            managedDisk: { storageAccountType: "StandardSSD_LRS" },
            createOption: "FromImage",
            name: "myVMosdisk",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a vm from a generalized shared image.

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Standard_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a vm from a specialized shared image.

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/mySharedGallery/images/mySharedImage",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Standard_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a VM with network interface configuration

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            sku: "2016-Datacenter",
            publisher: "MicrosoftWindowsServer",
            version: "latest",
            offer: "WindowsServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Standard_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        networkProfile: {
          networkApiVersion: "2020-11-01",
          networkInterfaceConfigurations: [
            {
              name: "{nic-config-name}",
              properties: {
                primary: true,
                deleteOption: "Delete",
                ipConfigurations: [
                  {
                    name: "{ip-config-name}",
                    properties: {
                      primary: true,
                      publicIPAddressConfiguration: {
                        name: "{publicIP-config-name}",
                        sku: { name: "Basic", tier: "Global" },
                        properties: {
                          deleteOption: "Detach",
                          publicIPAllocationMethod: "Static",
                        },
                      },
                    },
                  },
                ],
              },
            },
          ],
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a VM with UserData

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            sku: "2016-Datacenter",
            publisher: "MicrosoftWindowsServer",
            version: "latest",
            offer: "WindowsServer",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Standard_LRS" },
            name: "vmOSdisk",
            createOption: "FromImage",
          },
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "{vm-name}",
          adminPassword: "{your-password}",
        },
        diagnosticsProfile: {
          bootDiagnostics: {
            storageUri:
              "http://{existing-storage-account-name}.blob.core.windows.net",
            enabled: true,
          },
        },
        userData: "RXhhbXBsZSBVc2VyRGF0YQ==",
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      galleryImage: "myGalleryImage",
      networkSecurityGroups: ["myNetworkSecurityGroup"],
      proximityPlacementGroup: "myProximityPlacementGroup",
      dedicatedHostGroup: "myDedicatedHostGroup",
      capacityReservationGroup: "myCapacityReservationGroup",
      networkInterfaces: ["myNetworkInterface"],
      availabilitySet: "myAvailabilitySet",
      virtualMachineScaleSet: "myVirtualMachineScaleSet",
      virtualMachineScaleSetVm: "myVirtualMachineScaleSetVM",
    }),
  },
];

Create a vm with Application Profile.

exports.createResources = () => [
  {
    type: "VirtualMachine",
    group: "Compute",
    name: "myVirtualMachine",
    properties: () => ({
      location: "westus",
      properties: {
        hardwareProfile: { vmSize: "Standard_D1_v2" },
        storageProfile: {
          imageReference: {
            sku: "{image_sku}",
            publisher: "{image_publisher}",
            version: "latest",
            offer: "{image_offer}",
          },
          osDisk: {
            caching: "ReadWrite",
            managedDisk: { storageAccountType: "Standard_LRS" },
            name: "myVMosdisk",
            createOption: "FromImage",
          },
        },
        applicationProfile: {
          galleryApplications: [
            {
              tags: "myTag1",
              order: 1,
              packageReferenceId:
                "/subscriptions/32c17a9e-aa7b-4ba5-a45b-e324116b6fdb/resourceGroups/myresourceGroupName2/providers/Microsoft.Compute/galleries/myGallery1/applications/MyApplication1/versions/1.0",
              configurationReference:
                "https://mystorageaccount.blob.core.windows.net/configurations/settings.config",
              treatFailureAsDeploymentFailure: false,
              enableAutomaticUpgrade: false,
            },
            {
              packageReferenceId:
                "/subscriptions/32c17a9e-aa7b-4ba5-a45b-e324116b6fdg/resourceGroups/myresourceGroupName3/providers/Microsoft.Compute/galleries/myGallery2/applications/MyApplication2/versions/1.1",
            },
          ],
        },
        osProfile: {
          adminUsername: "{your-username}",
          computerName: "myVM",
          adminPassword: "{your-password}",
        },
        networkProfile: {
          networkInterfaces: [
            {
              id: "/subscriptions/{subscription-id}/resourceGroups/myResourceGroup/providers/Microsoft.Network/networkInterfaces/{existing-nic-name}",
              properties: { primary: true },
            },
          ],
        },
      },
    }),
    dependencies: ({}) => ({
      resourceGroup: "myResourceGroup",
      disks: ["myDisk"],
      managedIdentities: ["myUserAssignedIdentity"],
      sshPublicKeys: ["mySshPublicKey"],
      </