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 and onwards: Creates a user.
-
#create_user_group(params = {}) ⇒ Types::UserGroup
For Valkey engine version 7.2 onwards and Redis OSS 6.0 onwards: 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
TagKeys
list 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
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). -
#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.
444 445 446 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 444 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.
550 551 552 553 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 550 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.
615 616 617 618 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 615 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.
667 668 669 670 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 667 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.
719 720 721 722 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 719 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.
828 829 830 831 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 828 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.
889 890 891 892 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 889 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
TargetSnapshotName
a 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.
1117 1118 1119 1120 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 1117 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.
1736 1737 1738 1739 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 1736 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.
1829 1830 1831 1832 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 1829 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.
1905 1906 1907 1908 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 1905 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).
2016 2017 2018 2019 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 2016 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.
2102 2103 2104 2105 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 2102 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.
2897 2898 2899 2900 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 2897 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.
3035 3036 3037 3038 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3035 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.
3099 3100 3101 3102 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3099 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.
3324 3325 3326 3327 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3324 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 and onwards: Creates a user. For more information, see Using Role Based Access Control (RBAC).
3415 3416 3417 3418 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3415 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 onwards: Creates a user group. For more information, see Using Role Based Access Control (RBAC)
3490 3491 3492 3493 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3490 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
3563 3564 3565 3566 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3563 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.
3713 3714 3715 3716 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3713 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
available
state
3880 3881 3882 3883 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3880 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.
3918 3919 3920 3921 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3918 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.
3958 3959 3960 3961 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3958 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.
3997 3998 3999 4000 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 3997 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
DeleteGlobalReplicationGroup
API 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.
4067 4068 4069 4070 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 4067 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.
4221 4222 4223 4224 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 4221 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.
4285 4286 4287 4288 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 4285 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.
4325 4326 4327 4328 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 4325 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.
4442 4443 4444 4445 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 4442 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).
4495 4496 4497 4498 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 4495 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).
4552 4553 4554 4555 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 4552 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
4825 4826 4827 4828 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 4825 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.
5079 5080 5081 5082 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 5079 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.
5157 5158 5159 5160 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 5157 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.
5637 5638 5639 5640 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 5637 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.
5708 5709 5710 5711 |
# File 'gems/aws-sdk-elasticache/lib/aws-sdk-elasticache/client.rb', line 5708 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.