Module types

Data structures used by operation inputs/outputs.

Modules

• builders
  Builders
• error
  Error types that Amazon ElastiCache can respond with.

Structs

• Authentication

  Indicates whether the user requires a password to authenticate.

• AuthenticationMode

  Specifies the authentication mode to use.

• AvailabilityZone

  Describes an Availability Zone in which the cluster is launched.

• CacheCluster

  Contains all of the attributes of a specific cluster.

• CacheEngineVersion

  Provides all of the details about a particular cache engine version.

• CacheNode

  Represents an individual cache node within a cluster. Each cache node runs its own instance of the cluster's protocol-compliant caching software - either Memcached, Valkey or Redis OSS.

  The following node types are supported by ElastiCache. Generally speaking, the current generation types provide more memory and computational power at lower cost when compared to their equivalent previous generation counterparts.

  • General purpose:

    • Current generation:

      M7g node types: cache.m7g.large, cache.m7g.xlarge, cache.m7g.2xlarge, cache.m7g.4xlarge, cache.m7g.8xlarge, cache.m7g.12xlarge, cache.m7g.16xlarge

      For region availability, see Supported Node Types

      M6g node types (available only for Redis OSS engine version 5.0.6 onward and for Memcached engine version 1.5.16 onward): cache.m6g.large, cache.m6g.xlarge, cache.m6g.2xlarge, cache.m6g.4xlarge, cache.m6g.8xlarge, cache.m6g.12xlarge, cache.m6g.16xlarge

      M5 node types: cache.m5.large, cache.m5.xlarge, cache.m5.2xlarge, cache.m5.4xlarge, cache.m5.12xlarge, cache.m5.24xlarge

      M4 node types: cache.m4.large, cache.m4.xlarge, cache.m4.2xlarge, cache.m4.4xlarge, cache.m4.10xlarge

      T4g node types (available only for Redis OSS engine version 5.0.6 onward and Memcached engine version 1.5.16 onward): cache.t4g.micro, cache.t4g.small, cache.t4g.medium

      T3 node types: cache.t3.micro, cache.t3.small, cache.t3.medium

      T2 node types: cache.t2.micro, cache.t2.small, cache.t2.medium

    • Previous generation: (not recommended. Existing clusters are still supported but creation of new clusters is not supported for these types.)

      T1 node types: cache.t1.micro

      M1 node types: cache.m1.small, cache.m1.medium, cache.m1.large, cache.m1.xlarge

      M3 node types: cache.m3.medium, cache.m3.large, cache.m3.xlarge, cache.m3.2xlarge

  • Compute optimized:

    • Previous generation: (not recommended. Existing clusters are still supported but creation of new clusters is not supported for these types.)

      C1 node types: cache.c1.xlarge

  • Memory optimized:

    • Current generation:

      R7g node types: cache.r7g.large, cache.r7g.xlarge, cache.r7g.2xlarge, cache.r7g.4xlarge, cache.r7g.8xlarge, cache.r7g.12xlarge, cache.r7g.16xlarge

      For region availability, see Supported Node Types

      R6g node types (available only for Redis OSS engine version 5.0.6 onward and for Memcached engine version 1.5.16 onward): cache.r6g.large, cache.r6g.xlarge, cache.r6g.2xlarge, cache.r6g.4xlarge, cache.r6g.8xlarge, cache.r6g.12xlarge, cache.r6g.16xlarge

      R5 node types: cache.r5.large, cache.r5.xlarge, cache.r5.2xlarge, cache.r5.4xlarge, cache.r5.12xlarge, cache.r5.24xlarge

      R4 node types: cache.r4.large, cache.r4.xlarge, cache.r4.2xlarge, cache.r4.4xlarge, cache.r4.8xlarge, cache.r4.16xlarge

    • Previous generation: (not recommended. Existing clusters are still supported but creation of new clusters is not supported for these types.)

      M2 node types: cache.m2.xlarge, cache.m2.2xlarge, cache.m2.4xlarge

      R3 node types: cache.r3.large, cache.r3.xlarge, cache.r3.2xlarge, cache.r3.4xlarge, cache.r3.8xlarge

  Additional node type info

  • All current generation instance types are created in Amazon VPC by default.

  • Valkey or Redis OSS append-only files (AOF) are not supported for T1 or T2 instances.

  • Valkey or Redis OSS Multi-AZ with automatic failover is not supported on T1 instances.

  • The configuration variables appendonly and appendfsync are not supported on Valkey, or on Redis OSS version 2.8.22 and later.

