All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.pulumi.azure.compute.kotlin.VirtualMachine.kt Maven / Gradle / Ivy

@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.azure.compute.kotlin

import com.pulumi.azure.compute.kotlin.outputs.VirtualMachineAdditionalCapabilities
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachineBootDiagnostics
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachineIdentity
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachineOsProfile
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachineOsProfileLinuxConfig
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachineOsProfileSecret
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachineOsProfileWindowsConfig
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachinePlan
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachineStorageDataDisk
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachineStorageImageReference
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachineStorageOsDisk
import com.pulumi.core.Output
import com.pulumi.kotlin.KotlinCustomResource
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.ResourceMapper
import com.pulumi.kotlin.options.CustomResourceOptions
import com.pulumi.kotlin.options.CustomResourceOptionsBuilder
import com.pulumi.resources.Resource
import kotlin.Boolean
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.collections.Map
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachineAdditionalCapabilities.Companion.toKotlin as virtualMachineAdditionalCapabilitiesToKotlin
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachineBootDiagnostics.Companion.toKotlin as virtualMachineBootDiagnosticsToKotlin
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachineIdentity.Companion.toKotlin as virtualMachineIdentityToKotlin
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachineOsProfile.Companion.toKotlin as virtualMachineOsProfileToKotlin
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachineOsProfileLinuxConfig.Companion.toKotlin as virtualMachineOsProfileLinuxConfigToKotlin
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachineOsProfileSecret.Companion.toKotlin as virtualMachineOsProfileSecretToKotlin
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachineOsProfileWindowsConfig.Companion.toKotlin as virtualMachineOsProfileWindowsConfigToKotlin
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachinePlan.Companion.toKotlin as virtualMachinePlanToKotlin
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachineStorageDataDisk.Companion.toKotlin as virtualMachineStorageDataDiskToKotlin
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachineStorageImageReference.Companion.toKotlin as virtualMachineStorageImageReferenceToKotlin
import com.pulumi.azure.compute.kotlin.outputs.VirtualMachineStorageOsDisk.Companion.toKotlin as virtualMachineStorageOsDiskToKotlin

/**
 * Builder for [VirtualMachine].
 */
@PulumiTagMarker
public class VirtualMachineResourceBuilder internal constructor() {
    public var name: String? = null

    public var args: VirtualMachineArgs = VirtualMachineArgs()

    public var opts: CustomResourceOptions = CustomResourceOptions()

    /**
     * @param name The _unique_ name of the resulting resource.
     */
    public fun name(`value`: String) {
        this.name = value
    }

    /**
     * @param block The arguments to use to populate this resource's properties.
     */
    public suspend fun args(block: suspend VirtualMachineArgsBuilder.() -> Unit) {
        val builder = VirtualMachineArgsBuilder()
        block(builder)
        this.args = builder.build()
    }

    /**
     * @param block A bag of options that control this resource's behavior.
     */
    public suspend fun opts(block: suspend CustomResourceOptionsBuilder.() -> Unit) {
        this.opts = com.pulumi.kotlin.options.CustomResourceOptions.opts(block)
    }

    internal fun build(): VirtualMachine {
        val builtJavaResource = com.pulumi.azure.compute.VirtualMachine(
            this.name,
            this.args.toJava(),
            this.opts.toJava(),
        )
        return VirtualMachine(builtJavaResource)
    }
}

