pulumi-aws-kotlin/com.pulumi.aws.elasticache.kotlin/ReplicationGroup

ReplicationGroup

class ReplicationGroup : KotlinCustomResource

Provides an ElastiCache Replication Group resource. For working with a Memcached cluster or a single-node Redis instance (Cluster Mode Disabled), see the aws.elasticache.Cluster resource.

Note: When you change an attribute, such as engine_version, by default the ElastiCache API applies it in the next maintenance window. Because of this, this provider may report a difference in its planning phase because the actual modification has not yet taken place. You can use the apply_immediately flag to instruct the service to apply the change immediately. Using apply_immediately can result in a brief downtime as servers reboots. See the AWS Documentation on Modifying an ElastiCache Cache Cluster for more information. Note: Any attribute changes that re-create the resource will be applied immediately, regardless of the value of apply_immediately. Note: Be aware of the terminology collision around "cluster" for aws.elasticache.ReplicationGroup. For example, it is possible to create a "Cluster Mode Disabled Redis Cluster". With "Cluster Mode Enabled", the data will be stored in shards (called "node groups"). See Redis Cluster Configuration for a diagram of the differences. To enable cluster mode, use a parameter group that has cluster mode enabled. The default parameter groups provided by AWS end with ".cluster.on", for example default.redis6.x.cluster.on.

Example Usage

Redis Cluster Mode Disabled