• CacheNodeTypeSpecificParameter

  A parameter that has a different value for each cache node type it is applied to. For example, in a Valkey or Redis OSS cluster, a cache.m1.large cache node type would have a larger maxmemory value than a cache.m1.small type.

• CacheNodeTypeSpecificValue

  A value that applies only to a certain cache node type.

• CacheNodeUpdateStatus

  The status of the service update on the cache node

• CacheParameterGroup

  Represents the output of a CreateCacheParameterGroup operation.

• CacheParameterGroupStatus

  Status of the cache parameter group.

• CacheSecurityGroup

  Represents the output of one of the following operations:

  • AuthorizeCacheSecurityGroupIngress

  • CreateCacheSecurityGroup

  • RevokeCacheSecurityGroupIngress

• CacheSecurityGroupMembership

  Represents a cluster's status within a particular cache security group.

• CacheSubnetGroup

  Represents the output of one of the following operations:

  • CreateCacheSubnetGroup

  • ModifyCacheSubnetGroup

• CacheUsageLimits

  The usage limits for storage and ElastiCache Processing Units for the cache.

• CloudWatchLogsDestinationDetails

  The configuration details of the CloudWatch Logs destination.

• ConfigureShard

  Node group (shard) configuration options when adding or removing replicas. Each node group (shard) configuration has the following members: NodeGroupId, NewReplicaCount, and PreferredAvailabilityZones.

• CustomerNodeEndpoint

  The endpoint from which data should be migrated.

• DataStorage

  The data storage limit.

• DestinationDetails

  Configuration details of either a CloudWatch Logs destination or Kinesis Data Firehose destination.

• Ec2SecurityGroup

  Provides ownership and status information for an Amazon EC2 security group.

• EcpuPerSecond

  The configuration for the number of ElastiCache Processing Units (ECPU) the cache can consume per second.

• Endpoint

  Represents the information required for client programs to connect to a cache node. This value is read-only.

• EngineDefaults

  Represents the output of a DescribeEngineDefaultParameters operation.

• Event

  Represents a single occurrence of something interesting within the system. Some examples of events are creating a cluster, adding or removing a cache node, or rebooting a node.

• Filter

  Used to streamline results of a search based on the property being filtered.

• GlobalNodeGroup

  Indicates the slot configuration and global identifier for a slice group.

• GlobalReplicationGroup

  Consists of a primary cluster that accepts writes and an associated secondary cluster that resides in a different Amazon region. The secondary cluster accepts only reads. The primary cluster automatically replicates updates to the secondary cluster.

  • The GlobalReplicationGroupIdSuffix represents the name of the Global datastore, which is what you use to associate a secondary cluster.

• GlobalReplicationGroupInfo

  The name of the Global datastore and role of this replication group in the Global datastore.

• GlobalReplicationGroupMember

  A member of a Global datastore. It contains the Replication Group Id, the Amazon region and the role of the replication group.

• KinesisFirehoseDestinationDetails

  The configuration details of the Kinesis Data Firehose destination.

• LogDeliveryConfiguration

  Returns the destination, format and type of the logs.

• LogDeliveryConfigurationRequest

  Specifies the destination, format and type of the logs.

• NodeGroup

  Represents a collection of cache nodes in a replication group. One node in the node group is the read/write primary node. All the other nodes are read-only Replica nodes.

• NodeGroupConfiguration

  Node group (shard) configuration options. Each node group (shard) configuration has the following: Slots, PrimaryAvailabilityZone, ReplicaAvailabilityZones, ReplicaCount.

• NodeGroupMember

  Represents a single node within a node group (shard).

• NodeGroupMemberUpdateStatus

  The status of the service update on the node group member

• NodeGroupUpdateStatus

  The status of the service update on the node group

• NodeSnapshot

  Represents an individual cache node in a snapshot of a cluster.

• NotificationConfiguration

  Describes a notification topic and its status. Notification topics are used for publishing ElastiCache events to subscribers using Amazon Simple Notification Service (SNS).

• Parameter

  Describes an individual setting that controls some aspect of ElastiCache behavior.

• ParameterNameValue

  Describes a name-value pair that is used to update the value of a parameter.

• PendingLogDeliveryConfiguration

  The log delivery configurations being modified

• PendingModifiedValues

  A group of settings that are applied to the cluster in the future, or that are currently being applied.