/**
 * Manages a Virtual Machine.
 * ## Disclaimers
 * > **Note:** The `azure.compute.VirtualMachine` resource has been superseded by the `azure.compute.LinuxVirtualMachine` and `azure.compute.WindowsVirtualMachine` resources. The existing `azure.compute.VirtualMachine` resource will continue to be available throughout the 2.x releases however is in a feature-frozen state to maintain compatibility - new functionality will instead be added to the `azure.compute.LinuxVirtualMachine` and `azure.compute.WindowsVirtualMachine` resources.
 * > **Note:** Data Disks can be attached either directly on the `azure.compute.VirtualMachine` resource, or using the `azure.compute.DataDiskAttachment` resource - but the two cannot be used together. If both are used against the same Virtual Machine, spurious changes will occur.
 * ## Example Usage
 * ### From An Azure Platform Image)
 * This example provisions a Virtual Machine with Managed Disks.
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as azure from "@pulumi/azure";
 * const config = new pulumi.Config();
 * const prefix = config.get("prefix") || "tfvmex";
 * const example = new azure.core.ResourceGroup("example", {
 *     name: `${prefix}-resources`,
 *     location: "West Europe",
 * });
 * const main = new azure.network.VirtualNetwork("main", {
 *     name: `${prefix}-network`,
 *     addressSpaces: ["10.0.0.0/16"],
 *     location: example.location,
 *     resourceGroupName: example.name,
 * });
 * const internal = new azure.network.Subnet("internal", {
 *     name: "internal",
 *     resourceGroupName: example.name,
 *     virtualNetworkName: main.name,
 *     addressPrefixes: ["10.0.2.0/24"],
 * });
 * const mainNetworkInterface = new azure.network.NetworkInterface("main", {
 *     name: `${prefix}-nic`,
 *     location: example.location,
 *     resourceGroupName: example.name,
 *     ipConfigurations: [{
 *         name: "testconfiguration1",
 *         subnetId: internal.id,
 *         privateIpAddressAllocation: "Dynamic",
 *     }],
 * });
 * const mainVirtualMachine = new azure.compute.VirtualMachine("main", {
 *     name: `${prefix}-vm`,
 *     location: example.location,
 *     resourceGroupName: example.name,
 *     networkInterfaceIds: [mainNetworkInterface.id],
 *     vmSize: "Standard_DS1_v2",
 *     storageImageReference: {
 *         publisher: "Canonical",
 *         offer: "0001-com-ubuntu-server-jammy",
 *         sku: "22_04-lts",
 *         version: "latest",
 *     },
 *     storageOsDisk: {
 *         name: "myosdisk1",
 *         caching: "ReadWrite",
 *         createOption: "FromImage",
 *         managedDiskType: "Standard_LRS",
 *     },
 *     osProfile: {
 *         computerName: "hostname",
 *         adminUsername: "testadmin",
 *         adminPassword: "Password1234!",
 *     },
 *     osProfileLinuxConfig: {
 *         disablePasswordAuthentication: false,
 *     },
 *     tags: {
 *         environment: "staging",
 *     },
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_azure as azure
 * config = pulumi.Config()
 * prefix = config.get("prefix")
 * if prefix is None:
 *     prefix = "tfvmex"
 * example = azure.core.ResourceGroup("example",
 *     name=f"{prefix}-resources",
 *     location="West Europe")
 * main = azure.network.VirtualNetwork("main",
 *     name=f"{prefix}-network",
 *     address_spaces=["10.0.0.0/16"],
 *     location=example.location,
 *     resource_group_name=example.name)
 * internal = azure.network.Subnet("internal",
 *     name="internal",
 *     resource_group_name=example.name,
 *     virtual_network_name=main.name,
 *     address_prefixes=["10.0.2.0/24"])
 * main_network_interface = azure.network.NetworkInterface("main",
 *     name=f"{prefix}-nic",
 *     location=example.location,
 *     resource_group_name=example.name,
 *     ip_configurations=[azure.network.NetworkInterfaceIpConfigurationArgs(
 *         name="testconfiguration1",
 *         subnet_id=internal.id,
 *         private_ip_address_allocation="Dynamic",
 *     )])
 * main_virtual_machine = azure.compute.VirtualMachine("main",
 *     name=f"{prefix}-vm",
 *     location=example.location,
 *     resource_group_name=example.name,
 *     network_interface_ids=[main_network_interface.id],
 *     vm_size="Standard_DS1_v2",
 *     storage_image_reference=azure.compute.VirtualMachineStorageImageReferenceArgs(
 *         publisher="Canonical",
 *         offer="0001-com-ubuntu-server-jammy",
 *         sku="22_04-lts",
 *         version="latest",
 *     ),
 *     storage_os_disk=azure.compute.VirtualMachineStorageOsDiskArgs(
 *         name="myosdisk1",
 *         caching="ReadWrite",
 *         create_option="FromImage",
 *         managed_disk_type="Standard_LRS",
 *     ),
 *     os_profile=azure.compute.VirtualMachineOsProfileArgs(
 *         computer_name="hostname",
 *         admin_username="testadmin",
 *         admin_password="Password1234!",
 *     ),
 *     os_profile_linux_config=azure.compute.VirtualMachineOsProfileLinuxConfigArgs(
 *         disable_password_authentication=False,
 *     ),
 *     tags={
 *         "environment": "staging",
 *     })
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Azure = Pulumi.Azure;
 * return await Deployment.RunAsync(() =>
 * {
 *     var config = new Config();
 *     var prefix = config.Get("prefix") ?? "tfvmex";
 *     var example = new Azure.Core.ResourceGroup("example", new()
 *     {
 *         Name = $"{prefix}-resources",
 *         Location = "West Europe",
 *     });
 *     var main = new Azure.Network.VirtualNetwork("main", new()
 *     {
 *         Name = $"{prefix}-network",
 *         AddressSpaces = new[]
 *         {
 *             "10.0.0.0/16",
 *         },
 *         Location = example.Location,
 *         ResourceGroupName = example.Name,
 *     });
 *     var @internal = new Azure.Network.Subnet("internal", new()
 *     {
 *         Name = "internal",
 *         ResourceGroupName = example.Name,
 *         VirtualNetworkName = main.Name,
 *         AddressPrefixes = new[]
 *         {
 *             "10.0.2.0/24",
 *         },
 *     });
 *     var mainNetworkInterface = new Azure.Network.NetworkInterface("main", new()
 *     {
 *         Name = $"{prefix}-nic",
 *         Location = example.Location,
 *         ResourceGroupName = example.Name,
 *         IpConfigurations = new[]
 *         {
 *             new Azure.Network.Inputs.NetworkInterfaceIpConfigurationArgs
 *             {
 *                 Name = "testconfiguration1",
 *                 SubnetId = @internal.Id,
 *                 PrivateIpAddressAllocation = "Dynamic",
 *             },
 *         },
 *     });
 *     var mainVirtualMachine = new Azure.Compute.VirtualMachine("main", new()
 *     {
 *         Name = $"{prefix}-vm",
 *         Location = example.Location,
 *         ResourceGroupName = example.Name,
 *         NetworkInterfaceIds = new[]
 *         {
 *             mainNetworkInterface.Id,
 *         },
 *         VmSize = "Standard_DS1_v2",
 *         StorageImageReference = new Azure.Compute.Inputs.VirtualMachineStorageImageReferenceArgs
 *         {
 *             Publisher = "Canonical",
 *             Offer = "0001-com-ubuntu-server-jammy",
 *             Sku = "22_04-lts",
 *             Version = "latest",
 *         },
 *         StorageOsDisk = new Azure.Compute.Inputs.VirtualMachineStorageOsDiskArgs
 *         {
 *             Name = "myosdisk1",
 *             Caching = "ReadWrite",
 *             CreateOption = "FromImage",
 *             ManagedDiskType = "Standard_LRS",
 *         },
 *         OsProfile = new Azure.Compute.Inputs.VirtualMachineOsProfileArgs
 *         {
 *             ComputerName = "hostname",
 *             AdminUsername = "testadmin",
 *             AdminPassword = "Password1234!",
 *         },
 *         OsProfileLinuxConfig = new Azure.Compute.Inputs.VirtualMachineOsProfileLinuxConfigArgs
 *         {
 *             DisablePasswordAuthentication = false,
 *         },
 *         Tags =
 *         {
 *             { "environment", "staging" },
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"fmt"
 * 	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/compute"
 * 	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
 * 	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/network"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi/config"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		cfg := config.New(ctx, "")
 * 		prefix := "tfvmex"
 * 		if param := cfg.Get("prefix"); param != "" {
 * 			prefix = param
 * 		}
 * 		example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
 * 			Name:     pulumi.String(fmt.Sprintf("%v-resources", prefix)),
 * 			Location: pulumi.String("West Europe"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		main, err := network.NewVirtualNetwork(ctx, "main", &network.VirtualNetworkArgs{
 * 			Name: pulumi.String(fmt.Sprintf("%v-network", prefix)),
 * 			AddressSpaces: pulumi.StringArray{
 * 				pulumi.String("10.0.0.0/16"),
 * 			},
 * 			Location:          example.Location,
 * 			ResourceGroupName: example.Name,
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		internal, err := network.NewSubnet(ctx, "internal", &network.SubnetArgs{
 * 			Name:               pulumi.String("internal"),
 * 			ResourceGroupName:  example.Name,
 * 			VirtualNetworkName: main.Name,
 * 			AddressPrefixes: pulumi.StringArray{
 * 				pulumi.String("10.0.2.0/24"),
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		mainNetworkInterface, err := network.NewNetworkInterface(ctx, "main", &network.NetworkInterfaceArgs{
 * 			Name:              pulumi.String(fmt.Sprintf("%v-nic", prefix)),
 * 			Location:          example.Location,
 * 			ResourceGroupName: example.Name,
 * 			IpConfigurations: network.NetworkInterfaceIpConfigurationArray{
 * 				&network.NetworkInterfaceIpConfigurationArgs{
 * 					Name:                       pulumi.String("testconfiguration1"),
 * 					SubnetId:                   internal.ID(),
 * 					PrivateIpAddressAllocation: pulumi.String("Dynamic"),
 * 				},
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = compute.NewVirtualMachine(ctx, "main", &compute.VirtualMachineArgs{
 * 			Name:              pulumi.String(fmt.Sprintf("%v-vm", prefix)),
 * 			Location:          example.Location,
 * 			ResourceGroupName: example.Name,
 * 			NetworkInterfaceIds: pulumi.StringArray{
 * 				mainNetworkInterface.ID(),
 * 			},
 * 			VmSize: pulumi.String("Standard_DS1_v2"),
 * 			StorageImageReference: &compute.VirtualMachineStorageImageReferenceArgs{
 * 				Publisher: pulumi.String("Canonical"),
 * 				Offer:     pulumi.String("0001-com-ubuntu-server-jammy"),
 * 				Sku:       pulumi.String("22_04-lts"),
 * 				Version:   pulumi.String("latest"),
 * 			},
 * 			StorageOsDisk: &compute.VirtualMachineStorageOsDiskArgs{
 * 				Name:            pulumi.String("myosdisk1"),
 * 				Caching:         pulumi.String("ReadWrite"),
 * 				CreateOption:    pulumi.String("FromImage"),
 * 				ManagedDiskType: pulumi.String("Standard_LRS"),
 * 			},
 * 			OsProfile: &compute.VirtualMachineOsProfileArgs{
 * 				ComputerName:  pulumi.String("hostname"),
 * 				AdminUsername: pulumi.String("testadmin"),
 * 				AdminPassword: pulumi.String("Password1234!"),
 * 			},
 * 			OsProfileLinuxConfig: &compute.VirtualMachineOsProfileLinuxConfigArgs{
 * 				DisablePasswordAuthentication: pulumi.Bool(false),
 * 			},
 * 			Tags: pulumi.StringMap{
 * 				"environment": pulumi.String("staging"),
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		return nil
 * 	})
 * }
 * ```
 * ```java
 * package generated_program;
 * import com.pulumi.Context;
 * import com.pulumi.Pulumi;
 * import com.pulumi.core.Output;
 * import com.pulumi.azure.core.ResourceGroup;
 * import com.pulumi.azure.core.ResourceGroupArgs;
 * import com.pulumi.azure.network.VirtualNetwork;
 * import com.pulumi.azure.network.VirtualNetworkArgs;
 * import com.pulumi.azure.network.Subnet;
 * import com.pulumi.azure.network.SubnetArgs;
 * import com.pulumi.azure.network.NetworkInterface;
 * import com.pulumi.azure.network.NetworkInterfaceArgs;
 * import com.pulumi.azure.network.inputs.NetworkInterfaceIpConfigurationArgs;
 * import com.pulumi.azure.compute.VirtualMachine;
 * import com.pulumi.azure.compute.VirtualMachineArgs;
 * import com.pulumi.azure.compute.inputs.VirtualMachineStorageImageReferenceArgs;
 * import com.pulumi.azure.compute.inputs.VirtualMachineStorageOsDiskArgs;
 * import com.pulumi.azure.compute.inputs.VirtualMachineOsProfileArgs;
 * import com.pulumi.azure.compute.inputs.VirtualMachineOsProfileLinuxConfigArgs;
 * 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) {
 *         final var config = ctx.config();
 *         final var prefix = config.get("prefix").orElse("tfvmex");
 *         var example = new ResourceGroup("example", ResourceGroupArgs.builder()
 *             .name(String.format("%s-resources", prefix))
 *             .location("West Europe")
 *             .build());
 *         var main = new VirtualNetwork("main", VirtualNetworkArgs.builder()
 *             .name(String.format("%s-network", prefix))
 *             .addressSpaces("10.0.0.0/16")
 *             .location(example.location())
 *             .resourceGroupName(example.name())
 *             .build());
 *         var internal = new Subnet("internal", SubnetArgs.builder()
 *             .name("internal")
 *             .resourceGroupName(example.name())
 *             .virtualNetworkName(main.name())
 *             .addressPrefixes("10.0.2.0/24")
 *             .build());
 *         var mainNetworkInterface = new NetworkInterface("mainNetworkInterface", NetworkInterfaceArgs.builder()
 *             .name(String.format("%s-nic", prefix))
 *             .location(example.location())
 *             .resourceGroupName(example.name())
 *             .ipConfigurations(NetworkInterfaceIpConfigurationArgs.builder()
 *                 .name("testconfiguration1")
 *                 .subnetId(internal.id())
 *                 .privateIpAddressAllocation("Dynamic")
 *                 .build())
 *             .build());
 *         var mainVirtualMachine = new VirtualMachine("mainVirtualMachine", VirtualMachineArgs.builder()
 *             .name(String.format("%s-vm", prefix))
 *             .location(example.location())
 *             .resourceGroupName(example.name())
 *             .networkInterfaceIds(mainNetworkInterface.id())
 *             .vmSize("Standard_DS1_v2")
 *             .storageImageReference(VirtualMachineStorageImageReferenceArgs.builder()
 *                 .publisher("Canonical")
 *                 .offer("0001-com-ubuntu-server-jammy")
 *                 .sku("22_04-lts")
 *                 .version("latest")
 *                 .build())
 *             .storageOsDisk(VirtualMachineStorageOsDiskArgs.builder()
 *                 .name("myosdisk1")
 *                 .caching("ReadWrite")
 *                 .createOption("FromImage")
 *                 .managedDiskType("Standard_LRS")
 *                 .build())
 *             .osProfile(VirtualMachineOsProfileArgs.builder()
 *                 .computerName("hostname")
 *                 .adminUsername("testadmin")
 *                 .adminPassword("Password1234!")
 *                 .build())
 *             .osProfileLinuxConfig(VirtualMachineOsProfileLinuxConfigArgs.builder()
 *                 .disablePasswordAuthentication(false)
 *                 .build())
 *             .tags(Map.of("environment", "staging"))
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * configuration:
 *   prefix:
 *     type: string
 *     default: tfvmex
 * resources:
 *   example:
 *     type: azure:core:ResourceGroup
 *     properties:
 *       name: ${prefix}-resources
 *       location: West Europe
 *   main:
 *     type: azure:network:VirtualNetwork
 *     properties:
 *       name: ${prefix}-network
 *       addressSpaces:
 *         - 10.0.0.0/16
 *       location: ${example.location}
 *       resourceGroupName: ${example.name}
 *   internal:
 *     type: azure:network:Subnet
 *     properties:
 *       name: internal
 *       resourceGroupName: ${example.name}
 *       virtualNetworkName: ${main.name}
 *       addressPrefixes:
 *         - 10.0.2.0/24
 *   mainNetworkInterface:
 *     type: azure:network:NetworkInterface
 *     name: main
 *     properties:
 *       name: ${prefix}-nic
 *       location: ${example.location}
 *       resourceGroupName: ${example.name}
 *       ipConfigurations:
 *         - name: testconfiguration1
 *           subnetId: ${internal.id}
 *           privateIpAddressAllocation: Dynamic
 *   mainVirtualMachine:
 *     type: azure:compute:VirtualMachine
 *     name: main
 *     properties:
 *       name: ${prefix}-vm
 *       location: ${example.location}
 *       resourceGroupName: ${example.name}
 *       networkInterfaceIds:
 *         - ${mainNetworkInterface.id}
 *       vmSize: Standard_DS1_v2
 *       storageImageReference:
 *         publisher: Canonical
 *         offer: 0001-com-ubuntu-server-jammy
 *         sku: 22_04-lts
 *         version: latest
 *       storageOsDisk:
 *         name: myosdisk1
 *         caching: ReadWrite
 *         createOption: FromImage
 *         managedDiskType: Standard_LRS
 *       osProfile:
 *         computerName: hostname
 *         adminUsername: testadmin
 *         adminPassword: Password1234!
 *       osProfileLinuxConfig:
 *         disablePasswordAuthentication: false
 *       tags:
 *         environment: staging
 * ```
 * 
 * ## Import
 * Virtual Machines can be imported using the `resource id`, e.g.
 * ```sh
 * $ pulumi import azure:compute/virtualMachine:VirtualMachine example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/mygroup1/providers/Microsoft.Compute/virtualMachines/machine1
 * ```
 */