To create a single shard primary with single read replica:

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.elasticache.ReplicationGroup("example", {
    automaticFailoverEnabled: true,
    preferredCacheClusterAzs: [
        "us-west-2a",
        "us-west-2b",
    ],
    replicationGroupId: "tf-rep-group-1",
    description: "example description",
    nodeType: "cache.m4.large",
    numCacheClusters: 2,
    parameterGroupName: "default.redis3.2",
    port: 6379,
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
example = aws.elasticache.ReplicationGroup("example",
    automatic_failover_enabled=True,
    preferred_cache_cluster_azs=[
        "us-west-2a",
        "us-west-2b",
    ],
    replication_group_id="tf-rep-group-1",
    description="example description",
    node_type="cache.m4.large",
    num_cache_clusters=2,
    parameter_group_name="default.redis3.2",
    port=6379)
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.ElastiCache.ReplicationGroup("example", new()
    {
        AutomaticFailoverEnabled = true,
        PreferredCacheClusterAzs = new[]
        {
            "us-west-2a",
            "us-west-2b",
        },
        ReplicationGroupId = "tf-rep-group-1",
        Description = "example description",
        NodeType = "cache.m4.large",
        NumCacheClusters = 2,
        ParameterGroupName = "default.redis3.2",
        Port = 6379,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/elasticache"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := elasticache.NewReplicationGroup(ctx, "example", &elasticache.ReplicationGroupArgs{
			AutomaticFailoverEnabled: pulumi.Bool(true),
			PreferredCacheClusterAzs: pulumi.StringArray{
				pulumi.String("us-west-2a"),
				pulumi.String("us-west-2b"),
			},
			ReplicationGroupId: pulumi.String("tf-rep-group-1"),
			Description:        pulumi.String("example description"),
			NodeType:           pulumi.String("cache.m4.large"),
			NumCacheClusters:   pulumi.Int(2),
			ParameterGroupName: pulumi.String("default.redis3.2"),
			Port:               pulumi.Int(6379),
		})
		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.elasticache.ReplicationGroup;
import com.pulumi.aws.elasticache.ReplicationGroupArgs;
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 ReplicationGroup("example", ReplicationGroupArgs.builder()
            .automaticFailoverEnabled(true)
            .preferredCacheClusterAzs(
                "us-west-2a",
                "us-west-2b")
            .replicationGroupId("tf-rep-group-1")
            .description("example description")
            .nodeType("cache.m4.large")
            .numCacheClusters(2)
            .parameterGroupName("default.redis3.2")
            .port(6379)
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: aws:elasticache:ReplicationGroup
    properties:
      automaticFailoverEnabled: true
      preferredCacheClusterAzs:
        - us-west-2a
        - us-west-2b
      replicationGroupId: tf-rep-group-1
      description: example description
      nodeType: cache.m4.large
      numCacheClusters: 2
      parameterGroupName: default.redis3.2
      port: 6379
Content copied to clipboard

You have two options for adjusting the number of replicas:

  • Adjusting num_cache_clusters directly. This will attempt to automatically add or remove replicas, but provides no granular control (e.g., preferred availability zone, cache cluster ID) for the added or removed replicas. This also currently expects cache cluster IDs in the form of replication_group_id-00#.

  • Otherwise for fine grained control of the underlying cache clusters, they can be added or removed with the aws.elasticache.Cluster resource and its replication_group_id attribute. In this situation, you will need to utilize ignoreChanges to prevent perpetual differences with the number_cache_cluster attribute.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.elasticache.ReplicationGroup("example", {
    automaticFailoverEnabled: true,
    preferredCacheClusterAzs: [
        "us-west-2a",
        "us-west-2b",
    ],
    replicationGroupId: "tf-rep-group-1",
    description: "example description",
    nodeType: "cache.m4.large",
    numCacheClusters: 2,
    parameterGroupName: "default.redis3.2",
    port: 6379,
});
const replica: aws.elasticache.Cluster[] = [];
for (const range = {value: 0}; range.value < 1; range.value++) {
    replica.push(new aws.elasticache.Cluster(`replica-${range.value}`, {
        clusterId: `tf-rep-group-1-${range.value}`,
        replicationGroupId: example.id,
    }));
}
Content copied to clipboard
import pulumi
import pulumi_aws as aws
example = aws.elasticache.ReplicationGroup("example",
    automatic_failover_enabled=True,
    preferred_cache_cluster_azs=[
        "us-west-2a",
        "us-west-2b",
    ],
    replication_group_id="tf-rep-group-1",
    description="example description",
    node_type="cache.m4.large",
    num_cache_clusters=2,
    parameter_group_name="default.redis3.2",
    port=6379)
replica = []
for range in [{"value": i} for i in range(0, 1)]:
    replica.append(aws.elasticache.Cluster(f"replica-{range['value']}",
        cluster_id=f"tf-rep-group-1-{range['value']}",
        replication_group_id=example.id))
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.ElastiCache.ReplicationGroup("example", new()
    {
        AutomaticFailoverEnabled = true,
        PreferredCacheClusterAzs = new[]
        {
            "us-west-2a",
            "us-west-2b",
        },
        ReplicationGroupId = "tf-rep-group-1",
        Description = "example description",
        NodeType = "cache.m4.large",
        NumCacheClusters = 2,
        ParameterGroupName = "default.redis3.2",
        Port = 6379,
    });
    var replica = new List<Aws.ElastiCache.Cluster>();
    for (var rangeIndex = 0; rangeIndex < 1; rangeIndex++)
    {
        var range = new { Value = rangeIndex };
        replica.Add(new Aws.ElastiCache.Cluster($"replica-{range.Value}", new()
        {
            ClusterId = $"tf-rep-group-1-{range.Value}",
            ReplicationGroupId = example.Id,
        }));
    }
});
Content copied to clipboard
package main
import (
	"fmt"
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/elasticache"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := elasticache.NewReplicationGroup(ctx, "example", &elasticache.ReplicationGroupArgs{
			AutomaticFailoverEnabled: pulumi.Bool(true),
			PreferredCacheClusterAzs: pulumi.StringArray{
				pulumi.String("us-west-2a"),
				pulumi.String("us-west-2b"),
			},
			ReplicationGroupId: pulumi.String("tf-rep-group-1"),
			Description:        pulumi.String("example description"),
			NodeType:           pulumi.String("cache.m4.large"),
			NumCacheClusters:   pulumi.Int(2),
			ParameterGroupName: pulumi.String("default.redis3.2"),
			Port:               pulumi.Int(6379),
		})
		if err != nil {
			return err
		}
		var replica []*elasticache.Cluster
		for index := 0; index < 1; index++ {
			key0 := index
			val0 := index
			__res, err := elasticache.NewCluster(ctx, fmt.Sprintf("replica-%v", key0), &elasticache.ClusterArgs{
				ClusterId:          pulumi.String(fmt.Sprintf("tf-rep-group-1-%v", val0)),
				ReplicationGroupId: example.ID(),
			})
			if err != nil {
				return err
			}
			replica = append(replica, __res)
		}
		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.elasticache.ReplicationGroup;
import com.pulumi.aws.elasticache.ReplicationGroupArgs;
import com.pulumi.aws.elasticache.Cluster;
import com.pulumi.aws.elasticache.ClusterArgs;
import com.pulumi.codegen.internal.KeyedValue;
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 ReplicationGroup("example", ReplicationGroupArgs.builder()
            .automaticFailoverEnabled(true)
            .preferredCacheClusterAzs(
                "us-west-2a",
                "us-west-2b")
            .replicationGroupId("tf-rep-group-1")
            .description("example description")
            .nodeType("cache.m4.large")
            .numCacheClusters(2)
            .parameterGroupName("default.redis3.2")
            .port(6379)
            .build());
        for (var i = 0; i < 1; i++) {
            new Cluster("replica-" + i, ClusterArgs.builder()
                .clusterId(String.format("tf-rep-group-1-%s", range.value()))
                .replicationGroupId(example.id())
                .build());
}
    }
}
Content copied to clipboard
resources:
  example:
    type: aws:elasticache:ReplicationGroup
    properties:
      automaticFailoverEnabled: true
      preferredCacheClusterAzs:
        - us-west-2a
        - us-west-2b
      replicationGroupId: tf-rep-group-1
      description: example description
      nodeType: cache.m4.large
      numCacheClusters: 2
      parameterGroupName: default.redis3.2
      port: 6379
  replica:
    type: aws:elasticache:Cluster
    properties:
      clusterId: tf-rep-group-1-${range.value}
      replicationGroupId: ${example.id}
    options: {}
