Class: Aws::ElastiCache::Client
- Inherits:
- Seahorse::Client::Base
- Object
- Seahorse::Client::Base
- Aws::ElastiCache::Client
- Includes:
- ClientStubs
- Defined in:
- gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb
Overview
An API client for ElastiCache. To construct a client, you need to configure a :region and :credentials.
client = Aws::ElastiCache::Client.new( region: region_name, credentials: credentials, # ... ) For details on configuring region and credentials see the developer guide.
See #initialize for a full list of supported configuration options.
Instance Attribute Summary
Attributes inherited from Seahorse::Client::Base
API Operations collapse
- #add_tags_to_resource(params = {}) ⇒ Types::TagListMessage
A tag is a key-value pair where the key and value are case-sensitive.
- #authorize_cache_security_group_ingress(params = {}) ⇒ Types::AuthorizeCacheSecurityGroupIngressResult
Allows network ingress to a cache security group.
- #batch_apply_update_action(params = {}) ⇒ Types::UpdateActionResultsMessage
Apply the service update.
- #batch_stop_update_action(params = {}) ⇒ Types::UpdateActionResultsMessage
Stop the service update.
- #complete_migration(params = {}) ⇒ Types::CompleteMigrationResponse
Complete the migration of data.
- #copy_serverless_cache_snapshot(params = {}) ⇒ Types::CopyServerlessCacheSnapshotResponse
Creates a copy of an existing serverless cache’s snapshot.
- #copy_snapshot(params = {}) ⇒ Types::CopySnapshotResult
Makes a copy of an existing snapshot.
- #create_cache_cluster(params = {}) ⇒ Types::CreateCacheClusterResult
Creates a cluster.
- #create_cache_parameter_group(params = {}) ⇒ Types::CreateCacheParameterGroupResult
Creates a new Amazon ElastiCache cache parameter group.
- #create_cache_security_group(params = {}) ⇒ Types::CreateCacheSecurityGroupResult
Creates a new cache security group.
- #create_cache_subnet_group(params = {}) ⇒ Types::CreateCacheSubnetGroupResult
Creates a new cache subnet group.
- #create_global_replication_group(params = {}) ⇒ Types::CreateGlobalReplicationGroupResult
Global Datastore offers fully managed, fast, reliable and secure cross-region replication.
- #create_replication_group(params = {}) ⇒ Types::CreateReplicationGroupResult
Creates a Valkey or Redis OSS (cluster mode disabled) or a Valkey or Redis OSS (cluster mode enabled) replication group.
- #create_serverless_cache(params = {}) ⇒ Types::CreateServerlessCacheResponse
Creates a serverless cache.
- #create_serverless_cache_snapshot(params = {}) ⇒ Types::CreateServerlessCacheSnapshotResponse
This API creates a copy of an entire ServerlessCache at a specific moment in time.
- #create_snapshot(params = {}) ⇒ Types::CreateSnapshotResult
Creates a copy of an entire cluster or replication group at a specific moment in time.
- #create_user(params = {}) ⇒ Types::User
For Valkey engine version 7.2 onwards and Redis OSS 6.0 to 7.1: Creates a user.
- #create_user_group(params = {}) ⇒ Types::UserGroup
For Valkey engine version 7.2 onwards and Redis OSS 6.0 to 7.1: Creates a user group.
- #decrease_node_groups_in_global_replication_group(params = {}) ⇒ Types::DecreaseNodeGroupsInGlobalReplicationGroupResult
Decreases the number of node groups in a Global datastore.
- #decrease_replica_count(params = {}) ⇒ Types::DecreaseReplicaCountResult
Dynamically decreases the number of replicas in a Valkey or Redis OSS (cluster mode disabled) replication group or the number of replica nodes in one or more node groups (shards) of a Valkey or Redis OSS (cluster mode enabled) replication group.
- #delete_cache_cluster(params = {}) ⇒ Types::DeleteCacheClusterResult
Deletes a previously provisioned cluster.
- #delete_cache_parameter_group(params = {}) ⇒ Struct
Deletes the specified cache parameter group.
- #delete_cache_security_group(params = {}) ⇒ Struct
Deletes a cache security group.
- #delete_cache_subnet_group(params = {}) ⇒ Struct
Deletes a cache subnet group.
- #delete_global_replication_group(params = {}) ⇒ Types::DeleteGlobalReplicationGroupResult
Deleting a Global datastore is a two-step process:.
- #delete_replication_group(params = {}) ⇒ Types::DeleteReplicationGroupResult
Deletes an existing replication group.
- #delete_serverless_cache(params = {}) ⇒ Types::DeleteServerlessCacheResponse
Deletes a specified existing serverless cache.
- #delete_serverless_cache_snapshot(params = {}) ⇒ Types::DeleteServerlessCacheSnapshotResponse
Deletes an existing serverless cache snapshot.
- #delete_snapshot(params = {}) ⇒ Types::DeleteSnapshotResult
Deletes an existing snapshot.
- #delete_user(params = {}) ⇒ Types::User
For Valkey engine version 7.2 onwards and Redis OSS 6.0 onwards: Deletes a user.
- #delete_user_group(params = {}) ⇒ Types::UserGroup
For Valkey engine version 7.2 onwards and Redis OSS 6.0 onwards: Deletes a user group.
- #describe_cache_clusters(params = {}) ⇒ Types::CacheClusterMessage
Returns information about all provisioned clusters if no cluster identifier is specified, or about a specific cache cluster if a cluster identifier is supplied.
- #describe_cache_engine_versions(params = {}) ⇒ Types::CacheEngineVersionMessage
Returns a list of the available cache engines and their versions.
- #describe_cache_parameter_groups(params = {}) ⇒ Types::CacheParameterGroupsMessage
Returns a list of cache parameter group descriptions.
- #describe_cache_parameters(params = {}) ⇒ Types::CacheParameterGroupDetails
Returns the detailed parameter list for a particular cache parameter group.
- #describe_cache_security_groups(params = {}) ⇒ Types::CacheSecurityGroupMessage
Returns a list of cache security group descriptions.
- #describe_cache_subnet_groups(params = {}) ⇒ Types::CacheSubnetGroupMessage
Returns a list of cache subnet group descriptions.
- #describe_engine_default_parameters(params = {}) ⇒ Types::DescribeEngineDefaultParametersResult
Returns the default engine and system parameter information for the specified cache engine.
- #describe_events(params = {}) ⇒ Types::EventsMessage
Returns events related to clusters, cache security groups, and cache parameter groups.
- #describe_global_replication_groups(params = {}) ⇒ Types::DescribeGlobalReplicationGroupsResult
Returns information about a particular global replication group.
- #describe_replication_groups(params = {}) ⇒ Types::ReplicationGroupMessage
Returns information about a particular replication group.
- #describe_reserved_cache_nodes(params = {}) ⇒ Types::ReservedCacheNodeMessage
Returns information about reserved cache nodes for this account, or about a specified reserved cache node.
- #describe_reserved_cache_nodes_offerings(params = {}) ⇒ Types::ReservedCacheNodesOfferingMessage
Lists available reserved cache node offerings.
- #describe_serverless_cache_snapshots(params = {}) ⇒ Types::DescribeServerlessCacheSnapshotsResponse
Returns information about serverless cache snapshots.
- #describe_serverless_caches(params = {}) ⇒ Types::DescribeServerlessCachesResponse
Returns information about a specific serverless cache.
- #describe_service_updates(params = {}) ⇒ Types::ServiceUpdatesMessage
Returns details of the service updates.
- #describe_snapshots(params = {}) ⇒ Types::DescribeSnapshotsListMessage
Returns information about cluster or replication group snapshots.
- #describe_update_actions(params = {}) ⇒ Types::UpdateActionsMessage
Returns details of the update actions.
- #describe_user_groups(params = {}) ⇒ Types::DescribeUserGroupsResult
Returns a list of user groups.
- #describe_users(params = {}) ⇒ Types::DescribeUsersResult
Returns a list of users.
- #disassociate_global_replication_group(params = {}) ⇒ Types::DisassociateGlobalReplicationGroupResult
Remove a secondary cluster from the Global datastore using the Global datastore name.
- #export_serverless_cache_snapshot(params = {}) ⇒ Types::ExportServerlessCacheSnapshotResponse
Provides the functionality to export the serverless cache snapshot data to Amazon S3.
- #failover_global_replication_group(params = {}) ⇒ Types::FailoverGlobalReplicationGroupResult
Used to failover the primary region to a secondary region.
- #increase_node_groups_in_global_replication_group(params = {}) ⇒ Types::IncreaseNodeGroupsInGlobalReplicationGroupResult
Increase the number of node groups in the Global datastore.
- #increase_replica_count(params = {}) ⇒ Types::IncreaseReplicaCountResult
Dynamically increases the number of replicas in a Valkey or Redis OSS (cluster mode disabled) replication group or the number of replica nodes in one or more node groups (shards) of a Valkey or Redis OSS (cluster mode enabled) replication group.
- #list_allowed_node_type_modifications(params = {}) ⇒ Types::AllowedNodeTypeModificationsMessage
Lists all available node types that you can scale with your cluster's replication group's current node type.
- #list_tags_for_resource(params = {}) ⇒ Types::TagListMessage
Lists all tags currently on a named resource.
- #modify_cache_cluster(params = {}) ⇒ Types::ModifyCacheClusterResult
Modifies the settings for a cluster.
- #modify_cache_parameter_group(params = {}) ⇒ Types::CacheParameterGroupNameMessage
Modifies the parameters of a cache parameter group.
- #modify_cache_subnet_group(params = {}) ⇒ Types::ModifyCacheSubnetGroupResult
Modifies an existing cache subnet group.
- #modify_global_replication_group(params = {}) ⇒ Types::ModifyGlobalReplicationGroupResult
Modifies the settings for a Global datastore.
- #modify_replication_group(params = {}) ⇒ Types::ModifyReplicationGroupResult
Modifies the settings for a replication group.
- #modify_replication_group_shard_configuration(params = {}) ⇒ Types::ModifyReplicationGroupShardConfigurationResult
Modifies a replication group's shards (node groups) by allowing you to add shards, remove shards, or rebalance the keyspaces among existing shards.
- #modify_serverless_cache(params = {}) ⇒ Types::ModifyServerlessCacheResponse
This API modifies the attributes of a serverless cache.
- #modify_user(params = {}) ⇒ Types::User
Changes user password(s) and/or access string.
- #modify_user_group(params = {}) ⇒ Types::UserGroup
Changes the list of users that belong to the user group.
- #purchase_reserved_cache_nodes_offering(params = {}) ⇒ Types::PurchaseReservedCacheNodesOfferingResult
Allows you to purchase a reserved cache node offering.
- #rebalance_slots_in_global_replication_group(params = {}) ⇒ Types::RebalanceSlotsInGlobalReplicationGroupResult
Redistribute slots to ensure uniform distribution across existing shards in the cluster.
- #reboot_cache_cluster(params = {}) ⇒ Types::RebootCacheClusterResult
Reboots some, or all, of the cache nodes within a provisioned cluster.
- #remove_tags_from_resource(params = {}) ⇒ Types::TagListMessage
Removes the tags identified by the
TagKeyslist from the named resource. - #reset_cache_parameter_group(params = {}) ⇒ Types::CacheParameterGroupNameMessage
Modifies the parameters of a cache parameter group to the engine or system default value.
- #revoke_cache_security_group_ingress(params = {}) ⇒ Types::RevokeCacheSecurityGroupIngressResult
Revokes ingress from a cache security group.
- #start_migration(params = {}) ⇒ Types::StartMigrationResponse
Start the migration of data.
- #test_failover(params = {}) ⇒ Types::TestFailoverResult
Represents the input of a
TestFailoveroperation which tests automatic failover on a specified node group (called shard in the console) in a replication group (called cluster in the console). - #test_migration(params = {}) ⇒ Types::TestMigrationResponse
Async API to test connection between source and target replication group.
Instance Method Summary collapse
- #initialize(options) ⇒ Client constructor
A new instance of Client.
- #wait_until(waiter_name, params = {}, options = {}) {|w.waiter| ... } ⇒ Boolean
Polls an API operation until a resource enters a desired state.
Methods included from ClientStubs
#api_requests, #stub_data, #stub_responses
Methods inherited from Seahorse::Client::Base
add_plugin, api, clear_plugins, define, new, #operation_names, plugins, remove_plugin, set_api, set_plugins
Methods included from Seahorse::Client::HandlerBuilder
#handle, #handle_request, #handle_response
Constructor Details
#initialize(options) ⇒ Client
Returns a new instance of Client.
473 474 475 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 473 def initialize(*args) super end |
Instance Method Details
#add_tags_to_resource(params = {}) ⇒ Types::TagListMessage
A tag is a key-value pair where the key and value are case-sensitive. 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. For more information, see Resource-level permissions.
For example, you can use cost-allocation tags to your ElastiCache resources, Amazon generates a cost allocation report as a comma-separated value (CSV) file with your usage and costs aggregated by your tags. You can apply tags that represent business categories (such as cost centers, application names, or owners) to organize your costs across multiple services.
For more information, see Using Cost Allocation Tags in Amazon ElastiCache in the ElastiCache User Guide.
579 580 581 582 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 579 def (params = {}, = {}) req = build_request(:add_tags_to_resource, params) req.send_request() end |
#authorize_cache_security_group_ingress(params = {}) ⇒ Types::AuthorizeCacheSecurityGroupIngressResult
Allows network ingress to a cache security group. Applications using ElastiCache must be running on Amazon EC2, and Amazon EC2 security groups are used as the authorization mechanism.
644 645 646 647 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 644 def (params = {}, = {}) req = build_request(:authorize_cache_security_group_ingress, params) req.send_request() end |
#batch_apply_update_action(params = {}) ⇒ Types::UpdateActionResultsMessage
Apply the service update. For more information on service updates and applying them, see Applying Service Updates.
696 697 698 699 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 696 def batch_apply_update_action(params = {}, = {}) req = build_request(:batch_apply_update_action, params) req.send_request() end |
#batch_stop_update_action(params = {}) ⇒ Types::UpdateActionResultsMessage
Stop the service update. For more information on service updates and stopping them, see Stopping Service Updates.
748 749 750 751 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 748 def batch_stop_update_action(params = {}, = {}) req = build_request(:batch_stop_update_action, params) req.send_request() end |
#complete_migration(params = {}) ⇒ Types::CompleteMigrationResponse
Complete the migration of data.
857 858 859 860 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 857 def complete_migration(params = {}, = {}) req = build_request(:complete_migration, params) req.send_request() end |
#copy_serverless_cache_snapshot(params = {}) ⇒ Types::CopyServerlessCacheSnapshotResponse
Creates a copy of an existing serverless cache’s snapshot. Available for Valkey, Redis OSS and Serverless Memcached only.
918 919 920 921 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 918 def copy_serverless_cache_snapshot(params = {}, = {}) req = build_request(:copy_serverless_cache_snapshot, params) req.send_request() end |
#copy_snapshot(params = {}) ⇒ Types::CopySnapshotResult
Makes a copy of an existing snapshot.
Users or groups that have permissions to use the CopySnapshot operation can create their own Amazon S3 buckets and copy snapshots to it. To control access to your snapshots, use an IAM policy to control who has the ability to use the CopySnapshot operation. For more information about using IAM to control the use of ElastiCache operations, see Exporting Snapshots and Authentication & Access Control.
You could receive the following error messages.
Error Messages
Error Message: The S3 bucket %s is outside of the region.
Solution: Create an Amazon S3 bucket in the same region as your snapshot. For more information, see Step 1: Create an Amazon S3 Bucket in the ElastiCache User Guide.
Error Message: The S3 bucket %s does not exist.
Solution: Create an Amazon S3 bucket in the same region as your snapshot. For more information, see Step 1: Create an Amazon S3 Bucket in the ElastiCache User Guide.
Error Message: The S3 bucket %s is not owned by the authenticated user.
Solution: Create an Amazon S3 bucket in the same region as your snapshot. For more information, see Step 1: Create an Amazon S3 Bucket in the ElastiCache User Guide.
Error Message: The authenticated user does not have sufficient permissions to perform the desired activity.
Solution: Contact your system administrator to get the needed permissions.
Error Message: The S3 bucket %s already contains an object with key %s.
Solution: Give the
TargetSnapshotNamea new and unique value. If exporting a snapshot, you could alternatively create a new Amazon S3 bucket and use this same value forTargetSnapshotName.Error Message: ElastiCache has not been granted READ permissions %s on the S3 Bucket.
Solution: Add List and Read permissions on the bucket. For more information, see Step 2: Grant ElastiCache Access to Your Amazon S3 Bucket in the ElastiCache User Guide.
Error Message: ElastiCache has not been granted WRITE permissions %s on the S3 Bucket.
Solution: Add Upload/Delete permissions on the bucket. For more information, see Step 2: Grant ElastiCache Access to Your Amazon S3 Bucket in the ElastiCache User Guide.
Error Message: ElastiCache has not been granted READ_ACP permissions %s on the S3 Bucket.
Solution: Add View Permissions on the bucket. For more information, see Step 2: Grant ElastiCache Access to Your Amazon S3 Bucket in the ElastiCache User Guide.
1146 1147 1148 1149 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 1146 def copy_snapshot(params = {}, = {}) req = build_request(:copy_snapshot, params) req.send_request() end |
#create_cache_cluster(params = {}) ⇒ Types::CreateCacheClusterResult
Creates a cluster. All nodes in the cluster run the same protocol-compliant cache engine software, either Memcached, Valkey or Redis OSS.
This operation is not supported for Valkey or Redis OSS (cluster mode enabled) clusters.
1767 1768 1769 1770 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 1767 def create_cache_cluster(params = {}, = {}) req = build_request(:create_cache_cluster, params) req.send_request() end |
#create_cache_parameter_group(params = {}) ⇒ Types::CreateCacheParameterGroupResult
Creates a new Amazon ElastiCache cache parameter group. An ElastiCache cache parameter group is a collection of parameters and their values that are applied to all of the nodes in any cluster or replication group using the CacheParameterGroup.
A newly created CacheParameterGroup is an exact duplicate of the default parameter group for the CacheParameterGroupFamily. To customize the newly created CacheParameterGroup you can change the values of specific parameters. For more information, see:
ModifyCacheParameterGroup in the ElastiCache API Reference.
Parameters and Parameter Groups in the ElastiCache User Guide.
1860 1861 1862 1863 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 1860 def create_cache_parameter_group(params = {}, = {}) req = build_request(:create_cache_parameter_group, params) req.send_request() end |
#create_cache_security_group(params = {}) ⇒ Types::CreateCacheSecurityGroupResult
Creates a new cache security group. Use a cache security group to control access to one or more clusters.
Cache security groups are only used when you are creating a cluster outside of an Amazon Virtual Private Cloud (Amazon VPC). If you are creating a cluster inside of a VPC, use a cache subnet group instead. For more information, see CreateCacheSubnetGroup.
1936 1937 1938 1939 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 1936 def create_cache_security_group(params = {}, = {}) req = build_request(:create_cache_security_group, params) req.send_request() end |
#create_cache_subnet_group(params = {}) ⇒ Types::CreateCacheSubnetGroupResult
Creates a new cache subnet group.
Use this parameter only when you are creating a cluster in an Amazon Virtual Private Cloud (Amazon VPC).
2047 2048 2049 2050 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 2047 def create_cache_subnet_group(params = {}, = {}) req = build_request(:create_cache_subnet_group, params) req.send_request() end |
#create_global_replication_group(params = {}) ⇒ Types::CreateGlobalReplicationGroupResult
Global Datastore offers fully managed, fast, reliable and secure cross-region replication. Using Global Datastore with Valkey or Redis OSS, you can create cross-region read replica clusters for ElastiCache to enable low-latency reads and disaster recovery across regions. For more information, see Replication Across Regions Using Global Datastore.
The GlobalReplicationGroupIdSuffix is the name of the Global datastore.
The PrimaryReplicationGroupId represents the name of the primary cluster that accepts writes and will replicate updates to the secondary cluster.
2133 2134 2135 2136 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 2133 def create_global_replication_group(params = {}, = {}) req = build_request(:create_global_replication_group, params) req.send_request() end |
#create_replication_group(params = {}) ⇒ Types::CreateReplicationGroupResult
Creates a Valkey or Redis OSS (cluster mode disabled) or a Valkey or Redis OSS (cluster mode enabled) replication group.
This API can be used to create a standalone regional replication group or a secondary replication group associated with a Global datastore.
A Valkey or Redis OSS (cluster mode disabled) replication group is a collection of nodes, where one of the nodes is a read/write primary and the others are read-only replicas. Writes to the primary are asynchronously propagated to the replicas.
A Valkey or Redis OSS cluster-mode enabled cluster is comprised of from 1 to 90 shards (API/CLI: node groups). Each shard has a primary node and up to 5 read-only replica nodes. The configuration can range from 90 shards and 0 replicas to 15 shards and 5 replicas, which is the maximum number or replicas allowed.
The node or shard limit can be increased to a maximum of 500 per cluster if the Valkey or Redis OSS engine version is 5.0.6 or higher. For example, you can choose to configure a 500 node cluster that ranges between 83 shards (one primary and 5 replicas per shard) and 500 shards (single primary and no replicas). Make sure there are enough available IP addresses to accommodate the increase. Common pitfalls include the subnets in the subnet group have too small a CIDR range or the subnets are shared and heavily used by other clusters. For more information, see Creating a Subnet Group. For versions below 5.0.6, the limit is 250 per cluster.
To request a limit increase, see Amazon Service Limits and choose the limit type Nodes per cluster per instance type.
When a Valkey or Redis OSS (cluster mode disabled) replication group has been successfully created, you can add one or more read replicas to it, up to a total of 5 read replicas. If you need to increase or decrease the number of node groups (console: shards), you can use scaling. For more information, see Scaling self-designed clusters in the ElastiCache User Guide.
2928 2929 2930 2931 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 2928 def create_replication_group(params = {}, = {}) req = build_request(:create_replication_group, params) req.send_request() end |
#create_serverless_cache(params = {}) ⇒ Types::CreateServerlessCacheResponse
Creates a serverless cache.
3066 3067 3068 3069 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3066 def create_serverless_cache(params = {}, = {}) req = build_request(:create_serverless_cache, params) req.send_request() end |
#create_serverless_cache_snapshot(params = {}) ⇒ Types::CreateServerlessCacheSnapshotResponse
This API creates a copy of an entire ServerlessCache at a specific moment in time. Available for Valkey, Redis OSS and Serverless Memcached only.
3130 3131 3132 3133 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3130 def create_serverless_cache_snapshot(params = {}, = {}) req = build_request(:create_serverless_cache_snapshot, params) req.send_request() end |
#create_snapshot(params = {}) ⇒ Types::CreateSnapshotResult
Creates a copy of an entire cluster or replication group at a specific moment in time.
3355 3356 3357 3358 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3355 def create_snapshot(params = {}, = {}) req = build_request(:create_snapshot, params) req.send_request() end |
#create_user(params = {}) ⇒ Types::User
For Valkey engine version 7.2 onwards and Redis OSS 6.0 to 7.1: Creates a user. For more information, see Using Role Based Access Control (RBAC).
3446 3447 3448 3449 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3446 def create_user(params = {}, = {}) req = build_request(:create_user, params) req.send_request() end |
#create_user_group(params = {}) ⇒ Types::UserGroup
For Valkey engine version 7.2 onwards and Redis OSS 6.0 to 7.1: Creates a user group. For more information, see Using Role Based Access Control (RBAC)
3522 3523 3524 3525 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3522 def create_user_group(params = {}, = {}) req = build_request(:create_user_group, params) req.send_request() end |
#decrease_node_groups_in_global_replication_group(params = {}) ⇒ Types::DecreaseNodeGroupsInGlobalReplicationGroupResult
Decreases the number of node groups in a Global datastore
3595 3596 3597 3598 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3595 def decrease_node_groups_in_global_replication_group(params = {}, = {}) req = build_request(:decrease_node_groups_in_global_replication_group, params) req.send_request() end |
#decrease_replica_count(params = {}) ⇒ Types::DecreaseReplicaCountResult
Dynamically decreases the number of replicas in a Valkey or Redis OSS (cluster mode disabled) replication group or the number of replica nodes in one or more node groups (shards) of a Valkey or Redis OSS (cluster mode enabled) replication group. This operation is performed with no cluster down time.
3745 3746 3747 3748 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3745 def decrease_replica_count(params = {}, = {}) req = build_request(:decrease_replica_count, params) req.send_request() end |
#delete_cache_cluster(params = {}) ⇒ Types::DeleteCacheClusterResult
Deletes a previously provisioned cluster. DeleteCacheCluster deletes all associated cache nodes, node endpoints and the cluster itself. When you receive a successful response from this operation, Amazon ElastiCache immediately begins deleting the cluster; you cannot cancel or revert this operation.
This operation is not valid for:
Valkey or Redis OSS (cluster mode enabled) clusters
Valkey or Redis OSS (cluster mode disabled) clusters
A cluster that is the last read replica of a replication group
A cluster that is the primary node of a replication group
A node group (shard) that has Multi-AZ mode enabled
A cluster from a Valkey or Redis OSS (cluster mode enabled) replication group
A cluster that is not in the
availablestate
3914 3915 3916 3917 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3914 def delete_cache_cluster(params = {}, = {}) req = build_request(:delete_cache_cluster, params) req.send_request() end |
#delete_cache_parameter_group(params = {}) ⇒ Struct
Deletes the specified cache parameter group. You cannot delete a cache parameter group if it is associated with any cache clusters. You cannot delete the default cache parameter groups in your account.
3952 3953 3954 3955 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3952 def delete_cache_parameter_group(params = {}, = {}) req = build_request(:delete_cache_parameter_group, params) req.send_request() end |
#delete_cache_security_group(params = {}) ⇒ Struct
Deletes a cache security group.
3992 3993 3994 3995 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3992 def delete_cache_security_group(params = {}, = {}) req = build_request(:delete_cache_security_group, params) req.send_request() end |
#delete_cache_subnet_group(params = {}) ⇒ Struct
Deletes a cache subnet group.
4031 4032 4033 4034 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 4031 def delete_cache_subnet_group(params = {}, = {}) req = build_request(:delete_cache_subnet_group, params) req.send_request() end |
#delete_global_replication_group(params = {}) ⇒ Types::DeleteGlobalReplicationGroupResult
Deleting a Global datastore is a two-step process:
First, you must DisassociateGlobalReplicationGroup to remove the secondary clusters in the Global datastore.
Once the Global datastore contains only the primary cluster, you can use the
DeleteGlobalReplicationGroupAPI to delete the Global datastore while retainining the primary cluster usingRetainPrimaryReplicationGroup=true.
Since the Global Datastore has only a primary cluster, you can delete the Global Datastore while retaining the primary by setting RetainPrimaryReplicationGroup=true. The primary cluster is never deleted when deleting a Global Datastore. It can only be deleted when it no longer is associated with any Global Datastore.
When you receive a successful response from this operation, Amazon ElastiCache immediately begins deleting the selected resources; you cannot cancel or revert this operation.
4101 4102 4103 4104 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 4101 def delete_global_replication_group(params = {}, = {}) req = build_request(:delete_global_replication_group, params) req.send_request() end |
#delete_replication_group(params = {}) ⇒ Types::DeleteReplicationGroupResult
Deletes an existing replication group. By default, this operation deletes the entire replication group, including the primary/primaries and all of the read replicas. If the replication group has only one primary, you can optionally delete only the read replicas, while retaining the primary by setting RetainPrimaryCluster=true.
When you receive a successful response from this operation, Amazon ElastiCache immediately begins deleting the selected resources; you cannot cancel or revert this operation.
CreateSnapshot permission is required to create a final snapshot. Without this permission, the API call will fail with an Access Denied exception.
- This operation is valid for Redis OSS only.
4255 4256 4257 4258 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 4255 def delete_replication_group(params = {}, = {}) req = build_request(:delete_replication_group, params) req.send_request() end |
#delete_serverless_cache(params = {}) ⇒ Types::DeleteServerlessCacheResponse
Deletes a specified existing serverless cache.
CreateServerlessCacheSnapshot permission is required to create a final snapshot. Without this permission, the API call will fail with an Access Denied exception.
4319 4320 4321 4322 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 4319 def delete_serverless_cache(params = {}, = {}) req = build_request(:delete_serverless_cache, params) req.send_request() end |
#delete_serverless_cache_snapshot(params = {}) ⇒ Types::DeleteServerlessCacheSnapshotResponse
Deletes an existing serverless cache snapshot. Available for Valkey, Redis OSS and Serverless Memcached only.
4359 4360 4361 4362 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 4359 def delete_serverless_cache_snapshot(params = {}, = {}) req = build_request(:delete_serverless_cache_snapshot, params) req.send_request() end |
#delete_snapshot(params = {}) ⇒ Types::DeleteSnapshotResult
Deletes an existing snapshot. When you receive a successful response from this operation, ElastiCache immediately begins deleting the snapshot; you cannot cancel or revert this operation.
4476 4477 4478 4479 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 4476 def delete_snapshot(params = {}, = {}) req = build_request(:delete_snapshot, params) req.send_request() end |
#delete_user(params = {}) ⇒ Types::User
For Valkey engine version 7.2 onwards and Redis OSS 6.0 onwards: Deletes a user. The user will be removed from all user groups and in turn removed from all replication groups. For more information, see Using Role Based Access Control (RBAC).
4529 4530 4531 4532 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 4529 def delete_user(params = {}, = {}) req = build_request(:delete_user, params) req.send_request() end |
#delete_user_group(params = {}) ⇒ Types::UserGroup
For Valkey engine version 7.2 onwards and Redis OSS 6.0 onwards: Deletes a user group. The user group must first be disassociated from the replication group before it can be deleted. For more information, see Using Role Based Access Control (RBAC).
4586 4587 4588 4589 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 4586 def delete_user_group(params = {}, = {}) req = build_request(:delete_user_group, params) req.send_request() end |
#describe_cache_clusters(params = {}) ⇒ Types::CacheClusterMessage
Returns information about all provisioned clusters if no cluster identifier is specified, or about a specific cache cluster if a cluster identifier is supplied.
By default, abbreviated information about the clusters is returned. You can use the optional ShowCacheNodeInfo flag to retrieve detailed information about the cache nodes associated with the clusters. These details include the DNS address and port for the cache node endpoint.
If the cluster is in the creating state, only cluster-level information is displayed until all of the nodes are successfully provisioned.
If the cluster is in the deleting state, only cluster-level information is displayed.
If cache nodes are currently being added to the cluster, node endpoint information and creation time for the additional nodes are not displayed until they are completely provisioned. When the cluster state is available, the cluster is ready for use.
If cache nodes are currently being removed from the cluster, no endpoint information for the removed nodes is displayed.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
The following waiters are defined for this operation (see #wait_until for detailed usage):
- cache_cluster_available
- cache_cluster_deleted
4861 4862 4863 4864 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 4861 def describe_cache_clusters(params = {}, = {}) req = build_request(:describe_cache_clusters, params) req.send_request() end |
#describe_cache_engine_versions(params = {}) ⇒ Types::CacheEngineVersionMessage
Returns a list of the available cache engines and their versions.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
5115 5116 5117 5118 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 5115 def describe_cache_engine_versions(params = {}, = {}) req = build_request(:describe_cache_engine_versions, params) req.send_request() end |
#describe_cache_parameter_groups(params = {}) ⇒ Types::CacheParameterGroupsMessage
Returns a list of cache parameter group descriptions. If a cache parameter group name is specified, the list contains only the descriptions for that group.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
5193 5194 5195 5196 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 5193 def describe_cache_parameter_groups(params = {}, = {}) req = build_request(:describe_cache_parameter_groups, params) req.send_request() end |
#describe_cache_parameters(params = {}) ⇒ Types::CacheParameterGroupDetails
Returns the detailed parameter list for a particular cache parameter group.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
5673 5674 5675 5676 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 5673 def describe_cache_parameters(params = {}, = {}) req = build_request(:describe_cache_parameters, params) req.send_request() end |
#describe_cache_security_groups(params = {}) ⇒ Types::CacheSecurityGroupMessage
Returns a list of cache security group descriptions. If a cache security group name is specified, the list contains only the description of that group. This applicable only when you have ElastiCache in Classic setup
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
5744 5745 5746 5747 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 5744 def describe_cache_security_groups(params = {}, = {}) req = build_request(:describe_cache_security_groups, params) req.send_request() end |
#describe_cache_subnet_groups(params = {}) ⇒ Types::CacheSubnetGroupMessage
Returns a list of cache subnet group descriptions. If a subnet group name is specified, the list contains only the description of that group. This is applicable only when you have ElastiCache in VPC setup. All ElastiCache clusters now launch in VPC by default.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
5856 5857 5858 5859 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 5856 def describe_cache_subnet_groups(params = {}, = {}) req = build_request(:describe_cache_subnet_groups, params) req.send_request() end |
#describe_engine_default_parameters(params = {}) ⇒ Types::DescribeEngineDefaultParametersResult
Returns the default engine and system parameter information for the specified cache engine.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
6544 6545 6546 6547 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 6544 def describe_engine_default_parameters(params = {}, = {}) req = build_request(:describe_engine_default_parameters, params) req.send_request() end |
#describe_events(params = {}) ⇒ Types::EventsMessage
Returns events related to clusters, cache security groups, and cache parameter groups. You can obtain events specific to a particular cluster, cache security group, or cache parameter group by providing the name as a parameter.
By default, only the events occurring within the last hour are returned; however, you can retrieve up to 14 days' worth of events if necessary.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
6727 6728 6729 6730 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 6727 def describe_events(params = {}, = {}) req = build_request(:describe_events, params) req.send_request() end |
#describe_global_replication_groups(params = {}) ⇒ Types::DescribeGlobalReplicationGroupsResult
Returns information about a particular global replication group. If no identifier is specified, returns information about all Global datastores.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
6799 6800 6801 6802 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 6799 def describe_global_replication_groups(params = {}, = {}) req = build_request(:describe_global_replication_groups, params) req.send_request() end |
#describe_replication_groups(params = {}) ⇒ Types::ReplicationGroupMessage
Returns information about a particular replication group. If no identifier is specified, DescribeReplicationGroups returns information about all replication groups.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
The following waiters are defined for this operation (see #wait_until for detailed usage):
- replication_group_available
- replication_group_deleted
7003 7004 7005 7006 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 7003 def describe_replication_groups(params = {}, = {}) req = build_request(:describe_replication_groups, params) req.send_request() end |
#describe_reserved_cache_nodes(params = {}) ⇒ Types::ReservedCacheNodeMessage
Returns information about reserved cache nodes for this account, or about a specified reserved cache node.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
7222 7223 7224 7225 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 7222 def describe_reserved_cache_nodes(params = {}, = {}) req = build_request(:describe_reserved_cache_nodes, params) req.send_request() end |
#describe_reserved_cache_nodes_offerings(params = {}) ⇒ Types::ReservedCacheNodesOfferingMessage
Lists available reserved cache node offerings.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
7743 7744 7745 7746 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 7743 def describe_reserved_cache_nodes_offerings(params = {}, = {}) req = build_request(:describe_reserved_cache_nodes_offerings, params) req.send_request() end |
#describe_serverless_cache_snapshots(params = {}) ⇒ Types::DescribeServerlessCacheSnapshotsResponse
Returns information about serverless cache snapshots. By default, this API lists all of the customer’s serverless cache snapshots. It can also describe a single serverless cache snapshot, or the snapshots associated with a particular serverless cache. Available for Valkey, Redis OSS and Serverless Memcached only.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
7820 7821 7822 7823 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 7820 def describe_serverless_cache_snapshots(params = {}, = {}) req = build_request(:describe_serverless_cache_snapshots, params) req.send_request() end |
#describe_serverless_caches(params = {}) ⇒ Types::DescribeServerlessCachesResponse
Returns information about a specific serverless cache. If no identifier is specified, then the API returns information on all the serverless caches belonging to this Amazon Web Services account.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
7895 7896 7897 7898 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 7895 def describe_serverless_caches(params = {}, = {}) req = build_request(:describe_serverless_caches, params) req.send_request() end |
#describe_service_updates(params = {}) ⇒ Types::ServiceUpdatesMessage
Returns details of the service updates
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
7954 7955 7956 7957 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 7954 def describe_service_updates(params = {}, = {}) req = build_request(:describe_service_updates, params) req.send_request() end |
#describe_snapshots(params = {}) ⇒ Types::DescribeSnapshotsListMessage
Returns information about cluster or replication group snapshots. By default, DescribeSnapshots lists all of your snapshots; it can optionally describe a single snapshot, or just the snapshots associated with a particular cache cluster.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
8122 8123 8124 8125 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 8122 def describe_snapshots(params = {}, = {}) req = build_request(:describe_snapshots, params) req.send_request() end |
#describe_update_actions(params = {}) ⇒ Types::UpdateActionsMessage
Returns details of the update actions
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
8234 8235 8236 8237 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 8234 def describe_update_actions(params = {}, = {}) req = build_request(:describe_update_actions, params) req.send_request() end |
#describe_user_groups(params = {}) ⇒ Types::DescribeUserGroupsResult
Returns a list of user groups.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
8295 8296 8297 8298 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 8295 def describe_user_groups(params = {}, = {}) req = build_request(:describe_user_groups, params) req.send_request() end |
#describe_users(params = {}) ⇒ Types::DescribeUsersResult
Returns a list of users.
The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.
8365 8366 8367 8368 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 8365 def describe_users(params = {}, = {}) req = build_request(:describe_users, params) req.send_request() end |
#disassociate_global_replication_group(params = {}) ⇒ Types::DisassociateGlobalReplicationGroupResult
Remove a secondary cluster from the Global datastore using the Global datastore name. The secondary cluster will no longer receive updates from the primary cluster, but will remain as a standalone cluster in that Amazon region.
8425 8426 8427 8428 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 8425 def disassociate_global_replication_group(params = {}, = {}) req = build_request(:disassociate_global_replication_group, params) req.send_request() end |
#export_serverless_cache_snapshot(params = {}) ⇒ Types::ExportServerlessCacheSnapshotResponse
Provides the functionality to export the serverless cache snapshot data to Amazon S3. Available for Valkey and Redis OSS only.
8471 8472 8473 8474 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 8471 def export_serverless_cache_snapshot(params = {}, = {}) req = build_request(:export_serverless_cache_snapshot, params) req.send_request() end |
#failover_global_replication_group(params = {}) ⇒ Types::FailoverGlobalReplicationGroupResult
Used to failover the primary region to a secondary region. The secondary region will become primary, and all other clusters will become secondary.
8528 8529 8530 8531 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 8528 def failover_global_replication_group(params = {}, = {}) req = build_request(:failover_global_replication_group, params) req.send_request() end |
#increase_node_groups_in_global_replication_group(params = {}) ⇒ Types::IncreaseNodeGroupsInGlobalReplicationGroupResult
Increase the number of node groups in the Global datastore
8601 8602 8603 8604 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 8601 def increase_node_groups_in_global_replication_group(params = {}, = {}) req = build_request(:increase_node_groups_in_global_replication_group, params) req.send_request() end |
#increase_replica_count(params = {}) ⇒ Types::IncreaseReplicaCountResult
Dynamically increases the number of replicas in a Valkey or Redis OSS (cluster mode disabled) replication group or the number of replica nodes in one or more node groups (shards) of a Valkey or Redis OSS (cluster mode enabled) replication group. This operation is performed with no cluster down time.
8736 8737 8738 8739 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 8736 def increase_replica_count(params = {}, = {}) req = build_request(:increase_replica_count, params) req.send_request() end |
#list_allowed_node_type_modifications(params = {}) ⇒ Types::AllowedNodeTypeModificationsMessage
Lists all available node types that you can scale with your cluster's replication group's current node type.
When you use the ModifyCacheCluster or ModifyReplicationGroup operations to scale your cluster or replication group, the value of the CacheNodeType parameter must be one of the node types returned by this operation.
8827 8828 8829 8830 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 8827 def list_allowed_node_type_modifications(params = {}, = {}) req = build_request(:list_allowed_node_type_modifications, params) req.send_request() end |
#list_tags_for_resource(params = {}) ⇒ Types::TagListMessage
Lists all tags currently on a named resource.
A tag is a key-value pair where the key and value are case-sensitive. 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. For more information, see Resource-level permissions.
If the cluster is not in the available state, ListTagsForResource returns an error.
8905 8906 8907 8908 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 8905 def (params = {}, = {}) req = build_request(:list_tags_for_resource, params) req.send_request() end |
#modify_cache_cluster(params = {}) ⇒ Types::ModifyCacheClusterResult
Modifies the settings for a cluster. You can use this operation to change one or more cluster configuration parameters by specifying the parameters and the new values.
9409 9410 9411 9412 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 9409 def modify_cache_cluster(params = {}, = {}) req = build_request(:modify_cache_cluster, params) req.send_request() end |
#modify_cache_parameter_group(params = {}) ⇒ Types::CacheParameterGroupNameMessage
Modifies the parameters of a cache parameter group. You can modify up to 20 parameters in a single request by submitting a list parameter name and value pairs.
9475 9476 9477 9478 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 9475 def modify_cache_parameter_group(params = {}, = {}) req = build_request(:modify_cache_parameter_group, params) req.send_request() end |
#modify_cache_subnet_group(params = {}) ⇒ Types::ModifyCacheSubnetGroupResult
Modifies an existing cache subnet group.
9581 9582 9583 9584 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 9581 def modify_cache_subnet_group(params = {}, = {}) req = build_request(:modify_cache_subnet_group, params) req.send_request() end |
#modify_global_replication_group(params = {}) ⇒ Types::ModifyGlobalReplicationGroupResult
Modifies the settings for a Global datastore.
9665 9666 9667 9668 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 9665 def modify_global_replication_group(params = {}, = {}) req = build_request(:modify_global_replication_group, params) req.send_request() end |
#modify_replication_group(params = {}) ⇒ Types::ModifyReplicationGroupResult
Modifies the settings for a replication group. This is limited to Valkey and Redis OSS 7 and above.
Scaling for Valkey or Redis OSS (cluster mode enabled) in the ElastiCache User Guide
ModifyReplicationGroupShardConfiguration in the ElastiCache API Reference
10140 10141 10142 10143 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 10140 def modify_replication_group(params = {}, = {}) req = build_request(:modify_replication_group, params) req.send_request() end |
#modify_replication_group_shard_configuration(params = {}) ⇒ Types::ModifyReplicationGroupShardConfigurationResult
Modifies a replication group's shards (node groups) by allowing you to add shards, remove shards, or rebalance the keyspaces among existing shards.
10293 10294 10295 10296 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 10293 def modify_replication_group_shard_configuration(params = {}, = {}) req = build_request(:modify_replication_group_shard_configuration, params) req.send_request() end |
#modify_serverless_cache(params = {}) ⇒ Types::ModifyServerlessCacheResponse
This API modifies the attributes of a serverless cache.
10409 10410 10411 10412 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 10409 def modify_serverless_cache(params = {}, = {}) req = build_request(:modify_serverless_cache, params) req.send_request() end |
#modify_user(params = {}) ⇒ Types::User
Changes user password(s) and/or access string.
10483 10484 10485 10486 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 10483 def modify_user(params = {}, = {}) req = build_request(:modify_user, params) req.send_request() end |
#modify_user_group(params = {}) ⇒ Types::UserGroup
Changes the list of users that belong to the user group.
10546 10547 10548 10549 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 10546 def modify_user_group(params = {}, = {}) req = build_request(:modify_user_group, params) req.send_request() end |
#purchase_reserved_cache_nodes_offering(params = {}) ⇒ Types::PurchaseReservedCacheNodesOfferingResult
Allows you to purchase a reserved cache node offering. Reserved nodes are not eligible for cancellation and are non-refundable. For more information, see Managing Costs with Reserved Nodes.
10634 10635 10636 10637 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 10634 def purchase_reserved_cache_nodes_offering(params = {}, = {}) req = build_request(:purchase_reserved_cache_nodes_offering, params) req.send_request() end |
#rebalance_slots_in_global_replication_group(params = {}) ⇒ Types::RebalanceSlotsInGlobalReplicationGroupResult
Redistribute slots to ensure uniform distribution across existing shards in the cluster.
10686 10687 10688 10689 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 10686 def rebalance_slots_in_global_replication_group(params = {}, = {}) req = build_request(:rebalance_slots_in_global_replication_group, params) req.send_request() end |
#reboot_cache_cluster(params = {}) ⇒ Types::RebootCacheClusterResult
Reboots some, or all, of the cache nodes within a provisioned cluster. This operation applies any modified cache parameter groups to the cluster. The reboot operation takes place as soon as possible, and results in a momentary outage to the cluster. During the reboot, the cluster status is set to REBOOTING.
The reboot causes the contents of the cache (for each cache node being rebooted) to be lost.
When the reboot is complete, a cluster event is created.
Rebooting a cluster is currently supported on Memcached, Valkey and Redis OSS (cluster mode disabled) clusters. Rebooting is not supported on Valkey or Redis OSS (cluster mode enabled) clusters.
If you make changes to parameters that require a Valkey or Redis OSS (cluster mode enabled) cluster reboot for the changes to be applied, see Rebooting a Cluster for an alternate process.
10859 10860 10861 10862 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 10859 def reboot_cache_cluster(params = {}, = {}) req = build_request(:reboot_cache_cluster, params) req.send_request() end |
#remove_tags_from_resource(params = {}) ⇒ Types::TagListMessage
Removes the tags identified by the TagKeys list from the named resource. A tag is a key-value pair where the key and value are case-sensitive. 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. For more information, see Resource-level permissions.
10954 10955 10956 10957 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 10954 def (params = {}, = {}) req = build_request(:remove_tags_from_resource, params) req.send_request() end |
#reset_cache_parameter_group(params = {}) ⇒ Types::CacheParameterGroupNameMessage
Modifies the parameters of a cache parameter group to the engine or system default value. You can reset specific parameters by submitting a list of parameter names. To reset the entire cache parameter group, specify the ResetAllParameters and CacheParameterGroupName parameters.
11021 11022 11023 11024 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 11021 def reset_cache_parameter_group(params = {}, = {}) req = build_request(:reset_cache_parameter_group, params) req.send_request() end |
#revoke_cache_security_group_ingress(params = {}) ⇒ Types::RevokeCacheSecurityGroupIngressResult
Revokes ingress from a cache security group. Use this operation to disallow access from an Amazon EC2 security group that had been previously authorized.
11080 11081 11082 11083 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 11080 def revoke_cache_security_group_ingress(params = {}, = {}) req = build_request(:revoke_cache_security_group_ingress, params) req.send_request() end |
#start_migration(params = {}) ⇒ Types::StartMigrationResponse
Start the migration of data.
11193 11194 11195 11196 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 11193 def start_migration(params = {}, = {}) req = build_request(:start_migration, params) req.send_request() end |
#test_failover(params = {}) ⇒ Types::TestFailoverResult
Represents the input of a TestFailover operation which tests automatic failover on a specified node group (called shard in the console) in a replication group (called cluster in the console).
This API is designed for testing the behavior of your application in case of ElastiCache failover. It is not designed to be an operational tool for initiating a failover to overcome a problem you may have with the cluster. Moreover, in certain conditions such as large-scale operational events, Amazon may block this API.
Note the following
A customer can use this operation to test automatic failover on up to 15 shards (called node groups in the ElastiCache API and Amazon CLI) in any rolling 24-hour period.
If calling this operation on shards in different clusters (called replication groups in the API and CLI), the calls can be made concurrently.
If calling this operation multiple times on different shards in the same Valkey or Redis OSS (cluster mode enabled) replication group, the first node replacement must complete before a subsequent call can be made.
To determine whether the node replacement is complete you can check Events using the Amazon ElastiCache console, the Amazon CLI, or the ElastiCache API. Look for the following automatic failover related events, listed here in order of occurrance:
Replication group message:
Test Failover API called for node group <node-group-id>Cache cluster message:
Failover from primary node <primary-node-id> to replica node <node-id> completedReplication group message:
Failover from primary node <primary-node-id> to replica node <node-id> completedCache cluster message:
Recovering cache nodes <node-id>Cache cluster message:
Finished recovery for cache nodes <node-id>For more information see:Viewing ElastiCache Events in the ElastiCache User Guide
DescribeEvents in the ElastiCache API Reference
Also see, Testing Multi-AZ in the ElastiCache User Guide.
11360 11361 11362 11363 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 11360 def test_failover(params = {}, = {}) req = build_request(:test_failover, params) req.send_request() end |
#test_migration(params = {}) ⇒ Types::TestMigrationResponse
Async API to test connection between source and target replication group.
11473 11474 11475 11476 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 11473 def test_migration(params = {}, = {}) req = build_request(:test_migration, params) req.send_request() end |
#wait_until(waiter_name, params = {}, options = {}) {|w.waiter| ... } ⇒ Boolean
Polls an API operation until a resource enters a desired state.
Basic Usage
A waiter will call an API operation until:
- It is successful
- It enters a terminal state
- It makes the maximum number of attempts
In between attempts, the waiter will sleep.
# polls in a loop, sleeping between attempts client.wait_until(waiter_name, params) Configuration
You can configure the maximum number of polling attempts, and the delay (in seconds) between each polling attempt. You can pass configuration as the final arguments hash.
# poll for ~25 seconds client.wait_until(waiter_name, params, { max_attempts: 5, delay: 5, }) Callbacks
You can be notified before each polling attempt and before each delay. If you throw :success or :failure from these callbacks, it will terminate the waiter.
started_at = Time.now client.wait_until(waiter_name, params, { # disable max attempts max_attempts: nil, # poll for 1 hour, instead of a number of attempts before_wait: -> (attempts, response) do throw :failure if Time.now - started_at > 3600 end }) Handling Errors
When a waiter is unsuccessful, it will raise an error. All of the failure errors extend from Waiters::Errors::WaiterFailed.
begin client.wait_until(...) rescue Aws::Waiters::Errors::WaiterFailed # resource did not enter the desired state in time end Valid Waiters
The following table lists the valid waiter names, the operations they call, and the default :delay and :max_attempts values.
| waiter_name | params | :delay | :max_attempts |
|---|---|---|---|
| cache_cluster_available | #describe_cache_clusters | 15 | 40 |
| cache_cluster_deleted | #describe_cache_clusters | 15 | 40 |
| replication_group_available | #describe_replication_groups | 15 | 40 |
| replication_group_deleted | #describe_replication_groups | 15 | 40 |
11591 11592 11593 11594 11595 | # File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 11591 def wait_until(waiter_name, params = {}, = {}) w = waiter(waiter_name, ) yield(w.waiter) if block_given? # deprecated w.wait(params) end |