public class VirtualMachine internal constructor(
    override val javaResource: com.pulumi.azure.compute.VirtualMachine,
) : KotlinCustomResource(javaResource, VirtualMachineMapper) {
    /**
     * An `additional_capabilities` block as defined below.
     */
    public val additionalCapabilities: Output?
        get() = javaResource.additionalCapabilities().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 -> virtualMachineAdditionalCapabilitiesToKotlin(args0) })
            }).orElse(null)
        })

    /**
     * The ID of the Availability Set in which the Virtual Machine should exist. Changing this forces a new resource to be created.
     */
    public val availabilitySetId: Output
        get() = javaResource.availabilitySetId().applyValue({ args0 -> args0 })

    /**
     * A `boot_diagnostics` block as defined below.
     */
    public val bootDiagnostics: Output?
        get() = javaResource.bootDiagnostics().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 -> virtualMachineBootDiagnosticsToKotlin(args0) })
            }).orElse(null)
        })

    /**
     * Should the Data Disks (either the Managed Disks / VHD Blobs) be deleted when the Virtual Machine is destroyed? Defaults to `false`.
     * > **Note:** This setting works when instance is deleted via the provider only and don't forget to delete disks manually if you deleted VM manually. It can increase spending.
     */
    public val deleteDataDisksOnTermination: Output?
        get() = javaResource.deleteDataDisksOnTermination().applyValue({ args0 ->
            args0.map({ args0 ->
                args0
            }).orElse(null)
        })

    /**
     * Should the OS Disk (either the Managed Disk / VHD Blob) be deleted when the Virtual Machine is destroyed? Defaults to `false`.
     * > **Note:** This setting works when instance is deleted via the provider only and don't forget to delete disks manually if you deleted VM manually. It can increase spending.
     */
    public val deleteOsDiskOnTermination: Output?
        get() = javaResource.deleteOsDiskOnTermination().applyValue({ args0 ->
            args0.map({ args0 ->
                args0
            }).orElse(null)
        })

    /**
     * An `identity` block as defined below.
     */
    public val identity: Output?
        get() = javaResource.identity().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 ->
                    virtualMachineIdentityToKotlin(args0)
                })
            }).orElse(null)
        })

    /**
     * Specifies the BYOL Type for this Virtual Machine. This is only applicable to Windows Virtual Machines. Possible values are `Windows_Client` and `Windows_Server`.
     */
    public val licenseType: Output
        get() = javaResource.licenseType().applyValue({ args0 -> args0 })

    /**
     * Specifies the Azure Region where the Virtual Machine exists. Changing this forces a new resource to be created.
     */
    public val location: Output
        get() = javaResource.location().applyValue({ args0 -> args0 })

    /**
     * Specifies the name of the Virtual Machine. Changing this forces a new resource to be created.
     */
    public val name: Output
        get() = javaResource.name().applyValue({ args0 -> args0 })

    /**
     * A list of Network Interface IDs which should be associated with the Virtual Machine.
     */
    public val networkInterfaceIds: Output>
        get() = javaResource.networkInterfaceIds().applyValue({ args0 -> args0.map({ args0 -> args0 }) })

    /**
     * An `os_profile` block as defined below. Required when `create_option` in the `storage_os_disk` block is set to `FromImage`.
     */
    public val osProfile: Output?
        get() = javaResource.osProfile().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 ->
                    virtualMachineOsProfileToKotlin(args0)
                })
            }).orElse(null)
        })

    /**
     * (Required, when a Linux machine) An `os_profile_linux_config` block as defined below.
     */
    public val osProfileLinuxConfig: Output?
        get() = javaResource.osProfileLinuxConfig().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 -> virtualMachineOsProfileLinuxConfigToKotlin(args0) })
            }).orElse(null)
        })

    /**
     * One or more `os_profile_secrets` blocks as defined below.
     */
    public val osProfileSecrets: Output>?
        get() = javaResource.osProfileSecrets().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.map({ args0 ->
                    args0.let({ args0 ->
                        virtualMachineOsProfileSecretToKotlin(args0)
                    })
                })
            }).orElse(null)
        })

    /**
     * (Required, when a Windows machine) An `os_profile_windows_config` block as defined below.
     */
    public val osProfileWindowsConfig: Output?
        get() = javaResource.osProfileWindowsConfig().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 -> virtualMachineOsProfileWindowsConfigToKotlin(args0) })
            }).orElse(null)
        })

    /**
     * A `plan` block as defined below.
     */
    public val plan: Output?
        get() = javaResource.plan().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 ->
                    virtualMachinePlanToKotlin(args0)
                })
            }).orElse(null)
        })

    /**
     * The ID of the Network Interface (which must be attached to the Virtual Machine) which should be the Primary Network Interface for this Virtual Machine.
     */
    public val primaryNetworkInterfaceId: Output?
        get() = javaResource.primaryNetworkInterfaceId().applyValue({ args0 ->
            args0.map({ args0 ->
                args0
            }).orElse(null)
        })

    /**
     * The ID of the Proximity Placement Group to which this Virtual Machine should be assigned. Changing this forces a new resource to be created
     */
    public val proximityPlacementGroupId: Output?
        get() = javaResource.proximityPlacementGroupId().applyValue({ args0 ->
            args0.map({ args0 ->
                args0
            }).orElse(null)
        })

    /**
     * Specifies the name of the Resource Group in which the Virtual Machine should exist. Changing this forces a new resource to be created.
     */
    public val resourceGroupName: Output
        get() = javaResource.resourceGroupName().applyValue({ args0 -> args0 })

    /**
     * One or more `storage_data_disk` blocks as defined below.
     * > **Please Note:** Data Disks can also be attached either using this block or the `azure.compute.DataDiskAttachment` resource - but not both.
     */
    public val storageDataDisks: Output>
        get() = javaResource.storageDataDisks().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.let({ args0 -> virtualMachineStorageDataDiskToKotlin(args0) })
            })
        })

    /**
     * A `storage_image_reference` block as defined below. Changing this forces a new resource to be created.
     */
    public val storageImageReference: Output
        get() = javaResource.storageImageReference().applyValue({ args0 ->
            args0.let({ args0 ->
                virtualMachineStorageImageReferenceToKotlin(args0)
            })
        })

    /**
     * A `storage_os_disk` block as defined below.
     */
    public val storageOsDisk: Output
        get() = javaResource.storageOsDisk().applyValue({ args0 ->
            args0.let({ args0 ->
                virtualMachineStorageOsDiskToKotlin(args0)
            })
        })

    /**
     * A mapping of tags to assign to the Virtual Machine.
     */
    public val tags: Output>?
        get() = javaResource.tags().applyValue({ args0 ->
            args0.map({ args0 ->
                args0.map({ args0 ->
                    args0.key.to(args0.value)
                }).toMap()
            }).orElse(null)
        })

    /**
     * Specifies the [size of the Virtual Machine](https://docs.microsoft.com/azure/virtual-machines/sizes-general). See also [Azure VM Naming Conventions](https://docs.microsoft.com/azure/virtual-machines/vm-naming-conventions).
     */
    public val vmSize: Output
        get() = javaResource.vmSize().applyValue({ args0 -> args0 })

    /**
     * A list of a single item of the Availability Zone which the Virtual Machine should be allocated in. Changing this forces a new resource to be created.
     * > **Please Note**: Availability Zones are [only supported in several regions at this time](https://docs.microsoft.com/azure/availability-zones/az-overview).
     * For more information on the different example configurations, please check out the [Azure documentation](https://docs.microsoft.com/en-gb/rest/api/compute/virtualmachines/createorupdate#examples)
     */
    public val zones: Output?
        get() = javaResource.zones().applyValue({ args0 -> args0.map({ args0 -> args0 }).orElse(null) })
}

public object VirtualMachineMapper : ResourceMapper {
    override fun supportsMappingOfType(javaResource: Resource): Boolean =
        com.pulumi.azure.compute.VirtualMachine::class == javaResource::class

    override fun map(javaResource: Resource): VirtualMachine = VirtualMachine(
        javaResource as
            com.pulumi.azure.compute.VirtualMachine,
    )
}

/**
 * @see [VirtualMachine].
 * @param name The _unique_ name of the resulting resource.
 * @param block Builder for [VirtualMachine].
 */
public suspend fun virtualMachine(
    name: String,
    block: suspend VirtualMachineResourceBuilder.() -> Unit,
): VirtualMachine {
    val builder = VirtualMachineResourceBuilder()
    builder.name(name)
    block(builder)
    return builder.build()
}

/**
 * @see [VirtualMachine].
 * @param name The _unique_ name of the resulting resource.
 */
public fun virtualMachine(name: String): VirtualMachine {
    val builder = VirtualMachineResourceBuilder()
    builder.name(name)
    return builder.build()
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy