aws_sdk_elasticache

Module types

Source
Expand description

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.

ScaleConfig

Configuration settings for horizontal or vertical scaling operations on Memcached clusters.

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.