pulumi-aws-kotlin/com.pulumi.aws.dms.kotlin/ReplicationConfigArgs

ReplicationConfigArgs

data class ReplicationConfigArgs(val computeConfig: Output<ReplicationConfigComputeConfigArgs>? = null, val replicationConfigIdentifier: Output<String>? = null, val replicationSettings: Output<String>? = null, val replicationType: Output<String>? = null, val resourceIdentifier: Output<String>? = null, val sourceEndpointArn: Output<String>? = null, val startReplication: Output<Boolean>? = null, val supplementalSettings: Output<String>? = null, val tableMappings: Output<String>? = null, val tags: Output<Map<String, String>>? = null, val targetEndpointArn: Output<String>? = null) : ConvertibleToJava<ReplicationConfigArgs>

Provides a DMS Serverless replication config resource.

NOTE: Changing most arguments will stop the replication if it is running. You can set start_replication to resume the replication afterwards.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const name = new aws.dms.ReplicationConfig("name", {
    replicationConfigIdentifier: "test-dms-serverless-replication-tf",
    resourceIdentifier: "test-dms-serverless-replication-tf",
    replicationType: "cdc",
    sourceEndpointArn: source.endpointArn,
    targetEndpointArn: target.endpointArn,
    tableMappings: `  {
    "rules":[{"rule-type":"selection","rule-id":"1","rule-name":"1","rule-action":"include","object-locator":{"schema-name":"%%","table-name":"%%"}}]
  }
`,
    startReplication: true,
    computeConfig: {
        replicationSubnetGroupId: _default.replicationSubnetGroupId,
        maxCapacityUnits: 64,
        minCapacityUnits: 2,
        preferredMaintenanceWindow: "sun:23:45-mon:00:30",
    },
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
name = aws.dms.ReplicationConfig("name",
    replication_config_identifier="test-dms-serverless-replication-tf",
    resource_identifier="test-dms-serverless-replication-tf",
    replication_type="cdc",
    source_endpoint_arn=source["endpointArn"],
    target_endpoint_arn=target["endpointArn"],
    table_mappings="""  {
    "rules":[{"rule-type":"selection","rule-id":"1","rule-name":"1","rule-action":"include","object-locator":{"schema-name":"%%","table-name":"%%"}}]
  }
""",
    start_replication=True,
    compute_config=aws.dms.ReplicationConfigComputeConfigArgs(
        replication_subnet_group_id=default["replicationSubnetGroupId"],
        max_capacity_units=64,
        min_capacity_units=2,
        preferred_maintenance_window="sun:23:45-mon:00:30",
    ))
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var name = new Aws.Dms.ReplicationConfig("name", new()
    {
        ReplicationConfigIdentifier = "test-dms-serverless-replication-tf",
        ResourceIdentifier = "test-dms-serverless-replication-tf",
        ReplicationType = "cdc",
        SourceEndpointArn = source.EndpointArn,
        TargetEndpointArn = target.EndpointArn,
        TableMappings = @"  {
    ""rules"":[{""rule-type"":""selection"",""rule-id"":""1"",""rule-name"":""1"",""rule-action"":""include"",""object-locator"":{""schema-name"":""%%"",""table-name"":""%%""}}]
  }
",
        StartReplication = true,
        ComputeConfig = new Aws.Dms.Inputs.ReplicationConfigComputeConfigArgs
        {
            ReplicationSubnetGroupId = @default.ReplicationSubnetGroupId,
            MaxCapacityUnits = 64,
            MinCapacityUnits = 2,
            PreferredMaintenanceWindow = "sun:23:45-mon:00:30",
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/dms"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dms.NewReplicationConfig(ctx, "name", &dms.ReplicationConfigArgs{
			ReplicationConfigIdentifier: pulumi.String("test-dms-serverless-replication-tf"),
			ResourceIdentifier:          pulumi.String("test-dms-serverless-replication-tf"),
			ReplicationType:             pulumi.String("cdc"),
			SourceEndpointArn:           pulumi.Any(source.EndpointArn),
			TargetEndpointArn:           pulumi.Any(target.EndpointArn),
			TableMappings:               pulumi.String("  {\n    \"rules\":[{\"rule-type\":\"selection\",\"rule-id\":\"1\",\"rule-name\":\"1\",\"rule-action\":\"include\",\"object-locator\":{\"schema-name\":\"%%\",\"table-name\":\"%%\"}}]\n  }\n"),
			StartReplication:            pulumi.Bool(true),
			ComputeConfig: &dms.ReplicationConfigComputeConfigArgs{
				ReplicationSubnetGroupId:   pulumi.Any(_default.ReplicationSubnetGroupId),
				MaxCapacityUnits:           pulumi.Int(64),
				MinCapacityUnits:           pulumi.Int(2),
				PreferredMaintenanceWindow: pulumi.String("sun:23:45-mon:00:30"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.dms.ReplicationConfig;
import com.pulumi.aws.dms.ReplicationConfigArgs;
import com.pulumi.aws.dms.inputs.ReplicationConfigComputeConfigArgs;
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 name = new ReplicationConfig("name", ReplicationConfigArgs.builder()
            .replicationConfigIdentifier("test-dms-serverless-replication-tf")
            .resourceIdentifier("test-dms-serverless-replication-tf")
            .replicationType("cdc")
            .sourceEndpointArn(source.endpointArn())
            .targetEndpointArn(target.endpointArn())
            .tableMappings("""
  {
    "rules":[{"rule-type":"selection","rule-id":"1","rule-name":"1","rule-action":"include","object-locator":{"schema-name":"%%","table-name":"%%"}}]
  }
            """)
            .startReplication(true)
            .computeConfig(ReplicationConfigComputeConfigArgs.builder()
                .replicationSubnetGroupId(default_.replicationSubnetGroupId())
                .maxCapacityUnits("64")
                .minCapacityUnits("2")
                .preferredMaintenanceWindow("sun:23:45-mon:00:30")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  name:
    type: aws:dms:ReplicationConfig
    properties:
      replicationConfigIdentifier: test-dms-serverless-replication-tf
      resourceIdentifier: test-dms-serverless-replication-tf
      replicationType: cdc
      sourceEndpointArn: ${source.endpointArn}
      targetEndpointArn: ${target.endpointArn}
      tableMappings: |2
          {
            "rules":[{"rule-type":"selection","rule-id":"1","rule-name":"1","rule-action":"include","object-locator":{"schema-name":"%%","table-name":"%%"}}]
          }
      startReplication: true
      computeConfig:
        replicationSubnetGroupId: ${default.replicationSubnetGroupId}
        maxCapacityUnits: '64'
        minCapacityUnits: '2'
        preferredMaintenanceWindow: sun:23:45-mon:00:30
Content copied to clipboard

Import

Using pulumi import, import a replication config using the arn. For example:

$ pulumi import aws:dms/replicationConfig:ReplicationConfig example arn:aws:dms:us-east-1:123456789012:replication-config:UX6OL6MHMMJKFFOXE3H7LLJCMEKBDUG4ZV7DRSI
Content copied to clipboard

Constructors

Link copied to clipboard
fun ReplicationConfigArgs(computeConfig: Output<ReplicationConfigComputeConfigArgs>? = null, replicationConfigIdentifier: Output<String>? = null, replicationSettings: Output<String>? = null, replicationType: Output<String>? = null, resourceIdentifier: Output<String>? = null, sourceEndpointArn: Output<String>? = null, startReplication: Output<Boolean>? = null, supplementalSettings: Output<String>? = null, tableMappings: Output<String>? = null, tags: Output<Map<String, String>>? = null, targetEndpointArn: Output<String>? = null)

Functions

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

Properties

Link copied to clipboard
val computeConfig: Output<ReplicationConfigComputeConfigArgs>? = null

Configuration block for provisioning an DMS Serverless replication.

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

Unique identifier that you want to use to create the config.

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

An escaped JSON string that are used to provision this replication configuration. For example, Change processing tuning settings

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

The migration type. Can be one of full-load | cdc | full-load-and-cdc.

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

Unique value or name that you set for a given resource that can be used to construct an Amazon Resource Name (ARN) for that resource. For more information, see Fine-grained access control using resource names and tags

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

The Amazon Resource Name (ARN) string that uniquely identifies the source endpoint.

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

Whether to run or stop the serverless replication, default is false.

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

JSON settings for specifying supplemental data. For more information see Specifying supplemental data for task settings

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

An escaped JSON string that contains the table mappings. For information on table mapping see Using Table Mapping with an AWS Database Migration Service Task to Select and Filter Data

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

A map of tags to assign to the resource. If configured with a provider default_tags configuration block present, tags with matching keys will overwrite those defined at the provider-level.

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

The Amazon Resource Name (ARN) string that uniquely identifies the target endpoint.