Content copied to clipboard

Redis Cluster Mode Enabled

To create two shards with a primary and a single read replica each:

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const baz = new aws.elasticache.ReplicationGroup("baz", {
    replicationGroupId: "tf-redis-cluster",
    description: "example description",
    nodeType: "cache.t2.small",
    port: 6379,
    parameterGroupName: "default.redis3.2.cluster.on",
    automaticFailoverEnabled: true,
    numNodeGroups: 2,
    replicasPerNodeGroup: 1,
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
baz = aws.elasticache.ReplicationGroup("baz",
    replication_group_id="tf-redis-cluster",
    description="example description",
    node_type="cache.t2.small",
    port=6379,
    parameter_group_name="default.redis3.2.cluster.on",
    automatic_failover_enabled=True,
    num_node_groups=2,
    replicas_per_node_group=1)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var baz = new Aws.ElastiCache.ReplicationGroup("baz", new()
    {
        ReplicationGroupId = "tf-redis-cluster",
        Description = "example description",
        NodeType = "cache.t2.small",
        Port = 6379,
        ParameterGroupName = "default.redis3.2.cluster.on",
        AutomaticFailoverEnabled = true,
        NumNodeGroups = 2,
        ReplicasPerNodeGroup = 1,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/elasticache"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := elasticache.NewReplicationGroup(ctx, "baz", &elasticache.ReplicationGroupArgs{
			ReplicationGroupId:       pulumi.String("tf-redis-cluster"),
			Description:              pulumi.String("example description"),
			NodeType:                 pulumi.String("cache.t2.small"),
			Port:                     pulumi.Int(6379),
			ParameterGroupName:       pulumi.String("default.redis3.2.cluster.on"),
			AutomaticFailoverEnabled: pulumi.Bool(true),
			NumNodeGroups:            pulumi.Int(2),
			ReplicasPerNodeGroup:     pulumi.Int(1),
		})
		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.elasticache.ReplicationGroup;
import com.pulumi.aws.elasticache.ReplicationGroupArgs;
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 baz = new ReplicationGroup("baz", ReplicationGroupArgs.builder()
            .replicationGroupId("tf-redis-cluster")
            .description("example description")
            .nodeType("cache.t2.small")
            .port(6379)
            .parameterGroupName("default.redis3.2.cluster.on")
            .automaticFailoverEnabled(true)
            .numNodeGroups(2)
            .replicasPerNodeGroup(1)
            .build());
    }
}
Content copied to clipboard
resources:
  baz:
    type: aws:elasticache:ReplicationGroup
    properties:
      replicationGroupId: tf-redis-cluster
      description: example description
      nodeType: cache.t2.small
      port: 6379
      parameterGroupName: default.redis3.2.cluster.on
      automaticFailoverEnabled: true
      numNodeGroups: 2
      replicasPerNodeGroup: 1
Content copied to clipboard

