Class: Aws::ElastiCache::Client
- Inherits:
-
Seahorse::Client::Base
- Object
- Seahorse::Client::Base
- Aws::ElastiCache::Client
- Includes:
- ClientStubs
- Defined in:
- lib/aws-sdk-elasticache/client.rb
Class Attribute Summary collapse
- .identifier ⇒ Object readonly private
API Operations collapse
-
#add_tags_to_resource(params = {}) ⇒ Types::TagListMessage
Adds up to 50 cost allocation tags to the named resource.
-
#authorize_cache_security_group_ingress(params = {}) ⇒ Types::AuthorizeCacheSecurityGroupIngressResult
Allows network ingress to a cache security group.
-
#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_replication_group(params = {}) ⇒ Types::CreateReplicationGroupResult
Creates a Redis (cluster mode disabled) or a Redis (cluster mode enabled) replication group.
-
#create_snapshot(params = {}) ⇒ Types::CreateSnapshotResult
Creates a copy of an entire cluster or replication group at a specific moment in time.
-
#decrease_replica_count(params = {}) ⇒ Types::DecreaseReplicaCountResult
Dynamically decreases the number of replics in a Redis (cluster mode disabled) replication group or the number of replica nodes in one or more node groups (shards) of a Redis (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_replication_group(params = {}) ⇒ Types::DeleteReplicationGroupResult
Deletes an existing replication group.
-
#delete_snapshot(params = {}) ⇒ Types::DeleteSnapshotResult
Deletes an existing snapshot.
-
#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_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_snapshots(params = {}) ⇒ Types::DescribeSnapshotsListMessage
Returns information about cluster or replication group snapshots.
-
#increase_replica_count(params = {}) ⇒ Types::IncreaseReplicaCountResult
Dynamically increases the number of replics in a Redis (cluster mode disabled) replication group or the number of replica nodes in one or more node groups (shards) of a Redis (cluster mode enabled) replication group.
-
#list_allowed_node_type_modifications(params = {}) ⇒ Types::AllowedNodeTypeModificationsMessage
Lists all available node types that you can scale your Redis cluster’s or replication group’s current node type up to.
-
#list_tags_for_resource(params = {}) ⇒ Types::TagListMessage
Lists all cost allocation tags currently on the 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_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 exisiting shards.
-
#purchase_reserved_cache_nodes_offering(params = {}) ⇒ Types::PurchaseReservedCacheNodesOfferingResult
Allows you to purchase a reserved cache node offering.
-
#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.
-
#test_failover(params = {}) ⇒ Types::TestFailoverResult
Represents the input of a ‘TestFailover` operation which test automatic failover on a specified node group (called shard in the console) in a replication group (called cluster in the console).
Class Method Summary collapse
- .errors_module ⇒ Object private
Instance Method Summary collapse
- #build_request(operation_name, params = {}) ⇒ Object private
-
#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.
- #waiter_names ⇒ Object deprecated private Deprecated.
Constructor Details
#initialize(options) ⇒ Client
Returns a new instance of Client.
202 203 204 |
# File 'lib/aws-sdk-elasticache/client.rb', line 202 def initialize(*args) super end |
Class Attribute Details
.identifier ⇒ Object (readonly)
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
7704 7705 7706 |
# File 'lib/aws-sdk-elasticache/client.rb', line 7704 def identifier @identifier end |
Class Method Details
.errors_module ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
7707 7708 7709 |
# File 'lib/aws-sdk-elasticache/client.rb', line 7707 def errors_module Errors end |
Instance Method Details
#add_tags_to_resource(params = {}) ⇒ Types::TagListMessage
Adds up to 50 cost allocation tags to the named resource. A cost allocation tag is a key-value pair where the key and value are case-sensitive. You can use cost allocation tags to categorize and track your AWS costs.
When you apply tags to your ElastiCache resources, AWS 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*.
[1]: docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Tagging.html
302 303 304 305 |
# File 'lib/aws-sdk-elasticache/client.rb', line 302 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.
<note markdown=“1”> You cannot authorize ingress from an Amazon EC2 security group in one region to an ElastiCache cluster in another region.
</note>
366 367 368 369 |
# File 'lib/aws-sdk-elasticache/client.rb', line 366 def (params = {}, = {}) req = build_request(:authorize_cache_security_group_ingress, params) req.send_request() end |
#build_request(operation_name, params = {}) ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
7563 7564 7565 7566 7567 7568 7569 7570 7571 7572 7573 7574 |
# File 'lib/aws-sdk-elasticache/client.rb', line 7563 def build_request(operation_name, params = {}) handlers = @handlers.for(operation_name) context = Seahorse::Client::RequestContext.new( operation_name: operation_name, operation: config.api.operation(operation_name), client: self, params: params, config: config) context[:gem_name] = 'aws-sdk-elasticache' context[:gem_version] = '1.10.0' Seahorse::Client::Request.new(handlers, context) end |
#copy_snapshot(params = {}) ⇒ Types::CopySnapshotResult
Makes a copy of an existing snapshot.
<note markdown=“1”> This operation is valid for Redis only.
</note>
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 for `TargetSnapshotName`.
-
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.
[1]: docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Snapshots.Exporting.html [2]: docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/IAM.html [3]: docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Snapshots.Exporting.html#Snapshots.Exporting.CreateBucket [4]: docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Snapshots.Exporting.html#Snapshots.Exporting.GrantAccess
572 573 574 575 |
# File 'lib/aws-sdk-elasticache/client.rb', line 572 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 or Redis.
This operation is not supported for Redis (cluster mode enabled) clusters.
1088 1089 1090 1091 |
# File 'lib/aws-sdk-elasticache/client.rb', line 1088 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][1
-
in the ElastiCache API Reference.
- Parameters and Parameter Groups][2
-
in the ElastiCache User Guide.
[1]: docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyCacheParameterGroup.html [2]: docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/ParameterGroups.html
1167 1168 1169 1170 |
# File 'lib/aws-sdk-elasticache/client.rb', line 1167 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].
[1]: docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateCacheSubnetGroup.html
1231 1232 1233 1234 |
# File 'lib/aws-sdk-elasticache/client.rb', line 1231 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).
1325 1326 1327 1328 |
# File 'lib/aws-sdk-elasticache/client.rb', line 1325 def create_cache_subnet_group(params = {}, = {}) req = build_request(:create_cache_subnet_group, params) req.send_request() end |
#create_replication_group(params = {}) ⇒ Types::CreateReplicationGroupResult
Creates a Redis (cluster mode disabled) or a Redis (cluster mode enabled) replication group.
A Redis (cluster mode disabled) replication group is a collection of clusters, where one of the clusters is a read/write primary and the others are read-only replicas. Writes to the primary are asynchronously propagated to the replicas.
A Redis (cluster mode enabled) replication group is a collection of 1 to 15 node groups (shards). Each node group (shard) has one read/write primary node and up to 5 read-only replica nodes. Writes to the primary are asynchronously propagated to the replicas. Redis (cluster mode enabled) replication groups partition the data across node groups (shards).
When a Redis (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. You cannot alter a Redis (cluster mode enabled) replication group after it has been created. However, if you need to increase or decrease the number of node groups (console: shards), you can avail yourself of ElastiCache for Redis’ enhanced backup and restore. For more information, see [Restoring From a Backup with Cluster Resizing] in the *ElastiCache User Guide*.
<note markdown=“1”> This operation is valid for Redis only.
</note>
[1]: docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/backups-restoring.html
1928 1929 1930 1931 |
# File 'lib/aws-sdk-elasticache/client.rb', line 1928 def create_replication_group(params = {}, = {}) req = build_request(:create_replication_group, 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.
<note markdown=“1”> This operation is valid for Redis only.
</note>
2131 2132 2133 2134 |
# File 'lib/aws-sdk-elasticache/client.rb', line 2131 def create_snapshot(params = {}, = {}) req = build_request(:create_snapshot, params) req.send_request() end |
#decrease_replica_count(params = {}) ⇒ Types::DecreaseReplicaCountResult
Dynamically decreases the number of replics in a Redis (cluster mode disabled) replication group or the number of replica nodes in one or more node groups (shards) of a Redis (cluster mode enabled) replication group. This operation is performed with no cluster down time.
2238 2239 2240 2241 |
# File 'lib/aws-sdk-elasticache/client.rb', line 2238 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 cannot be used to delete a cluster that is the last read replica of a replication group or node group (shard) that has Multi-AZ mode enabled or a cluster from a Redis (cluster mode enabled) replication group.
This operation is not valid for Redis (cluster mode enabled) clusters.
2370 2371 2372 2373 |
# File 'lib/aws-sdk-elasticache/client.rb', line 2370 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.
2407 2408 2409 2410 |
# File 'lib/aws-sdk-elasticache/client.rb', line 2407 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.
<note markdown=“1”> You cannot delete a cache security group if it is associated with any clusters.
</note>
2447 2448 2449 2450 |
# File 'lib/aws-sdk-elasticache/client.rb', line 2447 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.
<note markdown=“1”> You cannot delete a cache subnet group if it is associated with any clusters.
</note>
2486 2487 2488 2489 |
# File 'lib/aws-sdk-elasticache/client.rb', line 2486 def delete_cache_subnet_group(params = {}, = {}) req = build_request(:delete_cache_subnet_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.
<note markdown=“1”> This operation is valid for Redis only.
</note>
2593 2594 2595 2596 |
# File 'lib/aws-sdk-elasticache/client.rb', line 2593 def delete_replication_group(params = {}, = {}) req = build_request(:delete_replication_group, 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.
<note markdown=“1”> This operation is valid for Redis only.
</note>
2703 2704 2705 2706 |
# File 'lib/aws-sdk-elasticache/client.rb', line 2703 def delete_snapshot(params = {}, = {}) req = build_request(:delete_snapshot, 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.
2943 2944 2945 2946 |
# File 'lib/aws-sdk-elasticache/client.rb', line 2943 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.
3194 3195 3196 3197 |
# File 'lib/aws-sdk-elasticache/client.rb', line 3194 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.
3268 3269 3270 3271 |
# File 'lib/aws-sdk-elasticache/client.rb', line 3268 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.
3746 3747 3748 3749 |
# File 'lib/aws-sdk-elasticache/client.rb', line 3746 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.
3813 3814 3815 3816 |
# File 'lib/aws-sdk-elasticache/client.rb', line 3813 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.
3916 3917 3918 3919 |
# File 'lib/aws-sdk-elasticache/client.rb', line 3916 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.
4601 4602 4603 4604 |
# File 'lib/aws-sdk-elasticache/client.rb', line 4601 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.
4782 4783 4784 4785 |
# File 'lib/aws-sdk-elasticache/client.rb', line 4782 def describe_events(params = {}, = {}) req = build_request(:describe_events, 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.
<note markdown=“1”> This operation is valid for Redis only.
</note>
4935 4936 4937 4938 |
# File 'lib/aws-sdk-elasticache/client.rb', line 4935 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.
5115 5116 5117 5118 |
# File 'lib/aws-sdk-elasticache/client.rb', line 5115 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.
5597 5598 5599 5600 |
# File 'lib/aws-sdk-elasticache/client.rb', line 5597 def describe_reserved_cache_nodes_offerings(params = {}, = {}) req = build_request(:describe_reserved_cache_nodes_offerings, 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.
<note markdown=“1”> This operation is valid for Redis only.
</note>
5756 5757 5758 5759 |
# File 'lib/aws-sdk-elasticache/client.rb', line 5756 def describe_snapshots(params = {}, = {}) req = build_request(:describe_snapshots, params) req.send_request() end |
#increase_replica_count(params = {}) ⇒ Types::IncreaseReplicaCountResult
Dynamically increases the number of replics in a Redis (cluster mode disabled) replication group or the number of replica nodes in one or more node groups (shards) of a Redis (cluster mode enabled) replication group. This operation is performed with no cluster down time.
5847 5848 5849 5850 |
# File 'lib/aws-sdk-elasticache/client.rb', line 5847 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 your Redis cluster’s or replication group’s current node type up to.
When you use the ‘ModifyCacheCluster` or `ModifyReplicationGroup` operations to scale up your cluster or replication group, the value of the `CacheNodeType` parameter must be one of the node types returned by this operation.
5935 5936 5937 5938 |
# File 'lib/aws-sdk-elasticache/client.rb', line 5935 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 cost allocation tags currently on the named resource. A ‘cost allocation tag` is a key-value pair where the key is case-sensitive and the value is optional. You can use cost allocation tags to categorize and track your AWS costs.
If the cluster is not in the available state, ‘ListTagsForResource` returns an error.
You can have a maximum of 50 cost allocation tags on an ElastiCache resource. For more information, see [Monitoring Costs with Tags].
[1]: docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Tagging.html
6012 6013 6014 6015 |
# File 'lib/aws-sdk-elasticache/client.rb', line 6012 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.
6414 6415 6416 6417 |
# File 'lib/aws-sdk-elasticache/client.rb', line 6414 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.
6480 6481 6482 6483 |
# File 'lib/aws-sdk-elasticache/client.rb', line 6480 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.
6580 6581 6582 6583 |
# File 'lib/aws-sdk-elasticache/client.rb', line 6580 def modify_cache_subnet_group(params = {}, = {}) req = build_request(:modify_cache_subnet_group, params) req.send_request() end |
#modify_replication_group(params = {}) ⇒ Types::ModifyReplicationGroupResult
Modifies the settings for a replication group.
For Redis (cluster mode enabled) clusters, this operation cannot be used to change a cluster’s node type or engine version. For more information, see:
-
[Scaling for Amazon ElastiCache for Redis—Redis (cluster mode enabled)] in the ElastiCache User Guide
- ModifyReplicationGroupShardConfiguration][2
-
in the ElastiCache API
Reference
<note markdown=“1”> This operation is valid for Redis only.
</note>
[1]: docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/scaling-redis-cluster-mode-enabled.html [2]: docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroupShardConfiguration.html
6897 6898 6899 6900 |
# File 'lib/aws-sdk-elasticache/client.rb', line 6897 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 exisiting shards.
7007 7008 7009 7010 |
# File 'lib/aws-sdk-elasticache/client.rb', line 7007 def modify_replication_group_shard_configuration(params = {}, = {}) req = build_request(:modify_replication_group_shard_configuration, params) req.send_request() end |
#purchase_reserved_cache_nodes_offering(params = {}) ⇒ Types::PurchaseReservedCacheNodesOfferingResult
Allows you to purchase a reserved cache node offering.
7078 7079 7080 7081 |
# File 'lib/aws-sdk-elasticache/client.rb', line 7078 def purchase_reserved_cache_nodes_offering(params = {}, = {}) req = build_request(:purchase_reserved_cache_nodes_offering, 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 and Redis (cluster mode disabled) clusters. Rebooting is not supported on Redis (cluster mode enabled) clusters.
If you make changes to parameters that require a Redis (cluster mode enabled) cluster reboot for the changes to be applied, see [Rebooting a Cluster] for an alternate process.
[1]: docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/Clusters.Rebooting.html
7224 7225 7226 7227 |
# File 'lib/aws-sdk-elasticache/client.rb', line 7224 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.
7310 7311 7312 7313 |
# File 'lib/aws-sdk-elasticache/client.rb', line 7310 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.
7377 7378 7379 7380 |
# File 'lib/aws-sdk-elasticache/client.rb', line 7377 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.
7435 7436 7437 7438 |
# File 'lib/aws-sdk-elasticache/client.rb', line 7435 def revoke_cache_security_group_ingress(params = {}, = {}) req = build_request(:revoke_cache_security_group_ingress, params) req.send_request() end |
#test_failover(params = {}) ⇒ Types::TestFailoverResult
Represents the input of a ‘TestFailover` operation which test automatic failover on a specified node group (called shard in the console) in a replication group (called cluster in the console).
**Note the following**
-
A customer can use this operation to test automatic failover on up to 5 shards (called node groups in the ElastiCache API and AWS 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 Redis (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 AWS 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 master node <primary-node-id> to replica node <node-id> completed`
-
Replication group message: ‘Failover from master node <primary-node-id> to replica node <node-id> completed`
-
Cache cluster message: ‘Recovering cache nodes <node-id>`
-
Cache cluster message: ‘Finished recovery for cache nodes <node-id>`
For more information see:
- Viewing ElastiCache Events][1
-
in the *ElastiCache User Guide*
- DescribeEvents][2
-
in the ElastiCache API Reference
-
Also see, [Testing Multi-AZ with Automatic Failover] in the *ElastiCache User Guide*.
[1]: docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/ECEvents.Viewing.html [2]: docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeEvents.html [3]: docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/AutoFailover.html#auto-failover-test
7554 7555 7556 7557 |
# File 'lib/aws-sdk-elasticache/client.rb', line 7554 def test_failover(params = {}, = {}) req = build_request(:test_failover, 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.waiter_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 |
7667 7668 7669 7670 7671 |
# File 'lib/aws-sdk-elasticache/client.rb', line 7667 def wait_until(waiter_name, params = {}, = {}) w = waiter(waiter_name, ) yield(w.waiter) if block_given? # deprecated w.wait(params) end |
#waiter_names ⇒ Object
This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.
7675 7676 7677 |
# File 'lib/aws-sdk-elasticache/client.rb', line 7675 def waiter_names waiters.keys end |