• ProcessedUpdateAction

  Update action that has been processed for the corresponding apply/stop request

• RecurringCharge

  Contains the specific price and frequency of a recurring charges for a reserved cache node, or for a reserved cache node offering.

• RegionalConfiguration

  A list of the replication groups

• ReplicationGroup

  Contains all of the attributes of a specific Valkey or Redis OSS replication group.

• ReplicationGroupPendingModifiedValues

  The settings to be applied to the Valkey or Redis OSS replication group, either immediately or during the next maintenance window.

• ReservedCacheNode

  Represents the output of a PurchaseReservedCacheNodesOffering operation.

• ReservedCacheNodesOffering

  Describes all of the attributes of a reserved cache node offering.

• ReshardingConfiguration

  A list of PreferredAvailabilityZones objects that specifies the configuration of a node group in the resharded cluster.

• ReshardingStatus

  The status of an online resharding operation.

• SecurityGroupMembership

  Represents a single cache security group and its status.

• ServerlessCache

  The resource representing a serverless cache.

• ServerlessCacheConfiguration

  The configuration settings for a specific serverless cache.

• ServerlessCacheSnapshot

  The resource representing a serverless cache snapshot. Available for Valkey, Redis OSS and Serverless Memcached only.

• ServiceUpdate

  An update that you can apply to your Valkey or Redis OSS clusters.

• SlotMigration

  Represents the progress of an online resharding operation.

• Snapshot

  Represents a copy of an entire Valkey or Redis OSS cluster as of the time when the snapshot was taken.

• Subnet

  Represents the subnet associated with a cluster. This parameter refers to subnets defined in Amazon Virtual Private Cloud (Amazon VPC) and used with ElastiCache.

• SubnetOutpost

  The ID of the outpost subnet.

• Tag

  A tag that can be added to an ElastiCache cluster or replication group. Tags are composed of a Key/Value pair. You can use tags to categorize and track all your ElastiCache resources, with the exception of global replication group. When you add or remove tags on replication groups, those actions will be replicated to all nodes in the replication group. A tag with a null Value is permitted.

• TimeRangeFilter

  Filters update actions from the service updates that are in available status during the time range.

• UnprocessedUpdateAction

  Update action that has failed to be processed for the corresponding apply/stop request

• UpdateAction

  The status of the service update for a specific replication group

• User
• UserGroup
• UserGroupPendingChanges

  Returns the updates being applied to the user group.

• UserGroupsUpdateStatus

  The status of the user group update.

Enums

• AuthTokenUpdateStatus
  When writing a match expression against AuthTokenUpdateStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AuthTokenUpdateStrategyType
  When writing a match expression against AuthTokenUpdateStrategyType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AuthenticationType
  When writing a match expression against AuthenticationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AutomaticFailoverStatus
  When writing a match expression against AutomaticFailoverStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• AzMode
  When writing a match expression against AzMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ChangeType
  When writing a match expression against ChangeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ClusterMode
  When writing a match expression against ClusterMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DataStorageUnit
  When writing a match expression against DataStorageUnit, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DataTieringStatus
  When writing a match expression against DataTieringStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• DestinationType
  When writing a match expression against DestinationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• InputAuthenticationType
  When writing a match expression against InputAuthenticationType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• IpDiscovery
  When writing a match expression against IpDiscovery, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• LogDeliveryConfigurationStatus
  When writing a match expression against LogDeliveryConfigurationStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• LogFormat
  When writing a match expression against LogFormat, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• LogType
  When writing a match expression against LogType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• MultiAzStatus
  When writing a match expression against MultiAzStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• NetworkType
  When writing a match expression against NetworkType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• NodeUpdateInitiatedBy
  When writing a match expression against NodeUpdateInitiatedBy, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• NodeUpdateStatus
  When writing a match expression against NodeUpdateStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• OutpostMode
  When writing a match expression against OutpostMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• PendingAutomaticFailoverStatus
  When writing a match expression against PendingAutomaticFailoverStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ServiceUpdateSeverity
  When writing a match expression against ServiceUpdateSeverity, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ServiceUpdateStatus
  When writing a match expression against ServiceUpdateStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• ServiceUpdateType
  When writing a match expression against ServiceUpdateType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• SlaMet
  When writing a match expression against SlaMet, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• SourceType
  When writing a match expression against SourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• TransitEncryptionMode
  When writing a match expression against TransitEncryptionMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
• UpdateActionStatus
  When writing a match expression against UpdateActionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.