pulumi-aws-kotlin/com.pulumi.aws.drs.kotlin/ReplicationConfigurationTemplateArgs

ReplicationConfigurationTemplateArgs

data class ReplicationConfigurationTemplateArgs(val associateDefaultSecurityGroup: Output<Boolean>? = null, val autoReplicateNewDisks: Output<Boolean>? = null, val bandwidthThrottling: Output<Int>? = null, val createPublicIp: Output<Boolean>? = null, val dataPlaneRouting: Output<String>? = null, val defaultLargeStagingDiskType: Output<String>? = null, val ebsEncryption: Output<String>? = null, val ebsEncryptionKeyArn: Output<String>? = null, val pitPolicies: Output<List<ReplicationConfigurationTemplatePitPolicyArgs>>? = null, val replicationServerInstanceType: Output<String>? = null, val replicationServersSecurityGroupsIds: Output<List<String>>? = null, val stagingAreaSubnetId: Output<String>? = null, val stagingAreaTags: Output<Map<String, String>>? = null, val tags: Output<Map<String, String>>? = null, val timeouts: Output<ReplicationConfigurationTemplateTimeoutsArgs>? = null, val useDedicatedReplicationServer: Output<Boolean>? = null) : ConvertibleToJava<ReplicationConfigurationTemplateArgs>

Provides an Elastic Disaster Recovery replication configuration template resource. Before using DRS, your account must be initialized.

NOTE: Your configuration must use the PIT policy shown in the basic configuration due to AWS rules. The only value that you can change is the retention_duration of rule_id 3.

Example Usage

