Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
@file:Suppress("NAME_SHADOWING", "DEPRECATION")
package com.pulumi.azure.siterecovery.kotlin
import com.pulumi.azure.siterecovery.kotlin.outputs.VmwareReplicatedVmManagedDisk
import com.pulumi.azure.siterecovery.kotlin.outputs.VmwareReplicatedVmNetworkInterface
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 com.pulumi.azure.siterecovery.kotlin.outputs.VmwareReplicatedVmManagedDisk.Companion.toKotlin as vmwareReplicatedVmManagedDiskToKotlin
import com.pulumi.azure.siterecovery.kotlin.outputs.VmwareReplicatedVmNetworkInterface.Companion.toKotlin as vmwareReplicatedVmNetworkInterfaceToKotlin
/**
* Builder for [VmwareReplicatedVm].
*/
@PulumiTagMarker
public class VmwareReplicatedVmResourceBuilder internal constructor() {
public var name: String? = null
public var args: VmwareReplicatedVmArgs = VmwareReplicatedVmArgs()
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 VmwareReplicatedVmArgsBuilder.() -> Unit) {
val builder = VmwareReplicatedVmArgsBuilder()
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(): VmwareReplicatedVm {
val builtJavaResource =
com.pulumi.azure.siterecovery.VmwareReplicatedVm(
this.name,
this.args.toJava(),
this.opts.toJava(),
)
return VmwareReplicatedVm(builtJavaResource)
}
}
/**
* Manages a VMWare replicated VM using Azure Site Recovery (VMWare to Azure only). A replicated VM keeps a copiously updated image of the VM in Azure in order to be able to start the VM in Azure in case of a disaster.
* ## Example Usage
*
* ```typescript
* import * as pulumi from "@pulumi/pulumi";
* import * as azure from "@pulumi/azure";
* const example = new azure.core.ResourceGroup("example", {
* name: "example-rg",
* location: "West US",
* });
* const exampleVault = new azure.recoveryservices.Vault("example", {
* name: "example-recovery-vault",
* location: example.location,
* resourceGroupName: example.name,
* sku: "Standard",
* });
* const exampleVMWareReplicationPolicy = new azure.siterecovery.VMWareReplicationPolicy("example", {
* recoveryVaultId: exampleVault.id,
* name: "example-policy",
* recoveryPointRetentionInMinutes: 1440,
* applicationConsistentSnapshotFrequencyInMinutes: 240,
* });
* const test = new azure.siterecovery.VmwareReplicationPolicyAssociation("test", {
* name: "example-association",
* recoveryVaultId: exampleVault.id,
* policyId: exampleVMWareReplicationPolicy.id,
* });
* const exampleAccount = new azure.storage.Account("example", {
* name: "examplestorageacc",
* resourceGroupName: example.name,
* location: example.location,
* accountTier: "Standard",
* accountKind: "StorageV2",
* accountReplicationType: "LRS",
* });
* const exampleVirtualNetwork = new azure.network.VirtualNetwork("example", {
* name: "example-net",
* resourceGroupName: example.name,
* addressSpaces: ["192.168.2.0/24"],
* location: example.location,
* });
* const exampleSubnet = new azure.network.Subnet("example", {
* name: "example-subnet",
* resourceGroupName: example.name,
* virtualNetworkName: exampleVirtualNetwork.name,
* addressPrefixes: ["192.168.2.0/24"],
* });
* const exampleVmwareReplicatedVm = new azure.siterecovery.VmwareReplicatedVm("example", {
* name: "example-vmware-vm",
* recoveryVaultId: exampleVault.id,
* sourceVmName: "example-vm",
* applianceName: "example-appliance",
* recoveryReplicationPolicyId: exampleAzurermSiteRecoveryVmwareReplicationPolicyAssociation.policyId,
* physicalServerCredentialName: "example-creds",
* licenseType: "NotSpecified",
* targetBootDiagnosticsStorageAccountId: exampleAccount.id,
* targetVmName: "example_replicated_vm",
* targetResourceGroupId: example.id,
* defaultLogStorageAccountId: exampleAccount.id,
* defaultRecoveryDiskType: "Standard_LRS",
* targetNetworkId: exampleVirtualNetwork.id,
* networkInterfaces: [{
* sourceMacAddress: "00:00:00:00:00:00",
* targetSubnetName: exampleSubnet.name,
* isPrimary: true,
* }],
* });
* ```
* ```python
* import pulumi
* import pulumi_azure as azure
* example = azure.core.ResourceGroup("example",
* name="example-rg",
* location="West US")
* example_vault = azure.recoveryservices.Vault("example",
* name="example-recovery-vault",
* location=example.location,
* resource_group_name=example.name,
* sku="Standard")
* example_vm_ware_replication_policy = azure.siterecovery.VMWareReplicationPolicy("example",
* recovery_vault_id=example_vault.id,
* name="example-policy",
* recovery_point_retention_in_minutes=1440,
* application_consistent_snapshot_frequency_in_minutes=240)
* test = azure.siterecovery.VmwareReplicationPolicyAssociation("test",
* name="example-association",
* recovery_vault_id=example_vault.id,
* policy_id=example_vm_ware_replication_policy.id)
* example_account = azure.storage.Account("example",
* name="examplestorageacc",
* resource_group_name=example.name,
* location=example.location,
* account_tier="Standard",
* account_kind="StorageV2",
* account_replication_type="LRS")
* example_virtual_network = azure.network.VirtualNetwork("example",
* name="example-net",
* resource_group_name=example.name,
* address_spaces=["192.168.2.0/24"],
* location=example.location)
* example_subnet = azure.network.Subnet("example",
* name="example-subnet",
* resource_group_name=example.name,
* virtual_network_name=example_virtual_network.name,
* address_prefixes=["192.168.2.0/24"])
* example_vmware_replicated_vm = azure.siterecovery.VmwareReplicatedVm("example",
* name="example-vmware-vm",
* recovery_vault_id=example_vault.id,
* source_vm_name="example-vm",
* appliance_name="example-appliance",
* recovery_replication_policy_id=example_azurerm_site_recovery_vmware_replication_policy_association["policyId"],
* physical_server_credential_name="example-creds",
* license_type="NotSpecified",
* target_boot_diagnostics_storage_account_id=example_account.id,
* target_vm_name="example_replicated_vm",
* target_resource_group_id=example.id,
* default_log_storage_account_id=example_account.id,
* default_recovery_disk_type="Standard_LRS",
* target_network_id=example_virtual_network.id,
* network_interfaces=[{
* "source_mac_address": "00:00:00:00:00:00",
* "target_subnet_name": example_subnet.name,
* "is_primary": True,
* }])
* ```
* ```csharp
* using System.Collections.Generic;
* using System.Linq;
* using Pulumi;
* using Azure = Pulumi.Azure;
* return await Deployment.RunAsync(() =>
* {
* var example = new Azure.Core.ResourceGroup("example", new()
* {
* Name = "example-rg",
* Location = "West US",
* });
* var exampleVault = new Azure.RecoveryServices.Vault("example", new()
* {
* Name = "example-recovery-vault",
* Location = example.Location,
* ResourceGroupName = example.Name,
* Sku = "Standard",
* });
* var exampleVMWareReplicationPolicy = new Azure.SiteRecovery.VMWareReplicationPolicy("example", new()
* {
* RecoveryVaultId = exampleVault.Id,
* Name = "example-policy",
* RecoveryPointRetentionInMinutes = 1440,
* ApplicationConsistentSnapshotFrequencyInMinutes = 240,
* });
* var test = new Azure.SiteRecovery.VmwareReplicationPolicyAssociation("test", new()
* {
* Name = "example-association",
* RecoveryVaultId = exampleVault.Id,
* PolicyId = exampleVMWareReplicationPolicy.Id,
* });
* var exampleAccount = new Azure.Storage.Account("example", new()
* {
* Name = "examplestorageacc",
* ResourceGroupName = example.Name,
* Location = example.Location,
* AccountTier = "Standard",
* AccountKind = "StorageV2",
* AccountReplicationType = "LRS",
* });
* var exampleVirtualNetwork = new Azure.Network.VirtualNetwork("example", new()
* {
* Name = "example-net",
* ResourceGroupName = example.Name,
* AddressSpaces = new[]
* {
* "192.168.2.0/24",
* },
* Location = example.Location,
* });
* var exampleSubnet = new Azure.Network.Subnet("example", new()
* {
* Name = "example-subnet",
* ResourceGroupName = example.Name,
* VirtualNetworkName = exampleVirtualNetwork.Name,
* AddressPrefixes = new[]
* {
* "192.168.2.0/24",
* },
* });
* var exampleVmwareReplicatedVm = new Azure.SiteRecovery.VmwareReplicatedVm("example", new()
* {
* Name = "example-vmware-vm",
* RecoveryVaultId = exampleVault.Id,
* SourceVmName = "example-vm",
* ApplianceName = "example-appliance",
* RecoveryReplicationPolicyId = exampleAzurermSiteRecoveryVmwareReplicationPolicyAssociation.PolicyId,
* PhysicalServerCredentialName = "example-creds",
* LicenseType = "NotSpecified",
* TargetBootDiagnosticsStorageAccountId = exampleAccount.Id,
* TargetVmName = "example_replicated_vm",
* TargetResourceGroupId = example.Id,
* DefaultLogStorageAccountId = exampleAccount.Id,
* DefaultRecoveryDiskType = "Standard_LRS",
* TargetNetworkId = exampleVirtualNetwork.Id,
* NetworkInterfaces = new[]
* {
* new Azure.SiteRecovery.Inputs.VmwareReplicatedVmNetworkInterfaceArgs
* {
* SourceMacAddress = "00:00:00:00:00:00",
* TargetSubnetName = exampleSubnet.Name,
* IsPrimary = true,
* },
* },
* });
* });
* ```
* ```go
* package main
* import (
* "github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
* "github.com/pulumi/pulumi-azure/sdk/v5/go/azure/network"
* "github.com/pulumi/pulumi-azure/sdk/v5/go/azure/recoveryservices"
* "github.com/pulumi/pulumi-azure/sdk/v5/go/azure/siterecovery"
* "github.com/pulumi/pulumi-azure/sdk/v5/go/azure/storage"
* "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
* )
* func main() {
* pulumi.Run(func(ctx *pulumi.Context) error {
* example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
* Name: pulumi.String("example-rg"),
* Location: pulumi.String("West US"),
* })
* if err != nil {
* return err
* }
* exampleVault, err := recoveryservices.NewVault(ctx, "example", &recoveryservices.VaultArgs{
* Name: pulumi.String("example-recovery-vault"),
* Location: example.Location,
* ResourceGroupName: example.Name,
* Sku: pulumi.String("Standard"),
* })
* if err != nil {
* return err
* }
* exampleVMWareReplicationPolicy, err := siterecovery.NewVMWareReplicationPolicy(ctx, "example", &siterecovery.VMWareReplicationPolicyArgs{
* RecoveryVaultId: exampleVault.ID(),
* Name: pulumi.String("example-policy"),
* RecoveryPointRetentionInMinutes: pulumi.Int(1440),
* ApplicationConsistentSnapshotFrequencyInMinutes: pulumi.Int(240),
* })
* if err != nil {
* return err
* }
* _, err = siterecovery.NewVmwareReplicationPolicyAssociation(ctx, "test", &siterecovery.VmwareReplicationPolicyAssociationArgs{
* Name: pulumi.String("example-association"),
* RecoveryVaultId: exampleVault.ID(),
* PolicyId: exampleVMWareReplicationPolicy.ID(),
* })
* if err != nil {
* return err
* }
* exampleAccount, err := storage.NewAccount(ctx, "example", &storage.AccountArgs{
* Name: pulumi.String("examplestorageacc"),
* ResourceGroupName: example.Name,
* Location: example.Location,
* AccountTier: pulumi.String("Standard"),
* AccountKind: pulumi.String("StorageV2"),
* AccountReplicationType: pulumi.String("LRS"),
* })
* if err != nil {
* return err
* }
* exampleVirtualNetwork, err := network.NewVirtualNetwork(ctx, "example", &network.VirtualNetworkArgs{
* Name: pulumi.String("example-net"),
* ResourceGroupName: example.Name,
* AddressSpaces: pulumi.StringArray{
* pulumi.String("192.168.2.0/24"),
* },
* Location: example.Location,
* })
* if err != nil {
* return err
* }
* exampleSubnet, err := network.NewSubnet(ctx, "example", &network.SubnetArgs{
* Name: pulumi.String("example-subnet"),
* ResourceGroupName: example.Name,
* VirtualNetworkName: exampleVirtualNetwork.Name,
* AddressPrefixes: pulumi.StringArray{
* pulumi.String("192.168.2.0/24"),
* },
* })
* if err != nil {
* return err
* }
* _, err = siterecovery.NewVmwareReplicatedVm(ctx, "example", &siterecovery.VmwareReplicatedVmArgs{
* Name: pulumi.String("example-vmware-vm"),
* RecoveryVaultId: exampleVault.ID(),
* SourceVmName: pulumi.String("example-vm"),
* ApplianceName: pulumi.String("example-appliance"),
* RecoveryReplicationPolicyId: pulumi.Any(exampleAzurermSiteRecoveryVmwareReplicationPolicyAssociation.PolicyId),
* PhysicalServerCredentialName: pulumi.String("example-creds"),
* LicenseType: pulumi.String("NotSpecified"),
* TargetBootDiagnosticsStorageAccountId: exampleAccount.ID(),
* TargetVmName: pulumi.String("example_replicated_vm"),
* TargetResourceGroupId: example.ID(),
* DefaultLogStorageAccountId: exampleAccount.ID(),
* DefaultRecoveryDiskType: pulumi.String("Standard_LRS"),
* TargetNetworkId: exampleVirtualNetwork.ID(),
* NetworkInterfaces: siterecovery.VmwareReplicatedVmNetworkInterfaceArray{
* &siterecovery.VmwareReplicatedVmNetworkInterfaceArgs{
* SourceMacAddress: pulumi.String("00:00:00:00:00:00"),
* TargetSubnetName: exampleSubnet.Name,
* IsPrimary: pulumi.Bool(true),
* },
* },
* })
* 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.recoveryservices.Vault;
* import com.pulumi.azure.recoveryservices.VaultArgs;
* import com.pulumi.azure.siterecovery.VMWareReplicationPolicy;
* import com.pulumi.azure.siterecovery.VMWareReplicationPolicyArgs;
* import com.pulumi.azure.siterecovery.VmwareReplicationPolicyAssociation;
* import com.pulumi.azure.siterecovery.VmwareReplicationPolicyAssociationArgs;
* import com.pulumi.azure.storage.Account;
* import com.pulumi.azure.storage.AccountArgs;
* 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.siterecovery.VmwareReplicatedVm;
* import com.pulumi.azure.siterecovery.VmwareReplicatedVmArgs;
* import com.pulumi.azure.siterecovery.inputs.VmwareReplicatedVmNetworkInterfaceArgs;
* import java.util.List;
* import java.util.ArrayList;
* import java.util.Map;
* import java.io.File;
* import java.nio.file.Files;
* import java.nio.file.Paths;
* public class App {
* public static void main(String[] args) {
* Pulumi.run(App::stack);
* }
* public static void stack(Context ctx) {
* var example = new ResourceGroup("example", ResourceGroupArgs.builder()
* .name("example-rg")
* .location("West US")
* .build());
* var exampleVault = new Vault("exampleVault", VaultArgs.builder()
* .name("example-recovery-vault")
* .location(example.location())
* .resourceGroupName(example.name())
* .sku("Standard")
* .build());
* var exampleVMWareReplicationPolicy = new VMWareReplicationPolicy("exampleVMWareReplicationPolicy", VMWareReplicationPolicyArgs.builder()
* .recoveryVaultId(exampleVault.id())
* .name("example-policy")
* .recoveryPointRetentionInMinutes(1440)
* .applicationConsistentSnapshotFrequencyInMinutes(240)
* .build());
* var test = new VmwareReplicationPolicyAssociation("test", VmwareReplicationPolicyAssociationArgs.builder()
* .name("example-association")
* .recoveryVaultId(exampleVault.id())
* .policyId(exampleVMWareReplicationPolicy.id())
* .build());
* var exampleAccount = new Account("exampleAccount", AccountArgs.builder()
* .name("examplestorageacc")
* .resourceGroupName(example.name())
* .location(example.location())
* .accountTier("Standard")
* .accountKind("StorageV2")
* .accountReplicationType("LRS")
* .build());
* var exampleVirtualNetwork = new VirtualNetwork("exampleVirtualNetwork", VirtualNetworkArgs.builder()
* .name("example-net")
* .resourceGroupName(example.name())
* .addressSpaces("192.168.2.0/24")
* .location(example.location())
* .build());
* var exampleSubnet = new Subnet("exampleSubnet", SubnetArgs.builder()
* .name("example-subnet")
* .resourceGroupName(example.name())
* .virtualNetworkName(exampleVirtualNetwork.name())
* .addressPrefixes("192.168.2.0/24")
* .build());
* var exampleVmwareReplicatedVm = new VmwareReplicatedVm("exampleVmwareReplicatedVm", VmwareReplicatedVmArgs.builder()
* .name("example-vmware-vm")
* .recoveryVaultId(exampleVault.id())
* .sourceVmName("example-vm")
* .applianceName("example-appliance")
* .recoveryReplicationPolicyId(exampleAzurermSiteRecoveryVmwareReplicationPolicyAssociation.policyId())
* .physicalServerCredentialName("example-creds")
* .licenseType("NotSpecified")
* .targetBootDiagnosticsStorageAccountId(exampleAccount.id())
* .targetVmName("example_replicated_vm")
* .targetResourceGroupId(example.id())
* .defaultLogStorageAccountId(exampleAccount.id())
* .defaultRecoveryDiskType("Standard_LRS")
* .targetNetworkId(exampleVirtualNetwork.id())
* .networkInterfaces(VmwareReplicatedVmNetworkInterfaceArgs.builder()
* .sourceMacAddress("00:00:00:00:00:00")
* .targetSubnetName(exampleSubnet.name())
* .isPrimary(true)
* .build())
* .build());
* }
* }
* ```
* ```yaml
* resources:
* example:
* type: azure:core:ResourceGroup
* properties:
* name: example-rg
* location: West US
* exampleVault:
* type: azure:recoveryservices:Vault
* name: example
* properties:
* name: example-recovery-vault
* location: ${example.location}
* resourceGroupName: ${example.name}
* sku: Standard
* exampleVMWareReplicationPolicy:
* type: azure:siterecovery:VMWareReplicationPolicy
* name: example
* properties:
* recoveryVaultId: ${exampleVault.id}
* name: example-policy
* recoveryPointRetentionInMinutes: 1440
* applicationConsistentSnapshotFrequencyInMinutes: 240
* test:
* type: azure:siterecovery:VmwareReplicationPolicyAssociation
* properties:
* name: example-association
* recoveryVaultId: ${exampleVault.id}
* policyId: ${exampleVMWareReplicationPolicy.id}
* exampleAccount:
* type: azure:storage:Account
* name: example
* properties:
* name: examplestorageacc
* resourceGroupName: ${example.name}
* location: ${example.location}
* accountTier: Standard
* accountKind: StorageV2
* accountReplicationType: LRS
* exampleVirtualNetwork:
* type: azure:network:VirtualNetwork
* name: example
* properties:
* name: example-net
* resourceGroupName: ${example.name}
* addressSpaces:
* - 192.168.2.0/24
* location: ${example.location}
* exampleSubnet:
* type: azure:network:Subnet
* name: example
* properties:
* name: example-subnet
* resourceGroupName: ${example.name}
* virtualNetworkName: ${exampleVirtualNetwork.name}
* addressPrefixes:
* - 192.168.2.0/24
* exampleVmwareReplicatedVm:
* type: azure:siterecovery:VmwareReplicatedVm
* name: example
* properties:
* name: example-vmware-vm
* recoveryVaultId: ${exampleVault.id}
* sourceVmName: example-vm
* applianceName: example-appliance
* recoveryReplicationPolicyId: ${exampleAzurermSiteRecoveryVmwareReplicationPolicyAssociation.policyId}
* physicalServerCredentialName: example-creds
* licenseType: NotSpecified
* targetBootDiagnosticsStorageAccountId: ${exampleAccount.id}
* targetVmName: example_replicated_vm
* targetResourceGroupId: ${example.id}
* defaultLogStorageAccountId: ${exampleAccount.id}
* defaultRecoveryDiskType: Standard_LRS
* targetNetworkId: ${exampleVirtualNetwork.id}
* networkInterfaces:
* - sourceMacAddress: 00:00:00:00:00:00
* targetSubnetName: ${exampleSubnet.name}
* isPrimary: true
* ```
*
* ## Import
* Site Recovery VMWare Replicated VM's can be imported using the `resource id`, e.g.
* ```sh
* $ pulumi import azure:siterecovery/vmwareReplicatedVm:VmwareReplicatedVm vmreplication /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/resource-group-name/providers/Microsoft.RecoveryServices/vaults/recovery-vault-name/replicationFabrics/fabric-name/replicationProtectionContainers/protection-container-name/replicationProtectedItems/vm-replication-name
* ```
*/
public class VmwareReplicatedVm internal constructor(
override val javaResource: com.pulumi.azure.siterecovery.VmwareReplicatedVm,
) : KotlinCustomResource(javaResource, VmwareReplicatedVmMapper) {
/**
* The name of VMWare appliance which handles the replication. Changing this forces a new resource to be created.
*/
public val applianceName: Output
get() = javaResource.applianceName().applyValue({ args0 -> args0 })
/**
* The ID of the stroage account that should be used for logging during replication.
* > **Note:** Only standard types of storage accounts are allowed.
* > **Note:** Only one of `default_log_storage_account_id` or `managed_disk` must be specified.
* > **Note:** Changing `default_log_storage_account_id` forces a new resource to be created. But removing it does not.
* > **Note:** When `default_log_storage_account_id` co-exist with `managed_disk`, the value of `default_log_storage_account_id` must be as same as `log_storage_account_id` of every `managed_disk` or it forces a new resource to be created.
*/
public val defaultLogStorageAccountId: Output?
get() = javaResource.defaultLogStorageAccountId().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* The type of storage account that should be used for recovery disks when a failover is done. Possible values are `Premium_LRS`, `Standard_LRS` and `StandardSSD_LRS`.
* > **Note:** Only one of `default_recovery_disk_type` or `managed_disk` must be specified.
* > **Note:** Changing `default_recovery_disk_type` forces a new resource to be created. But removing it does not.
* > **Note:** When `default_recovery_disk_type` co-exist with `managed_disk`, the value of `default_recovery_disk_type` must be as same as `target_disk_type` of every `managed_disk` or it forces a new resource to be created.
*/
public val defaultRecoveryDiskType: Output?
get() = javaResource.defaultRecoveryDiskType().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* The ID of the default Disk Encryption Set that should be used for the disks when a failover is done.
* > **Note:** Changing `default_target_disk_encryption_set_id` forces a new resource to be created. But removing it does not.
* > **Note:** When `default_target_disk_encryption_set_id` co-exist with `managed_disk`, the value of `default_target_disk_encryption_set_id` must be as same as `target_disk_encryption_set_id` of every `managed_disk` or it forces a new resource to be created.
*/
public val defaultTargetDiskEncryptionSetId: Output?
get() = javaResource.defaultTargetDiskEncryptionSetId().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* The license type of the VM. Possible values are `NoLicenseType`, `NotSpecified` and `WindowsServer`. Defaults to `NotSpecified`.
*/
public val licenseType: Output?
get() = javaResource.licenseType().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* One or more `managed_disk` block as defined below. It's available only if mobility service is already installed on the source VM.
* > **Note:** A replicated VM could be created without `managed_disk` block, once the block has been specified, changing it expect removing it forces a new resource to be created.
*/
public val managedDisks: Output>?
get() = javaResource.managedDisks().applyValue({ args0 ->
args0.map({ args0 ->
args0.map({ args0 ->
args0.let({ args0 -> vmwareReplicatedVmManagedDiskToKotlin(args0) })
})
}).orElse(null)
})
/**
* Name of group in which all machines will replicate together and have shared crash consistent and app-consistent recovery points when failed over.
*/
public val multiVmGroupName: Output?
get() = javaResource.multiVmGroupName().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* The name of the replicated VM. Changing this forces a new resource to be created.
*/
public val name: Output
get() = javaResource.name().applyValue({ args0 -> args0 })
/**
* One or more `network_interface` block as defined below.
*/
public val networkInterfaces: Output>?
get() = javaResource.networkInterfaces().applyValue({ args0 ->
args0.map({ args0 ->
args0.map({ args0 ->
args0.let({ args0 ->
vmwareReplicatedVmNetworkInterfaceToKotlin(args0)
})
})
}).orElse(null)
})
/**
* The name of the credential to access the source VM. Changing this forces a new resource to be created. More information about the credentials could be found [here](https://learn.microsoft.com/en-us/azure/site-recovery/deploy-vmware-azure-replication-appliance-modernized).
*/
public val physicalServerCredentialName: Output
get() = javaResource.physicalServerCredentialName().applyValue({ args0 -> args0 })
/**
* The ID of the policy to use for this replicated VM.
*/
public val recoveryReplicationPolicyId: Output
get() = javaResource.recoveryReplicationPolicyId().applyValue({ args0 -> args0 })
/**
* The ID of the Recovery Services Vault where the replicated VM is created.
*/
public val recoveryVaultId: Output
get() = javaResource.recoveryVaultId().applyValue({ args0 -> args0 })
/**
* The name of the source VM in VMWare. Changing this forces a new resource to be created.
*/
public val sourceVmName: Output
get() = javaResource.sourceVmName().applyValue({ args0 -> args0 })
/**
* The ID of availability set that the new VM should belong to when a failover is done.
*/
public val targetAvailabilitySetId: Output?
get() = javaResource.targetAvailabilitySetId().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* The ID of the storage account that should be used for boot diagnostics when a failover is done.
*/
public val targetBootDiagnosticsStorageAccountId: Output?
get() = javaResource.targetBootDiagnosticsStorageAccountId().applyValue({ args0 ->
args0.map({ args0 -> args0 }).orElse(null)
})
/**
* The ID of network to use when a failover is done.
* > **Note:** `target_network_id` is required when `network_interface` is specified.
*/
public val targetNetworkId: Output?
get() = javaResource.targetNetworkId().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* The ID of Proximity Placement Group the new VM should belong to when a failover is done.
* > **Note:** Only one of `target_availability_set_id` or `target_zone` can be specified.
*/
public val targetProximityPlacementGroupId: Output?
get() = javaResource.targetProximityPlacementGroupId().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* The ID of resource group where the VM should be created when a failover is done.
*/
public val targetResourceGroupId: Output
get() = javaResource.targetResourceGroupId().applyValue({ args0 -> args0 })
/**
* Name of the VM that should be created when a failover is done. Changing this forces a new resource to be created.
*/
public val targetVmName: Output
get() = javaResource.targetVmName().applyValue({ args0 -> args0 })
/**
* Size of the VM that should be created when a failover is done, such as `Standard_F2`. If it's not specified, it will automatically be set by detecting the source VM size.
*/
public val targetVmSize: Output?
get() = javaResource.targetVmSize().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* Specifies the Availability Zone where the Failover VM should exist.
*/
public val targetZone: Output?
get() = javaResource.targetZone().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
/**
* The ID of network to use when a test failover is done.
*/
public val testNetworkId: Output?
get() = javaResource.testNetworkId().applyValue({ args0 ->
args0.map({ args0 ->
args0
}).orElse(null)
})
}
public object VmwareReplicatedVmMapper : ResourceMapper {
override fun supportsMappingOfType(javaResource: Resource): Boolean =
com.pulumi.azure.siterecovery.VmwareReplicatedVm::class == javaResource::class
override fun map(javaResource: Resource): VmwareReplicatedVm = VmwareReplicatedVm(
javaResource as
com.pulumi.azure.siterecovery.VmwareReplicatedVm,
)
}
/**
* @see [VmwareReplicatedVm].
* @param name The _unique_ name of the resulting resource.
* @param block Builder for [VmwareReplicatedVm].
*/
public suspend fun vmwareReplicatedVm(
name: String,
block: suspend VmwareReplicatedVmResourceBuilder.() -> Unit,
): VmwareReplicatedVm {
val builder = VmwareReplicatedVmResourceBuilder()
builder.name(name)
block(builder)
return builder.build()
}
/**
* @see [VmwareReplicatedVm].
* @param name The _unique_ name of the resulting resource.
*/
public fun vmwareReplicatedVm(name: String): VmwareReplicatedVm {
val builder = VmwareReplicatedVmResourceBuilder()
builder.name(name)
return builder.build()
}