Redis Log Delivery configuration

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const test = new aws.elasticache.ReplicationGroup("test", {
    replicationGroupId: "myreplicaciongroup",
    description: "test description",
    nodeType: "cache.t3.small",
    port: 6379,
    applyImmediately: true,
    autoMinorVersionUpgrade: false,
    maintenanceWindow: "tue:06:30-tue:07:30",
    snapshotWindow: "01:00-02:00",
    logDeliveryConfigurations: [
        {
            destination: example.name,
            destinationType: "cloudwatch-logs",
            logFormat: "text",
            logType: "slow-log",
        },
        {
            destination: exampleAwsKinesisFirehoseDeliveryStream.name,
            destinationType: "kinesis-firehose",
            logFormat: "json",
            logType: "engine-log",
        },
    ],
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
test = aws.elasticache.ReplicationGroup("test",
    replication_group_id="myreplicaciongroup",
    description="test description",
    node_type="cache.t3.small",
    port=6379,
    apply_immediately=True,
    auto_minor_version_upgrade=False,
    maintenance_window="tue:06:30-tue:07:30",
    snapshot_window="01:00-02:00",
    log_delivery_configurations=[
        aws.elasticache.ReplicationGroupLogDeliveryConfigurationArgs(
            destination=example["name"],
            destination_type="cloudwatch-logs",
            log_format="text",
            log_type="slow-log",
        ),
        aws.elasticache.ReplicationGroupLogDeliveryConfigurationArgs(
            destination=example_aws_kinesis_firehose_delivery_stream["name"],
            destination_type="kinesis-firehose",
            log_format="json",
            log_type="engine-log",
        ),
    ])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var test = new Aws.ElastiCache.ReplicationGroup("test", new()
    {
        ReplicationGroupId = "myreplicaciongroup",
        Description = "test description",
        NodeType = "cache.t3.small",
        Port = 6379,
        ApplyImmediately = true,
        AutoMinorVersionUpgrade = false,
        MaintenanceWindow = "tue:06:30-tue:07:30",
        SnapshotWindow = "01:00-02:00",
        LogDeliveryConfigurations = new[]
        {
            new Aws.ElastiCache.Inputs.ReplicationGroupLogDeliveryConfigurationArgs
            {
                Destination = example.Name,
                DestinationType = "cloudwatch-logs",
                LogFormat = "text",
                LogType = "slow-log",
            },
            new Aws.ElastiCache.Inputs.ReplicationGroupLogDeliveryConfigurationArgs
            {
                Destination = exampleAwsKinesisFirehoseDeliveryStream.Name,
                DestinationType = "kinesis-firehose",
                LogFormat = "json",
                LogType = "engine-log",
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/elasticache"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := elasticache.NewReplicationGroup(ctx, "test", &elasticache.ReplicationGroupArgs{
			ReplicationGroupId:      pulumi.String("myreplicaciongroup"),
			Description:             pulumi.String("test description"),
			NodeType:                pulumi.String("cache.t3.small"),
			Port:                    pulumi.Int(6379),
			ApplyImmediately:        pulumi.Bool(true),
			AutoMinorVersionUpgrade: pulumi.Bool(false),
			MaintenanceWindow:       pulumi.String("tue:06:30-tue:07:30"),
			SnapshotWindow:          pulumi.String("01:00-02:00"),
			LogDeliveryConfigurations: elasticache.ReplicationGroupLogDeliveryConfigurationArray{
				&elasticache.ReplicationGroupLogDeliveryConfigurationArgs{
					Destination:     pulumi.Any(example.Name),
					DestinationType: pulumi.String("cloudwatch-logs"),
					LogFormat:       pulumi.String("text"),
					LogType:         pulumi.String("slow-log"),
				},
				&elasticache.ReplicationGroupLogDeliveryConfigurationArgs{
					Destination:     pulumi.Any(exampleAwsKinesisFirehoseDeliveryStream.Name),
					DestinationType: pulumi.String("kinesis-firehose"),
					LogFormat:       pulumi.String("json"),
					LogType:         pulumi.String("engine-log"),
				},
			},
		})
		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.elasticache.ReplicationGroup;
import com.pulumi.aws.elasticache.ReplicationGroupArgs;
import com.pulumi.aws.elasticache.inputs.ReplicationGroupLogDeliveryConfigurationArgs;
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 test = new ReplicationGroup("test", ReplicationGroupArgs.builder()
            .replicationGroupId("myreplicaciongroup")
            .description("test description")
            .nodeType("cache.t3.small")
            .port(6379)
            .applyImmediately(true)
            .autoMinorVersionUpgrade(false)
            .maintenanceWindow("tue:06:30-tue:07:30")
            .snapshotWindow("01:00-02:00")
            .logDeliveryConfigurations(
                ReplicationGroupLogDeliveryConfigurationArgs.builder()
                    .destination(example.name())
                    .destinationType("cloudwatch-logs")
                    .logFormat("text")
                    .logType("slow-log")
                    .build(),
                ReplicationGroupLogDeliveryConfigurationArgs.builder()
                    .destination(exampleAwsKinesisFirehoseDeliveryStream.name())
                    .destinationType("kinesis-firehose")
                    .logFormat("json")
                    .logType("engine-log")
                    .build())
            .build());
    }
}
Content copied to clipboard
resources:
  test:
    type: aws:elasticache:ReplicationGroup
    properties:
      replicationGroupId: myreplicaciongroup
      description: test description
      nodeType: cache.t3.small
      port: 6379
      applyImmediately: true
      autoMinorVersionUpgrade: false
      maintenanceWindow: tue:06:30-tue:07:30
      snapshotWindow: 01:00-02:00
      logDeliveryConfigurations:
        - destination: ${example.name}
          destinationType: cloudwatch-logs
          logFormat: text
          logType: slow-log
        - destination: ${exampleAwsKinesisFirehoseDeliveryStream.name}
          destinationType: kinesis-firehose
          logFormat: json
          logType: engine-log
Content copied to clipboard

Note: We currently do not support passing a primary_cluster_id in order to create the Replication Group. Note: Automatic Failover is unavailable for Redis versions earlier than 2.8.6, and unavailable on T1 node types. For T2 node types, it is only available on Redis version 3.2.4 or later with cluster mode enabled. See the High Availability Using Replication Groups guide for full details on using Replication Groups.

Creating a secondary replication group for a global replication group

A Global Replication Group can have one one two secondary Replication Groups in different regions. These are added to an existing Global Replication Group.

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const primary = new aws.elasticache.ReplicationGroup("primary", {
    replicationGroupId: "example-primary",
    description: "primary replication group",
    engine: "redis",
    engineVersion: "5.0.6",
    nodeType: "cache.m5.large",
    numCacheClusters: 1,
});
const example = new aws.elasticache.GlobalReplicationGroup("example", {
    globalReplicationGroupIdSuffix: "example",
    primaryReplicationGroupId: primary.id,
});
const secondary = new aws.elasticache.ReplicationGroup("secondary", {
    replicationGroupId: "example-secondary",
    description: "secondary replication group",
    globalReplicationGroupId: example.globalReplicationGroupId,
    numCacheClusters: 1,
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
primary = aws.elasticache.ReplicationGroup("primary",
    replication_group_id="example-primary",
    description="primary replication group",
    engine="redis",
    engine_version="5.0.6",
    node_type="cache.m5.large",
    num_cache_clusters=1)
example = aws.elasticache.GlobalReplicationGroup("example",
    global_replication_group_id_suffix="example",
    primary_replication_group_id=primary.id)
secondary = aws.elasticache.ReplicationGroup("secondary",
    replication_group_id="example-secondary",
    description="secondary replication group",
    global_replication_group_id=example.global_replication_group_id,
    num_cache_clusters=1)
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;
return await Deployment.RunAsync(() =>
{
    var primary = new Aws.ElastiCache.ReplicationGroup("primary", new()
    {
        ReplicationGroupId = "example-primary",
        Description = "primary replication group",
        Engine = "redis",
        EngineVersion = "5.0.6",
        NodeType = "cache.m5.large",
        NumCacheClusters = 1,
    });
    var example = new Aws.ElastiCache.GlobalReplicationGroup("example", new()
    {
        GlobalReplicationGroupIdSuffix = "example",
        PrimaryReplicationGroupId = primary.Id,
    });
    var secondary = new Aws.ElastiCache.ReplicationGroup("secondary", new()
    {
        ReplicationGroupId = "example-secondary",
        Description = "secondary replication group",
        GlobalReplicationGroupId = example.GlobalReplicationGroupId,
        NumCacheClusters = 1,
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/elasticache"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		primary, err := elasticache.NewReplicationGroup(ctx, "primary", &elasticache.ReplicationGroupArgs{
			ReplicationGroupId: pulumi.String("example-primary"),
			Description:        pulumi.String("primary replication group"),
			Engine:             pulumi.String("redis"),
			EngineVersion:      pulumi.String("5.0.6"),
			NodeType:           pulumi.String("cache.m5.large"),
			NumCacheClusters:   pulumi.Int(1),
		})
		if err != nil {
			return err
		}
		example, err := elasticache.NewGlobalReplicationGroup(ctx, "example", &elasticache.GlobalReplicationGroupArgs{
			GlobalReplicationGroupIdSuffix: pulumi.String("example"),
			PrimaryReplicationGroupId:      primary.ID(),
		})
		if err != nil {
			return err
		}
		_, err = elasticache.NewReplicationGroup(ctx, "secondary", &elasticache.ReplicationGroupArgs{
			ReplicationGroupId:       pulumi.String("example-secondary"),
			Description:              pulumi.String("secondary replication group"),
			GlobalReplicationGroupId: example.GlobalReplicationGroupId,
			NumCacheClusters:         pulumi.Int(1),
		})
		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.elasticache.ReplicationGroup;
import com.pulumi.aws.elasticache.ReplicationGroupArgs;
import com.pulumi.aws.elasticache.GlobalReplicationGroup;
import com.pulumi.aws.elasticache.GlobalReplicationGroupArgs;
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 primary = new ReplicationGroup("primary", ReplicationGroupArgs.builder()
            .replicationGroupId("example-primary")
            .description("primary replication group")
            .engine("redis")
            .engineVersion("5.0.6")
            .nodeType("cache.m5.large")
            .numCacheClusters(1)
            .build());
        var example = new GlobalReplicationGroup("example", GlobalReplicationGroupArgs.builder()
            .globalReplicationGroupIdSuffix("example")
            .primaryReplicationGroupId(primary.id())
            .build());
        var secondary = new ReplicationGroup("secondary", ReplicationGroupArgs.builder()
            .replicationGroupId("example-secondary")
            .description("secondary replication group")
            .globalReplicationGroupId(example.globalReplicationGroupId())
            .numCacheClusters(1)
            .build());
    }
}
Content copied to clipboard
resources:
  secondary:
    type: aws:elasticache:ReplicationGroup
    properties:
      replicationGroupId: example-secondary
      description: secondary replication group
      globalReplicationGroupId: ${example.globalReplicationGroupId}
      numCacheClusters: 1
  example:
    type: aws:elasticache:GlobalReplicationGroup
    properties:
      globalReplicationGroupIdSuffix: example
      primaryReplicationGroupId: ${primary.id}
  primary:
    type: aws:elasticache:ReplicationGroup
    properties:
      replicationGroupId: example-primary
      description: primary replication group
      engine: redis
      engineVersion: 5.0.6
      nodeType: cache.m5.large
      numCacheClusters: 1
Content copied to clipboard

Redis AUTH and In-Transit Encryption Enabled

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
const example = new aws.elasticache.ReplicationGroup("example", {
    replicationGroupId: "example",
    description: "example with authentication",
    nodeType: "cache.t2.micro",
    numCacheClusters: 1,
    port: 6379,
    subnetGroupName: exampleAwsElasticacheSubnetGroup.name,
    securityGroupIds: [exampleAwsSecurityGroup&#46;id],
    parameterGroupName: "default.redis5.0",
    engineVersion: "5.0.6",
    transitEncryptionEnabled: true,
    authToken: "abcdefgh1234567890",
    authTokenUpdateStrategy: "ROTATE",
});
Content copied to clipboard
import pulumi
import pulumi_aws as aws
example = aws.elasticache.ReplicationGroup("example",
    replication_group_id="example",
    description="example with authentication",
    node_type="cache.t2.micro",
    num_cache_clusters=1,
    port=6379,
    subnet_group_name=example_aws_elasticache_subnet_group["name"],
    security_group_ids=[example_aws_security_group["id"]],
    parameter_group_name="default.redis5.0",
    engine_version="5.0.6",
    transit_encryption_enabled=True,
    auth_token="abcdefgh1234567890",
    auth_token_update_strategy="ROTATE")
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.ElastiCache.ReplicationGroup("example", new()
    {
        ReplicationGroupId = "example",
        Description = "example with authentication",
        NodeType = "cache.t2.micro",
        NumCacheClusters = 1,
        Port = 6379,
        SubnetGroupName = exampleAwsElasticacheSubnetGroup.Name,
        SecurityGroupIds = new[]
        {
            exampleAwsSecurityGroup.Id,
        },
        ParameterGroupName = "default.redis5.0",
        EngineVersion = "5.0.6",
        TransitEncryptionEnabled = true,
        AuthToken = "abcdefgh1234567890",
        AuthTokenUpdateStrategy = "ROTATE",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/elasticache"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := elasticache.NewReplicationGroup(ctx, "example", &elasticache.ReplicationGroupArgs{
			ReplicationGroupId: pulumi.String("example"),
			Description:        pulumi.String("example with authentication"),
			NodeType:           pulumi.String("cache.t2.micro"),
			NumCacheClusters:   pulumi.Int(1),
			Port:               pulumi.Int(6379),
			SubnetGroupName:    pulumi.Any(exampleAwsElasticacheSubnetGroup.Name),
			SecurityGroupIds: pulumi.StringArray{
				exampleAwsSecurityGroup.Id,
			},
			ParameterGroupName:       pulumi.String("default.redis5.0"),
			EngineVersion:            pulumi.String("5.0.6"),
			TransitEncryptionEnabled: pulumi.Bool(true),
			AuthToken:                pulumi.String("abcdefgh1234567890"),
			AuthTokenUpdateStrategy:  pulumi.String("ROTATE"),
		})
		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.elasticache.ReplicationGroup;
import com.pulumi.aws.elasticache.ReplicationGroupArgs;
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 ReplicationGroup("example", ReplicationGroupArgs.builder()
            .replicationGroupId("example")
            .description("example with authentication")
            .nodeType("cache.t2.micro")
            .numCacheClusters(1)
            .port(6379)
            .subnetGroupName(exampleAwsElasticacheSubnetGroup.name())
            .securityGroupIds(exampleAwsSecurityGroup.id())
            .parameterGroupName("default.redis5.0")
            .engineVersion("5.0.6")
            .transitEncryptionEnabled(true)
            .authToken("abcdefgh1234567890")
            .authTokenUpdateStrategy("ROTATE")
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: aws:elasticache:ReplicationGroup
    properties:
      replicationGroupId: example
      description: example with authentication
      nodeType: cache.t2.micro
      numCacheClusters: 1
      port: 6379
      subnetGroupName: ${exampleAwsElasticacheSubnetGroup.name}
      securityGroupIds:
        - ${exampleAwsSecurityGroup.id}
      parameterGroupName: default.redis5.0
      engineVersion: 5.0.6
      transitEncryptionEnabled: true
      authToken: abcdefgh1234567890
      authTokenUpdateStrategy: ROTATE
Content copied to clipboard

When adding a new auth_token to a previously passwordless replication group, using the ROTATE update strategy will result in support for both the new token and passwordless authentication. To immediately require authorization when adding the initial token, use the SET strategy instead. See the Authenticating with the Redis AUTH command guide for additional details.

Import

Using pulumi import, import ElastiCache Replication Groups using the replication_group_id. For example:

$ pulumi import aws:elasticache/replicationGroup:ReplicationGroup my_replication_group replication-group-1
Content copied to clipboard

Properties

Link copied to clipboard
val applyImmediately: Output<Boolean>

Specifies whether any modifications are applied immediately, or during the next maintenance window. Default is false.

Link copied to clipboard
val arn: Output<String>

ARN of the created ElastiCache Replication Group.

Link copied to clipboard
val atRestEncryptionEnabled: Output<Boolean>

Whether to enable encryption at rest.

Link copied to clipboard
val authToken: Output<String>?

Password used to access a password protected server. Can be specified only if transit_encryption_enabled = true.

Link copied to clipboard
val authTokenUpdateStrategy: Output<String>?

Strategy to use when updating the auth_token. Valid values are SET, ROTATE, and DELETE. Defaults to ROTATE.

Link copied to clipboard
val automaticFailoverEnabled: Output<Boolean>?

Specifies whether a read-only replica will be automatically promoted to read/write primary if the existing primary fails. If enabled, num_cache_clusters must be greater than 1. Must be enabled for Redis (cluster mode enabled) replication groups. Defaults to false.

Link copied to clipboard
val autoMinorVersionUpgrade: Output<Boolean>

Specifies whether minor version engine upgrades will be applied automatically to the underlying Cache Cluster instances during the maintenance window. Only supported for engine type "redis" and if the engine version is 6 or higher. Defaults to true.

Link copied to clipboard
val clusterEnabled: Output<Boolean>

Indicates if cluster mode is enabled.

Link copied to clipboard
val configurationEndpointAddress: Output<String>

Address of the replication group configuration endpoint when cluster mode is enabled.

Link copied to clipboard
val dataTieringEnabled: Output<Boolean>

Enables data tiering. Data tiering is only supported for replication groups using the r6gd node type. This parameter must be set to true when using r6gd nodes.

Link copied to clipboard
val description: Output<String>

User-created description for the replication group. Must not be empty.

Link copied to clipboard
val engine: Output<String>?

Name of the cache engine to be used for the clusters in this replication group. The only valid value is redis.

Link copied to clipboard
val engineVersion: Output<String>

Version number of the cache engine to be used for the cache clusters in this replication group. If the version is 7 or higher, the major and minor version should be set, e.g., 7.2. If the version is 6, the major and minor version can be set, e.g., 6.2, or the minor version can be unspecified which will use the latest version at creation time, e.g., 6.x. Otherwise, specify the full version desired, e.g., 5.0.6. The actual engine version used is returned in the attribute engine_version_actual, see Attribute Reference below.

Link copied to clipboard
val engineVersionActual: Output<String>

Because ElastiCache pulls the latest minor or patch for a version, this attribute returns the running version of the cache engine.

Link copied to clipboard
val finalSnapshotIdentifier: Output<String>?

The name of your final node group (shard) snapshot. ElastiCache creates the snapshot from the primary node in the cluster. If omitted, no final snapshot will be made.

Link copied to clipboard
val globalReplicationGroupId: Output<String>

The ID of the global replication group to which this replication group should belong. If this parameter is specified, the replication group is added to the specified global replication group as a secondary replication group; otherwise, the replication group is not part of any global replication group. If global_replication_group_id is set, the num_node_groups parameter cannot be set.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val ipDiscovery: Output<String>

The IP version to advertise in the discovery protocol. Valid values are ipv4 or ipv6.

Link copied to clipboard
val kmsKeyId: Output<String>?

The ARN of the key that you wish to use if encrypting at rest. If not supplied, uses service managed encryption. Can be specified only if at_rest_encryption_enabled = true.

Link copied to clipboard
val logDeliveryConfigurations: Output<List<ReplicationGroupLogDeliveryConfiguration>>?

Specifies the destination and format of Redis SLOWLOG or Redis Engine Log. See the documentation on Amazon ElastiCache. See Log Delivery Configuration below for more details.

Link copied to clipboard
val maintenanceWindow: Output<String>

Specifies the weekly time range for when maintenance on the cache cluster is performed. The format is ddd:hh24:mi-ddd:hh24:mi (24H Clock UTC). The minimum maintenance window is a 60 minute period. Example: sun:05:00-sun:09:00

Link copied to clipboard
val memberClusters: Output<List<String>>

Identifiers of all the nodes that are part of this replication group.

Link copied to clipboard
val multiAzEnabled: Output<Boolean>?

Specifies whether to enable Multi-AZ Support for the replication group. If true, automatic_failover_enabled must also be enabled. Defaults to false.

Link copied to clipboard
val networkType: Output<String>

The IP versions for cache cluster connections. Valid values are ipv4, ipv6 or dual_stack.

Link copied to clipboard
val nodeType: Output<String>

Instance class to be used. See AWS documentation for information on supported node types and guidance on selecting node types. Required unless global_replication_group_id is set. Cannot be set if global_replication_group_id is set.

Link copied to clipboard
val notificationTopicArn: Output<String>?

ARN of an SNS topic to send ElastiCache notifications to. Example: arn:aws:sns:us-east-1:012345678999:my_sns_topic

Link copied to clipboard
val numCacheClusters: Output<Int>

Number of cache clusters (primary and replicas) this replication group will have. If Multi-AZ is enabled, the value of this parameter must be at least 2. Updates will occur before other modifications. Conflicts with num_node_groups. Defaults to 1.

Link copied to clipboard
val numNodeGroups: Output<Int>

Number of node groups (shards) for this Redis replication group. Changing this number will trigger a resizing operation before other settings modifications.

Link copied to clipboard
val parameterGroupName: Output<String>

Name of the parameter group to associate with this replication group. If this argument is omitted, the default cache parameter group for the specified engine is used. To enable "cluster mode", i.e., data sharding, use a parameter group that has the parameter cluster-enabled set to true.

Link copied to clipboard
val port: Output<Int>?

Port number on which each of the cache nodes will accept connections. For Memcache the default is 11211, and for Redis the default port is 6379.

Link copied to clipboard
val preferredCacheClusterAzs: Output<List<String>>?

List of EC2 availability zones in which the replication group's cache clusters will be created. The order of the availability zones in the list is considered. The first item in the list will be the primary node. Ignored when updating.

Link copied to clipboard
val primaryEndpointAddress: Output<String>

(Redis only) Address of the endpoint for the primary node in the replication group, if the cluster mode is disabled.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val readerEndpointAddress: Output<String>

(Redis only) Address of the endpoint for the reader node in the replication group, if the cluster mode is disabled.

Link copied to clipboard
val replicasPerNodeGroup: Output<Int>

Number of replica nodes in each node group. Changing this number will trigger a resizing operation before other settings modifications. Valid values are 0 to 5.

Link copied to clipboard
val replicationGroupId: Output<String>

Replication group identifier. This parameter is stored as a lowercase string. The following arguments are optional:

Link copied to clipboard
val securityGroupIds: Output<List<String>>

IDs of one or more Amazon VPC security groups associated with this replication group. Use this parameter only when you are creating a replication group in an Amazon Virtual Private Cloud.

Link copied to clipboard
val securityGroupNames: Output<List<String>>

Names of one or more Amazon VPC security groups associated with this replication group. Use this parameter only when you are creating a replication group in an Amazon Virtual Private Cloud.

Link copied to clipboard
val snapshotArns: Output<List<String>>?

List of ARNs that identify Redis RDB snapshot files stored in Amazon S3. The names object names cannot contain any commas.

Link copied to clipboard
val snapshotName: Output<String>?

Name of a snapshot from which to restore data into the new node group. Changing the snapshot_name forces a new resource.

Link copied to clipboard
val snapshotRetentionLimit: Output<Int>?

Number of days for which ElastiCache will retain automatic cache cluster snapshots before deleting them. For example, if you set SnapshotRetentionLimit to 5, then a snapshot that was taken today will be retained for 5 days before being deleted. If the value of snapshot_retention_limit is set to zero (0), backups are turned off. Please note that setting a snapshot_retention_limit is not supported on cache.t1.micro cache nodes

Link copied to clipboard
val snapshotWindow: Output<String>

Daily time range (in UTC) during which ElastiCache will begin taking a daily snapshot of your cache cluster. The minimum snapshot window is a 60 minute period. Example: 05:00-09:00

Link copied to clipboard
val subnetGroupName: Output<String>

Name of the cache subnet group to be used for the replication group.

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

Map of tags to assign to the resource. Adding tags to this resource will add or overwrite any existing tags on the clusters in the replication group and not to the group itself. 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 tagsAll: Output<Map<String, String>>

Map of tags assigned to the resource, including those inherited from the provider default_tags configuration block.

Link copied to clipboard
val transitEncryptionEnabled: Output<Boolean>

Whether to enable encryption in transit. Changing this argument with an engine_version<7.0.5 will force a replacement. Engine versions prior to 7.0.5 only allow this transit encryption to be configured during creation of the replication group.

Link copied to clipboard
val transitEncryptionMode: Output<String>

A setting that enables clients to migrate to in-transit encryption with no downtime. Valid values are preferred and required. When enabling encryption on an existing replication group, this must first be set to preferred before setting it to required in a subsequent apply. See the TransitEncryptionMode field in the CreateReplicationGroup API documentation for additional details.

Link copied to clipboard
val urn: Output<String>
Link copied to clipboard
val userGroupIds: Output<List<String>>?

User Group ID to associate with the replication group. Only a maximum of one (1) user group ID is valid. NOTE: This argument is a set because the AWS specification allows for multiple IDs. However, in practice, AWS only allows a maximum size of one.