Basic configuration

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.drs.ReplicationConfigurationTemplate("example", {
    associateDefaultSecurityGroup: false,
    bandwidthThrottling: 12,
    createPublicIp: false,
    dataPlaneRouting: "PRIVATE_IP",
    defaultLargeStagingDiskType: "GP2",
    ebsEncryption: "DEFAULT",
    ebsEncryptionKeyArn: "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
    replicationServerInstanceType: "t3.small",
    replicationServersSecurityGroupsIds: exampleAwsSecurityGroup.map(__item => __item.id),
    stagingAreaSubnetId: exampleAwsSubnet.id,
    useDedicatedReplicationServer: false,
    pitPolicies: [
        {
            enabled: true,
            interval: 10,
            retentionDuration: 60,
            units: "MINUTE",
            ruleId: 1,
        },
        {
            enabled: true,
            interval: 1,
            retentionDuration: 24,
            units: "HOUR",
            ruleId: 2,
        },
        {
            enabled: true,
            interval: 1,
            retentionDuration: 3,
            units: "DAY",
            ruleId: 3,
        },
    ],
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
example = aws.drs.ReplicationConfigurationTemplate("example",
    associate_default_security_group=False,
    bandwidth_throttling=12,
    create_public_ip=False,
    data_plane_routing="PRIVATE_IP",
    default_large_staging_disk_type="GP2",
    ebs_encryption="DEFAULT",
    ebs_encryption_key_arn="arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
    replication_server_instance_type="t3.small",
    replication_servers_security_groups_ids=[__item["id"] for __item in example_aws_security_group],
    staging_area_subnet_id=example_aws_subnet["id"],
    use_dedicated_replication_server=False,
    pit_policies=[
        {
            "enabled": True,
            "interval": 10,
            "retention_duration": 60,
            "units": "MINUTE",
            "rule_id": 1,
        },
        {
            "enabled": True,
            "interval": 1,
            "retention_duration": 24,
            "units": "HOUR",
            "rule_id": 2,
        },
        {
            "enabled": True,
            "interval": 1,
            "retention_duration": 3,
            "units": "DAY",
            "rule_id": 3,
        },
    ])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var example = new Aws.Drs.ReplicationConfigurationTemplate("example", new()
    {
        AssociateDefaultSecurityGroup = false,
        BandwidthThrottling = 12,
        CreatePublicIp = false,
        DataPlaneRouting = "PRIVATE_IP",
        DefaultLargeStagingDiskType = "GP2",
        EbsEncryption = "DEFAULT",
        EbsEncryptionKeyArn = "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab",
        ReplicationServerInstanceType = "t3.small",
        ReplicationServersSecurityGroupsIds = exampleAwsSecurityGroup.Select(__item => __item.Id).ToList(),
        StagingAreaSubnetId = exampleAwsSubnet.Id,
        UseDedicatedReplicationServer = false,
        PitPolicies = new[]
        {
            new Aws.Drs.Inputs.ReplicationConfigurationTemplatePitPolicyArgs
            {
                Enabled = true,
                Interval = 10,
                RetentionDuration = 60,
                Units = "MINUTE",
                RuleId = 1,
            },
            new Aws.Drs.Inputs.ReplicationConfigurationTemplatePitPolicyArgs
            {
                Enabled = true,
                Interval = 1,
                RetentionDuration = 24,
                Units = "HOUR",
                RuleId = 2,
            },
            new Aws.Drs.Inputs.ReplicationConfigurationTemplatePitPolicyArgs
            {
                Enabled = true,
                Interval = 1,
                RetentionDuration = 3,
                Units = "DAY",
                RuleId = 3,
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/drs"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
var splat0 []interface{}
for _, val0 := range exampleAwsSecurityGroup {
splat0 = append(splat0, val0.Id)
}
_, err := drs.NewReplicationConfigurationTemplate(ctx, "example", &drs.ReplicationConfigurationTemplateArgs{
AssociateDefaultSecurityGroup: pulumi.Bool(false),
BandwidthThrottling: pulumi.Int(12),
CreatePublicIp: pulumi.Bool(false),
DataPlaneRouting: pulumi.String("PRIVATE_IP"),
DefaultLargeStagingDiskType: pulumi.String("GP2"),
EbsEncryption: pulumi.String("DEFAULT"),
EbsEncryptionKeyArn: pulumi.String("arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"),
ReplicationServerInstanceType: pulumi.String("t3.small"),
ReplicationServersSecurityGroupsIds: toPulumiArray(splat0),
StagingAreaSubnetId: pulumi.Any(exampleAwsSubnet.Id),
UseDedicatedReplicationServer: pulumi.Bool(false),
PitPolicies: drs.ReplicationConfigurationTemplatePitPolicyArray{
&drs.ReplicationConfigurationTemplatePitPolicyArgs{
Enabled: pulumi.Bool(true),
Interval: pulumi.Int(10),
RetentionDuration: pulumi.Int(60),
Units: pulumi.String("MINUTE"),
RuleId: pulumi.Int(1),
},
&drs.ReplicationConfigurationTemplatePitPolicyArgs{
Enabled: pulumi.Bool(true),
Interval: pulumi.Int(1),
RetentionDuration: pulumi.Int(24),
Units: pulumi.String("HOUR"),
RuleId: pulumi.Int(2),
},
&drs.ReplicationConfigurationTemplatePitPolicyArgs{
Enabled: pulumi.Bool(true),
Interval: pulumi.Int(1),
RetentionDuration: pulumi.Int(3),
Units: pulumi.String("DAY"),
RuleId: pulumi.Int(3),
},
},
})
if err != nil {
return err
}
return nil
})
}
func toPulumiArray(arr []) pulumi.Array {
var pulumiArr pulumi.Array
for _, v := range arr {
pulumiArr = append(pulumiArr, pulumi.(v))
}
return pulumiArr
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.drs.ReplicationConfigurationTemplate;
import com.pulumi.aws.drs.ReplicationConfigurationTemplateArgs;
import com.pulumi.aws.drs.inputs.ReplicationConfigurationTemplatePitPolicyArgs;
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 ReplicationConfigurationTemplate("example", ReplicationConfigurationTemplateArgs.builder()
            .associateDefaultSecurityGroup(false)
            .bandwidthThrottling(12)
            .createPublicIp(false)
            .dataPlaneRouting("PRIVATE_IP")
            .defaultLargeStagingDiskType("GP2")
            .ebsEncryption("DEFAULT")
            .ebsEncryptionKeyArn("arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab")
            .replicationServerInstanceType("t3.small")
            .replicationServersSecurityGroupsIds(exampleAwsSecurityGroup.stream().map(element -> element.id()).collect(toList()))
            .stagingAreaSubnetId(exampleAwsSubnet.id())
            .useDedicatedReplicationServer(false)
            .pitPolicies(
                ReplicationConfigurationTemplatePitPolicyArgs.builder()
                    .enabled(true)
                    .interval(10)
                    .retentionDuration(60)
                    .units("MINUTE")
                    .ruleId(1)
                    .build(),
                ReplicationConfigurationTemplatePitPolicyArgs.builder()
                    .enabled(true)
                    .interval(1)
                    .retentionDuration(24)
                    .units("HOUR")
                    .ruleId(2)
                    .build(),
                ReplicationConfigurationTemplatePitPolicyArgs.builder()
                    .enabled(true)
                    .interval(1)
                    .retentionDuration(3)
                    .units("DAY")
                    .ruleId(3)
                    .build())
            .build());
    }
}
Content copied to clipboard

Import

Using pulumi import, import DRS Replication Configuration Template using the id. For example:

$ pulumi import aws:drs/replicationConfigurationTemplate:ReplicationConfigurationTemplate example templateid
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(associateDefaultSecurityGroup: Output<Boolean>? = null, autoReplicateNewDisks: Output<Boolean>? = null, bandwidthThrottling: Output<Int>? = null, createPublicIp: Output<Boolean>? = null, dataPlaneRouting: Output<String>? = null, defaultLargeStagingDiskType: Output<String>? = null, ebsEncryption: Output<String>? = null, ebsEncryptionKeyArn: Output<String>? = null, pitPolicies: Output<List<ReplicationConfigurationTemplatePitPolicyArgs>>? = null, replicationServerInstanceType: Output<String>? = null, replicationServersSecurityGroupsIds: Output<List<String>>? = null, stagingAreaSubnetId: Output<String>? = null, stagingAreaTags: Output<Map<String, String>>? = null, tags: Output<Map<String, String>>? = null, timeouts: Output<ReplicationConfigurationTemplateTimeoutsArgs>? = null, useDedicatedReplicationServer: Output<Boolean>? = null)

Properties

Link copied to clipboard
val associateDefaultSecurityGroup: Output<Boolean>? = null

Whether to associate the default Elastic Disaster Recovery Security group with the Replication Configuration Template.

Link copied to clipboard
val autoReplicateNewDisks: Output<Boolean>? = null

Whether to allow the AWS replication agent to automatically replicate newly added disks.

Link copied to clipboard
val bandwidthThrottling: Output<Int>? = null

Configure bandwidth throttling for the outbound data transfer rate of the Source Server in Mbps.

Link copied to clipboard
val createPublicIp: Output<Boolean>? = null

Whether to create a Public IP for the Recovery Instance by default.

Link copied to clipboard
val dataPlaneRouting: Output<String>? = null

Data plane routing mechanism that will be used for replication. Valid values are PUBLIC_IP and PRIVATE_IP.

Link copied to clipboard
val defaultLargeStagingDiskType: Output<String>? = null

Staging Disk EBS volume type to be used during replication. Valid values are GP2, GP3, ST1, or AUTO.

Link copied to clipboard
val ebsEncryption: Output<String>? = null

Type of EBS encryption to be used during replication. Valid values are DEFAULT and CUSTOM.

Link copied to clipboard
val ebsEncryptionKeyArn: Output<String>? = null

ARN of the EBS encryption key to be used during replication.

Link copied to clipboard
val pitPolicies: Output<List<ReplicationConfigurationTemplatePitPolicyArgs>>? = null

Configuration block for Point in time (PIT) policy to manage snapshots taken during replication. See below.

Link copied to clipboard
val replicationServerInstanceType: Output<String>? = null

Instance type to be used for the replication server.

Link copied to clipboard
val replicationServersSecurityGroupsIds: Output<List<String>>? = null

Security group IDs that will be used by the replication server.

Link copied to clipboard
val stagingAreaSubnetId: Output<String>? = null

Subnet to be used by the replication staging area.

Link copied to clipboard
val stagingAreaTags: Output<Map<String, String>>? = null

Set of tags to be associated with all resources created in the replication staging area: EC2 replication server, EBS volumes, EBS snapshots, etc.

Link copied to clipboard
val tags: Output<Map<String, String>>? = null

Set of tags to be associated with the Replication Configuration Template resource.

Link copied to clipboard
Link copied to clipboard
val useDedicatedReplicationServer: Output<Boolean>? = null

Whether to use a dedicated Replication Server in the replication staging area. The following arguments are optional:

Functions

Link copied to clipboard
open override fun toJava(): ReplicationConfigurationTemplateArgs