ReplicationConfigurationTemplate class

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 retentionDuration of ruleId 3.

Example Usage

Basic configuration

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.drs.ReplicationConfigurationTemplate("example", {
    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,
        },
    ],
    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,
});
import pulumi
import pulumi_aws as aws

example = aws.drs.ReplicationConfigurationTemplate("example",
    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,
        },
    ],
    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)
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()
    {
        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,
            },
        },
        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,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/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.(map[string]interface{})["id"])
}
_, err := drs.NewReplicationConfigurationTemplate(ctx, "example", &drs.ReplicationConfigurationTemplateArgs{
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),
},
},
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),
})
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
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_drs_replicationconfigurationtemplate" "example" {
  pit_policies {
    enabled            = true
    interval           = 10
    retention_duration = 60
    units              = "MINUTE"
    rule_id            = 1
  }
  pit_policies {
    enabled            = true
    interval           = 1
    retention_duration = 24
    units              = "HOUR"
    rule_id            = 2
  }
  pit_policies {
    enabled            = true
    interval           = 1
    retention_duration = 3
    units              = "DAY"
    rule_id            = 3
  }
  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 = exampleAwsSecurityGroup[*].id
  staging_area_subnet_id                  = exampleAwsSubnet.id
  use_dedicated_replication_server        = false
}
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.ArrayList;
import java.util.Arrays;
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()
            .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())
            .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)
            .build());

    }
}

Import

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

$ pulumi import aws:drs/replicationConfigurationTemplate:ReplicationConfigurationTemplate example templateid

Constructors

ReplicationConfigurationTemplate(String name, {ReplicationConfigurationTemplateArgs? args, CustomResourceOptions? options})
Creates a new ReplicationConfigurationTemplate. name The Pulumi resource name. args Arguments used to configure this ReplicationConfigurationTemplate. The set of arguments for ReplicationConfigurationTemplate. options Resource options controlling this resource's behavior.
ReplicationConfigurationTemplate.reference(String urn)
Creates a typed reference to an existing ReplicationConfigurationTemplate resource.

Properties

arn ↔ Output<String>
Replication configuration template ARN.
latefinal
associateDefaultSecurityGroup ↔ Output<bool>
Whether to associate the default Elastic Disaster Recovery Security group with the Replication Configuration Template.
latefinal
autoReplicateNewDisks ↔ Output<bool>
Whether to allow the AWS replication agent to automatically replicate newly added disks.
latefinal
bandwidthThrottling ↔ Output<int>
Configure bandwidth throttling for the outbound data transfer rate of the Source Server in Mbps.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
createPublicIp ↔ Output<bool>
Whether to create a Public IP for the Recovery Instance by default.
latefinal
dataPlaneRouting ↔ Output<String>
Data plane routing mechanism that will be used for replication. Valid values are PUBLIC_IP and PRIVATE_IP.
latefinal
defaultLargeStagingDiskType ↔ Output<String>
Staging Disk EBS volume type to be used during replication. Valid values are GP2, GP3, ST1, or AUTO.
latefinal
ebsEncryption ↔ Output<String>
Type of EBS encryption to be used during replication. Valid values are DEFAULT and CUSTOM.
latefinal
ebsEncryptionKeyArn ↔ Output<String?>
ARN of the EBS encryption key to be used during replication.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
pitPolicies ↔ Output<List<ReplicationConfigurationTemplatePitPolicy>?>
Configuration block for Point in time (PIT) policy to manage snapshots taken during replication. See below.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
replicationServerInstanceType ↔ Output<String>
Instance type to be used for the replication server.
latefinal
replicationServersSecurityGroupsIds ↔ Output<List<String>>
Security group IDs that will be used by the replication server.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
stagingAreaSubnetId ↔ Output<String>
Subnet to be used by the replication staging area.
latefinal
stagingAreaTags ↔ Output<Map<String, String>>
Set of tags to be associated with all resources created in the replication staging area: EC2 replication server, EBS volumes, EBS snapshots, etc.
latefinal
tags ↔ Output<Map<String, String>?>
Set of tags to be associated with the Replication Configuration Template resource.
latefinal
tagsAll ↔ Output<Map<String, String>>
Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
timeouts ↔ Output<ReplicationConfigurationTemplateTimeouts?>
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited
useDedicatedReplicationServer ↔ Output<bool>
Whether to use a dedicated Replication Server in the replication staging area.
latefinal

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {ReplicationConfigurationTemplateState? state, CustomResourceOptions? options}) → ReplicationConfigurationTemplate
Gets an existing ReplicationConfigurationTemplate resource's state with the given name and id.