Package com.pulumi.aws.elasticache

Class ReplicationGroup

  • public class ReplicationGroup
extends com.pulumi.resources.CustomResource
    Provides an ElastiCache Replication Group resource. For working with a [Memcached cluster](https://docs.aws.amazon.com/AmazonElastiCache/latest/mem-ug/WhatIs.html) or a [single-node Redis instance (Cluster Mode Disabled)](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/WhatIs.html), see the `aws.elasticache.Cluster` resource. > **Note:** When you change an attribute, such as `engineVersion`, 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 `applyImmediately` flag to instruct the service to apply the change immediately. Using `applyImmediately` can result in a brief downtime as servers reboots. See the AWS Documentation on [Modifying an ElastiCache Cache Cluster](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Clusters.Modify.html) for more information. > **Note:** Any attribute changes that re-create the resource will be applied immediately, regardless of the value of `applyImmediately`. > **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"](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Clusters.Create.CON.Redis.html). With "Cluster Mode Enabled", the data will be stored in shards (called "node groups"). See [Redis Cluster Configuration](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/cluster-create-determine-requirements.html#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 OSS/Valkey Cluster Mode Disabled To create a single shard primary with single read replica: 
     
 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.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 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());
 
     }
 }
    You have two options for adjusting the number of replicas: * Adjusting `numCacheClusters` 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 `replicationGroupId` attribute. In this situation, you will need to utilize [`ignoreChanges`](https://www.pulumi.com/docs/intro/concepts/programming-model/#ignorechanges) to prevent perpetual differences with the `numberCacheCluster` attribute. 
     
 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 com.pulumi.resources.CustomResourceOptions;
 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 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(), CustomResourceOptions.builder()
                 .ignoreChanges("numCacheClusters")
                 .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());
 
         
 }
     }
 }
    ### Redis OSS/Valkey Cluster Mode Enabled To create two shards with a primary and a single read replica each: 
     
 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.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 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());
 
     }
 }
    ### Redis OSS/Valkey Cluster Mode Enabled with Node Group Configuration To create a cluster with specific availability zone placement and keyspace distribution: 
     
 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.ReplicationGroupNodeGroupConfigurationArgs;
 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 ReplicationGroup("example", ReplicationGroupArgs.builder()
             .nodeGroupConfigurations(            
                 ReplicationGroupNodeGroupConfigurationArgs.builder()
                     .nodeGroupId("0001")
                     .primaryAvailabilityZone("us-west-2a")
                     .replicaAvailabilityZones("us-west-2b")
                     .replicaCount(1)
                     .slots("0-8191")
                     .build(),
                 ReplicationGroupNodeGroupConfigurationArgs.builder()
                     .nodeGroupId("0002")
                     .primaryAvailabilityZone("us-west-2b")
                     .replicaAvailabilityZones("us-west-2a")
                     .replicaCount(1)
                     .slots("8192-16383")
                     .build())
             .replicationGroupId("tf-redis-cluster")
             .description("example description")
             .nodeType("cache.t2.small")
             .port(6379)
             .parameterGroupName("default.redis3.2.cluster.on")
             .automaticFailoverEnabled(true)
             .numNodeGroups(2)
             .build());
 
     }
 }
    ### Redis Log Delivery configuration 
     
 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.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 test = new ReplicationGroup("test", ReplicationGroupArgs.builder()
             .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())
             .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")
             .build());
 
     }
 }
    > **Note:** We currently do not support passing a `primaryClusterId` 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](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Replication.html) guide for full details on using Replication Groups. ### Creating a secondary replication group for a global replication group A Global Replication Group can have up to two secondary Replication Groups in different regions. These are added to an existing Global Replication Group. 
     
 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.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 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());
 
     }
 }
    ### Redis AUTH and In-Transit Encryption Enabled 
     
 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.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 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());
 
     }
 }
    > When adding a new `authToken` 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](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/auth.html) guide for additional details. ## Import Using `pulumi import`, import ElastiCache Replication Groups using the `replicationGroupId`. For example: ```sh $ pulumi import aws:elasticache/replicationGroup:ReplicationGroup my_replication_group replication-group-1 ```

    • Nested Class Summary

      • Nested classes/interfaces inherited from class com.pulumi.resources.CustomResource

        com.pulumi.resources.CustomResource.CustomResourceInternal

      • Nested classes/interfaces inherited from class com.pulumi.resources.Resource

        com.pulumi.resources.Resource.LazyField<T extends java.lang.Object>, com.pulumi.resources.Resource.LazyFields, com.pulumi.resources.Resource.ResourceInternal

    • Field Summary

      • Fields inherited from class com.pulumi.resources.Resource

        childResources, remote

    • Constructor Detail

      • ReplicationGroup

        public ReplicationGroup​(java.lang.String name)
        Parameters:
        name - The _unique_ name of the resulting resource.

      • ReplicationGroup

        public ReplicationGroup​(java.lang.String name,
                        ReplicationGroupArgs args)
        Parameters:
        name - The _unique_ name of the resulting resource.
        args - The arguments to use to populate this resource's properties.

      • ReplicationGroup

        public ReplicationGroup​(java.lang.String name,
                        ReplicationGroupArgs args,
                        @Nullable
                        com.pulumi.resources.CustomResourceOptions options)
        Parameters:
        name - The _unique_ name of the resulting resource.
        args - The arguments to use to populate this resource's properties.
        options - A bag of options that control this resource's behavior.

    • Method Detail

      • applyImmediately

        public com.pulumi.core.Output<java.lang.Boolean> applyImmediately()
        Returns:
        Specifies whether any modifications are applied immediately, or during the next maintenance window. Default is `false`.

      • arn

        public com.pulumi.core.Output<java.lang.String> arn()
        Returns:
        ARN of the created ElastiCache Replication Group.

      • atRestEncryptionEnabled

        public com.pulumi.core.Output<java.lang.Boolean> atRestEncryptionEnabled()
        Returns:
        Whether to enable encryption at rest. When `engine` is `redis`, default is `false`. When `engine` is `valkey`, default is `true`.

      • authToken

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> authToken()
        Returns:
        Password used to access a password protected server. Can be specified only if `transitEncryptionEnabled = true`.

      • authTokenUpdateStrategy

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> authTokenUpdateStrategy()
        Returns:
        Strategy used when modifying `authToken` or `authTokenWo` on an existing replication group. Not used during initial create. Valid values are `SET`, `ROTATE`, and `DELETE`. If omitted during an auth token change, AWS defaults to `ROTATE`. If value is `DELETE` then `authToken` and `authTokenWo` must be omitted.

      • authTokenWo

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> authTokenWo()
        Returns:
        **NOTE:** This field is write-only and its value will not be updated in state as part of read operations. Password used to access a password protected server, whose value will not be stored in state. Can be specified only if `transitEncryptionEnabled = true`. Conflicts with `authToken`. If set, requires `authTokenWoVersion` to be set.

      • authTokenWoVersion

        public com.pulumi.core.Output<java.util.Optional<java.lang.Integer>> authTokenWoVersion()
        Returns:
        Required when `authTokenWo` is set. Changing this value triggers an update to `authTokenWo`.

      • autoMinorVersionUpgrade

        public com.pulumi.core.Output<java.lang.Boolean> autoMinorVersionUpgrade()
        Returns:
        Specifies whether minor version engine upgrades will be applied automatically to the underlying Cache Cluster instances during the maintenance window. Only supported for engine types `"redis"` and `"valkey"` and if the engine version is 6 or higher. If this argument is not explicitly set in the configuration, AWS will set a default value of `true` and Terraform will not detect drift on this attribute.

      • automaticFailoverEnabled

        public com.pulumi.core.Output<java.util.Optional<java.lang.Boolean>> automaticFailoverEnabled()
        Returns:
        Specifies whether a read-only replica will be automatically promoted to read/write primary if the existing primary fails. If enabled, `numCacheClusters` must be greater than 1. Must be enabled for Redis (cluster mode enabled) replication groups. Defaults to `false`.

      • clusterEnabled

        public com.pulumi.core.Output<java.lang.Boolean> clusterEnabled()
        Returns:
        Indicates if cluster mode is enabled.

      • clusterMode

        public com.pulumi.core.Output<java.lang.String> clusterMode()
        Returns:
        Specifies whether cluster mode is enabled or disabled. Valid values are `enabled` or `disabled` or `compatible`

      • configurationEndpointAddress

        public com.pulumi.core.Output<java.lang.String> configurationEndpointAddress()
        Returns:
        Address of the replication group configuration endpoint when cluster mode is enabled.

      • dataTieringEnabled

        public com.pulumi.core.Output<java.lang.Boolean> dataTieringEnabled()
        Returns:
        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.

      • description

        public com.pulumi.core.Output<java.lang.String> description()
        Returns:
        User-created description for the replication group. Must not be empty.

      • durability

        public com.pulumi.core.Output<java.lang.String> durability()
        Returns:
        Specifies the durability mode for the replication group. Valid values are `default`, `async`, `sync`, or `disabled`. Requires cluster mode enabled and Valkey 9.0 or higher.

      • engine

        public com.pulumi.core.Output<java.lang.String> engine()
        Returns:
        Name of the cache engine to be used for the clusters in this replication group. Valid values are `redis` or `valkey`. Default is `redis`.

      • engineVersion

        public com.pulumi.core.Output<java.lang.String> engineVersion()
        Returns:
        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 `engineVersionActual`, see Attribute Reference below.

      • engineVersionActual

        public com.pulumi.core.Output<java.lang.String> engineVersionActual()
        Returns:
        Because ElastiCache pulls the latest minor or patch for a version, this attribute returns the running version of the cache engine.

      • finalSnapshotIdentifier

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> finalSnapshotIdentifier()
        Returns:
        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.

      • globalReplicationGroupId

        public com.pulumi.core.Output<java.lang.String> globalReplicationGroupId()
        Returns:
        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 `globalReplicationGroupId` is set, the `numNodeGroups` parameter cannot be set.

      • ipDiscovery

        public com.pulumi.core.Output<java.lang.String> ipDiscovery()
        Returns:
        The IP version to advertise in the discovery protocol. Valid values are `ipv4` or `ipv6`.

      • kmsKeyId

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> kmsKeyId()
        Returns:
        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 `atRestEncryptionEnabled = true`.

      • logDeliveryConfigurations

        public com.pulumi.core.Output<java.util.Optional<java.util.List<ReplicationGroupLogDeliveryConfiguration>>> logDeliveryConfigurations()
        Returns:
        Specifies the destination and format of Redis OSS/Valkey [SLOWLOG](https://redis.io/commands/slowlog) or Redis OSS/Valkey [Engine Log](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Log_Delivery.html#Log_contents-engine-log). See the documentation on [Amazon ElastiCache](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Log_Delivery.html#Log_contents-engine-log). See Log Delivery Configuration below for more details.

      • maintenanceWindow

        public com.pulumi.core.Output<java.lang.String> maintenanceWindow()
        Returns:
        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`

      • memberClusters

        public com.pulumi.core.Output<java.util.List<java.lang.String>> memberClusters()
        Returns:
        Identifiers of all the nodes that are part of this replication group.

      • multiAzEnabled

        public com.pulumi.core.Output<java.util.Optional<java.lang.Boolean>> multiAzEnabled()
        Returns:
        Specifies whether to enable Multi-AZ Support for the replication group. If `true`, `automaticFailoverEnabled` must also be enabled. Defaults to `false`.

      • networkType

        public com.pulumi.core.Output<java.lang.String> networkType()
        Returns:
        The IP versions for cache cluster connections. Valid values are `ipv4`, `ipv6` or `dualStack`.

      • nodeGroupConfigurations

        public com.pulumi.core.Output<java.util.List<ReplicationGroupNodeGroupConfiguration>> nodeGroupConfigurations()
        Returns:
        Configuration block for node groups (shards). Can be specified only if `numNodeGroups` is set. Conflicts with `preferredCacheClusterAzs`. See Node Group Configuration below for more details.

      • nodeType

        public com.pulumi.core.Output<java.lang.String> nodeType()
        Returns:
        Instance class to be used. See AWS documentation for information on [supported node types](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/CacheNodes.SupportedTypes.html) and [guidance on selecting node types](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/nodes-select-size.html). Required unless `globalReplicationGroupId` is set. Cannot be set if `globalReplicationGroupId` is set.

      • notificationTopicArn

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> notificationTopicArn()
        Returns:
        ARN of an SNS topic to send ElastiCache notifications to. Example: `arn:aws:sns:us-east-1:012345678999:my_sns_topic`

      • numCacheClusters

        public com.pulumi.core.Output<java.lang.Integer> numCacheClusters()
        Returns:
        Number of cache clusters (primary and replicas) this replication group will have. If `automaticFailoverEnabled` or `multiAzEnabled` are `true`, must be at least 2. Updates will occur before other modifications. Conflicts with `numNodeGroups` and `replicasPerNodeGroup`. Defaults to `1`.

      • numNodeGroups

        public com.pulumi.core.Output<java.lang.Integer> numNodeGroups()
        Returns:
        Number of node groups (shards) for this Redis replication group. Changing this number will trigger a resizing operation before other settings modifications. Conflicts with `numCacheClusters`.

      • parameterGroupName

        public com.pulumi.core.Output<java.lang.String> parameterGroupName()
        Returns:
        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.

      • port

        public com.pulumi.core.Output<java.util.Optional<java.lang.Integer>> port()
        Returns:
        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.

      • preferredCacheClusterAzs

        public com.pulumi.core.Output<java.util.Optional<java.util.List<java.lang.String>>> preferredCacheClusterAzs()
        Returns:
        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.

      • primaryEndpointAddress

        public com.pulumi.core.Output<java.lang.String> primaryEndpointAddress()
        Returns:
        (Redis only) Address of the endpoint for the primary node in the replication group, if the cluster mode is disabled.

      • readerEndpointAddress

        public com.pulumi.core.Output<java.lang.String> readerEndpointAddress()
        Returns:
        (Redis only) Address of the endpoint for the reader node in the replication group, if the cluster mode is disabled.

      • region

        public com.pulumi.core.Output<java.lang.String> region()
        Returns:
        Region where this resource will be [managed](https://docs.aws.amazon.com/general/latest/gr/rande.html#regional-endpoints). Defaults to the Region set in the provider configuration.

      • replicasPerNodeGroup

        public com.pulumi.core.Output<java.lang.Integer> replicasPerNodeGroup()
        Returns:
        Number of replica nodes in each node group. Changing this number will trigger a resizing operation before other settings modifications. Default AWS limit is 5. Higher values may be available with a quota increase. Conflicts with `numCacheClusters`. Can only be set if `numNodeGroups` is set.

      • replicationGroupId

        public com.pulumi.core.Output<java.lang.String> replicationGroupId()
        Returns:
        Replication group identifier. This parameter is stored as a lowercase string. The following arguments are optional:

      • securityGroupIds

        public com.pulumi.core.Output<java.util.List<java.lang.String>> securityGroupIds()
        Returns:
        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 a VPC.

      • securityGroupNames

        public com.pulumi.core.Output<java.util.List<java.lang.String>> securityGroupNames()
        Returns:
        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 a VPC.

      • snapshotArns

        public com.pulumi.core.Output<java.util.Optional<java.util.List<java.lang.String>>> snapshotArns()
        Returns:
        List of ARNs that identify Redis RDB snapshot files stored in Amazon S3. The names object names cannot contain any commas.

      • snapshotName

        public com.pulumi.core.Output<java.util.Optional<java.lang.String>> snapshotName()
        Returns:
        Name of a snapshot from which to restore data into the new node group. Changing the `snapshotName` forces a new resource.

      • snapshotRetentionLimit

        public com.pulumi.core.Output<java.util.Optional<java.lang.Integer>> snapshotRetentionLimit()
        Returns:
        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 `snapshotRetentionLimit` is set to zero (0), backups are turned off. Please note that setting a `snapshotRetentionLimit` is not supported on cache.t1.micro cache nodes

      • snapshotWindow

        public com.pulumi.core.Output<java.lang.String> snapshotWindow()
        Returns:
        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`

      • subnetGroupName

        public com.pulumi.core.Output<java.lang.String> subnetGroupName()
        Returns:
        Name of the cache subnet group to be used for the replication group.

      • tags

        public com.pulumi.core.Output<java.util.Optional<java.util.Map<java.lang.String,​java.lang.String>>> tags()
        Returns:
        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 `defaultTags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.

      • tagsAll

        public com.pulumi.core.Output<java.util.Map<java.lang.String,​java.lang.String>> tagsAll()
        Returns:
        Map of tags assigned to the resource, including those inherited from the provider `defaultTags` configuration block.

      • transitEncryptionEnabled

        public com.pulumi.core.Output<java.lang.Boolean> transitEncryptionEnabled()
        Returns:
        Whether to enable encryption in transit. Changing this argument with an `engineVersion` < `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.

      • transitEncryptionMode

        public com.pulumi.core.Output<java.lang.String> transitEncryptionMode()
        Returns:
        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](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateReplicationGroup.html) for additional details.

      • userGroupIds

        public com.pulumi.core.Output<java.util.Optional<java.util.List<java.lang.String>>> userGroupIds()
        Returns:
        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.

      • get

        public static ReplicationGroup get​(java.lang.String name,
                                   com.pulumi.core.Output<java.lang.String> id,
                                   @Nullable
                                   ReplicationGroupState state,
                                   @Nullable
                                   com.pulumi.resources.CustomResourceOptions options)
        Get an existing Host resource's state with the given name, ID, and optional extra properties used to qualify the lookup.
        Parameters:
        name - The _unique_ name of the resulting resource.
        id - The _unique_ provider ID of the resource to lookup.
        state -
        options - Optional settings to control the behavior of the CustomResource.