Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
Paws::ElastiCache(3)  User Contributed Perl Documentation Paws::ElastiCache(3)

NAME
       Paws::ElastiCache - Perl	Interface to AWS Amazon	ElastiCache

SYNOPSIS
	 use Paws;

	 my $obj = Paws->service('ElastiCache')->new;
	 my $res = $obj->Method(
	   Arg1	=> $val1,
	   Arg2	=> [ 'V1', 'V2'	],
	   # if	Arg3 is	an object, the HashRef will be used as arguments to the	constructor
	   # of	the arguments type
	   Arg3	=> { Att1 => 'Val1' },
	   # if	Arg4 is	an array of objects, the HashRefs will be passed as arguments to
	   # the constructor of	the arguments type
	   Arg4	=> [ { Att1 => 'Val1'  }, { Att1 => 'Val2' } ],
	 );

DESCRIPTION
       Amazon ElastiCache

       Amazon ElastiCache is a web service that	makes it easier	to set up,
       operate,	and scale a distributed	cache in the cloud.

       With ElastiCache, customers gain	all of the benefits of a high-
       performance, in-memory cache with far less of the administrative	burden
       of launching and	managing a distributed cache. The service makes	setup,
       scaling,	and cluster failure handling much simpler than in a self-
       managed cache deployment.

       In addition, through integration	with Amazon CloudWatch,	customers get
       enhanced	visibility into	the key	performance statistics associated with
       their cache and can receive alarms if a part of their cache runs	hot.

METHODS
   AddTagsToResource(ResourceName => Str, Tags =>
       ArrayRef[Paws::ElastiCache::Tag])
       Each argument is	described in detail in:
       Paws::ElastiCache::AddTagsToResource

       Returns:	a Paws::ElastiCache::TagListMessage instance

       The AddTagsToResource action adds up to 10 cost allocation tags to the
       named resource. A cost allocation tag is	a key-value pair where the key
       and value are case-sensitive. Cost allocation tags can be used 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.

   AuthorizeCacheSecurityGroupIngress(CacheSecurityGroupName =>	Str,
       EC2SecurityGroupName => Str, EC2SecurityGroupOwnerId => Str)
       Each argument is	described in detail in:
       Paws::ElastiCache::AuthorizeCacheSecurityGroupIngress

       Returns:	a Paws::ElastiCache::AuthorizeCacheSecurityGroupIngressResult
       instance

       The AuthorizeCacheSecurityGroupIngress action 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.

       You cannot authorize ingress from an Amazon EC2 security	group in one
       region to an ElastiCache	cluster	in another region.

   CopySnapshot(SourceSnapshotName => Str, TargetSnapshotName => Str)
       Each argument is	described in detail in:
       Paws::ElastiCache::CopySnapshot

       Returns:	a Paws::ElastiCache::CopySnapshotResult	instance

       The CopySnapshot	action makes a copy of an existing snapshot.

   CreateCacheCluster(CacheClusterId =>	Str, [AutoMinorVersionUpgrade => Bool,
       AZMode => Str, CacheNodeType => Str, CacheParameterGroupName => Str,
       CacheSecurityGroupNames => ArrayRef[Str], CacheSubnetGroupName => Str,
       Engine => Str, EngineVersion => Str, NotificationTopicArn => Str,
       NumCacheNodes =>	Int, Port => Int, PreferredAvailabilityZone => Str,
       PreferredAvailabilityZones => ArrayRef[Str], PreferredMaintenanceWindow
       => Str, ReplicationGroupId => Str, SecurityGroupIds => ArrayRef[Str],
       SnapshotArns => ArrayRef[Str], SnapshotName => Str,
       SnapshotRetentionLimit => Int, SnapshotWindow =>	Str, Tags =>
       ArrayRef[Paws::ElastiCache::Tag]])
       Each argument is	described in detail in:
       Paws::ElastiCache::CreateCacheCluster

       Returns:	a Paws::ElastiCache::CreateCacheClusterResult instance

       The CreateCacheCluster action creates a cache cluster. All nodes	in the
       cache cluster run the same protocol-compliant cache engine software,
       either Memcached	or Redis.

   CreateCacheParameterGroup(CacheParameterGroupFamily => Str,
       CacheParameterGroupName => Str, Description => Str)
       Each argument is	described in detail in:
       Paws::ElastiCache::CreateCacheParameterGroup

       Returns:	a Paws::ElastiCache::CreateCacheParameterGroupResult instance

       The CreateCacheParameterGroup action creates a new cache	parameter
       group. A	cache parameter	group is a collection of parameters that you
       apply to	all of the nodes in a cache cluster.

   CreateCacheSecurityGroup(CacheSecurityGroupName => Str, Description => Str)
       Each argument is	described in detail in:
       Paws::ElastiCache::CreateCacheSecurityGroup

       Returns:	a Paws::ElastiCache::CreateCacheSecurityGroupResult instance

       The CreateCacheSecurityGroup action creates a new cache security	group.
       Use a cache security group to control access to one or more cache
       clusters.

       Cache security groups are only used when	you are	creating a cache
       cluster outside of an Amazon Virtual Private Cloud (VPC). If you	are
       creating	a cache	cluster	inside of a VPC, use a cache subnet group
       instead.	For more information, see CreateCacheSubnetGroup.

   CreateCacheSubnetGroup(CacheSubnetGroupDescription => Str,
       CacheSubnetGroupName => Str, SubnetIds => ArrayRef[Str])
       Each argument is	described in detail in:
       Paws::ElastiCache::CreateCacheSubnetGroup

       Returns:	a Paws::ElastiCache::CreateCacheSubnetGroupResult instance

       The CreateCacheSubnetGroup action creates a new cache subnet group.

       Use this	parameter only when you	are creating a cluster in an Amazon
       Virtual Private Cloud (VPC).

   CreateReplicationGroup(ReplicationGroupDescription => Str,
       ReplicationGroupId => Str, [AutomaticFailoverEnabled => Bool,
       AutoMinorVersionUpgrade => Bool,	CacheNodeType => Str,
       CacheParameterGroupName => Str, CacheSecurityGroupNames =>
       ArrayRef[Str], CacheSubnetGroupName => Str, Engine => Str,
       EngineVersion =>	Str, NotificationTopicArn => Str, NumCacheClusters =>
       Int, Port => Int, PreferredCacheClusterAZs => ArrayRef[Str],
       PreferredMaintenanceWindow => Str, PrimaryClusterId => Str,
       SecurityGroupIds	=> ArrayRef[Str], SnapshotArns => ArrayRef[Str],
       SnapshotName => Str, SnapshotRetentionLimit => Int, SnapshotWindow =>
       Str, Tags => ArrayRef[Paws::ElastiCache::Tag]])
       Each argument is	described in detail in:
       Paws::ElastiCache::CreateReplicationGroup

       Returns:	a Paws::ElastiCache::CreateReplicationGroupResult instance

       The CreateReplicationGroup action creates a replication group. A
       replication group is a collection of cache clusters, where one of the
       cache clusters is a read/write primary and the others are read-only
       replicas. Writes	to the primary are automatically propagated to the
       replicas.

       When you	create a replication group, you	must specify an	existing cache
       cluster that is in the primary role. When the replication group has
       been successfully created, you can add one or more read replica
       replicas	to it, up to a total of	five read replicas.

       Note: This action is valid only for Redis.

   CreateSnapshot(CacheClusterId => Str, SnapshotName => Str)
       Each argument is	described in detail in:
       Paws::ElastiCache::CreateSnapshot

       Returns:	a Paws::ElastiCache::CreateSnapshotResult instance

       The CreateSnapshot action creates a copy	of an entire cache cluster at
       a specific moment in time.

   DeleteCacheCluster(CacheClusterId =>	Str, [FinalSnapshotIdentifier => Str])
       Each argument is	described in detail in:
       Paws::ElastiCache::DeleteCacheCluster

       Returns:	a Paws::ElastiCache::DeleteCacheClusterResult instance

       The DeleteCacheCluster action deletes a previously provisioned cache
       cluster.	DeleteCacheCluster deletes all associated cache	nodes, node
       endpoints and the cache cluster itself. When you	receive	a successful
       response	from this action, Amazon ElastiCache immediately begins
       deleting	the cache cluster; you cannot cancel or	revert this action.

       This API	cannot be used to delete a cache cluster that is the last read
       replica of a replication	group that has Multi-AZ	mode enabled.

   DeleteCacheParameterGroup(CacheParameterGroupName =>	Str)
       Each argument is	described in detail in:
       Paws::ElastiCache::DeleteCacheParameterGroup

       Returns:	nothing

       The DeleteCacheParameterGroup action deletes the	specified cache
       parameter group.	You cannot delete a cache parameter group if it	is
       associated with any cache clusters.

   DeleteCacheSecurityGroup(CacheSecurityGroupName => Str)
       Each argument is	described in detail in:
       Paws::ElastiCache::DeleteCacheSecurityGroup

       Returns:	nothing

       The DeleteCacheSecurityGroup action deletes a cache security group.

       You cannot delete a cache security group	if it is associated with any
       cache clusters.

   DeleteCacheSubnetGroup(CacheSubnetGroupName => Str)
       Each argument is	described in detail in:
       Paws::ElastiCache::DeleteCacheSubnetGroup

       Returns:	nothing

       The DeleteCacheSubnetGroup action deletes a cache subnet	group.

       You cannot delete a cache subnet	group if it is associated with any
       cache clusters.

   DeleteReplicationGroup(ReplicationGroupId =>	Str, [FinalSnapshotIdentifier
       => Str, RetainPrimaryCluster => Bool])
       Each argument is	described in detail in:
       Paws::ElastiCache::DeleteReplicationGroup

       Returns:	a Paws::ElastiCache::DeleteReplicationGroupResult instance

       The DeleteReplicationGroup action deletes an existing replication
       group. By default, this action deletes the entire replication group,
       including the primary cluster and all of	the read replicas. You can
       optionally delete only the read replicas, while retaining the primary
       cluster.

       When you	receive	a successful response from this	action,	Amazon
       ElastiCache immediately begins deleting the selected resources; you
       cannot cancel or	revert this action.

   DeleteSnapshot(SnapshotName => Str)
       Each argument is	described in detail in:
       Paws::ElastiCache::DeleteSnapshot

       Returns:	a Paws::ElastiCache::DeleteSnapshotResult instance

       The DeleteSnapshot action deletes an existing snapshot. When you
       receive a successful response from this action, ElastiCache immediately
       begins deleting the snapshot; you cannot	cancel or revert this action.

   DescribeCacheClusters([CacheClusterId => Str, Marker	=> Str,	MaxRecords =>
       Int, ShowCacheNodeInfo => Bool])
       Each argument is	described in detail in:
       Paws::ElastiCache::DescribeCacheClusters

       Returns:	a Paws::ElastiCache::CacheClusterMessage instance

       The DescribeCacheClusters action	returns	information about all
       provisioned cache clusters if no	cache cluster identifier is specified,
       or about	a specific cache cluster if a cache cluster identifier is
       supplied.

       By default, abbreviated information about the cache clusters(s) will be
       returned. You can use the optional ShowDetails flag to retrieve
       detailed	information about the cache nodes associated with the cache
       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
       will be displayed until all of the nodes	are successfully provisioned.

       If the cluster is in the	DELETING state,	only cluster level information
       will be displayed.

       If cache	nodes are currently being added	to the cache cluster, node
       endpoint	information and	creation time for the additional nodes will
       not be displayed	until they are completely provisioned. When the	cache
       cluster state is	available, the cluster is ready	for use.

       If cache	nodes are currently being removed from the cache cluster, no
       endpoint	information for	the removed nodes is displayed.

   DescribeCacheEngineVersions([CacheParameterGroupFamily => Str, DefaultOnly
       => Bool,	Engine => Str, EngineVersion =>	Str, Marker => Str, MaxRecords
       => Int])
       Each argument is	described in detail in:
       Paws::ElastiCache::DescribeCacheEngineVersions

       Returns:	a Paws::ElastiCache::CacheEngineVersionMessage instance

       The DescribeCacheEngineVersions action returns a	list of	the available
       cache engines and their versions.

   DescribeCacheParameterGroups([CacheParameterGroupName => Str, Marker	=>
       Str, MaxRecords => Int])
       Each argument is	described in detail in:
       Paws::ElastiCache::DescribeCacheParameterGroups

       Returns:	a Paws::ElastiCache::CacheParameterGroupsMessage instance

       The DescribeCacheParameterGroups	action returns a list of cache
       parameter group descriptions. If	a cache	parameter group	name is
       specified, the list will	contain	only the descriptions for that group.

   DescribeCacheParameters(CacheParameterGroupName => Str, [Marker => Str,
       MaxRecords => Int, Source => Str])
       Each argument is	described in detail in:
       Paws::ElastiCache::DescribeCacheParameters

       Returns:	a Paws::ElastiCache::CacheParameterGroupDetails	instance

       The DescribeCacheParameters action returns the detailed parameter list
       for a particular	cache parameter	group.

   DescribeCacheSecurityGroups([CacheSecurityGroupName => Str, Marker => Str,
       MaxRecords => Int])
       Each argument is	described in detail in:
       Paws::ElastiCache::DescribeCacheSecurityGroups

       Returns:	a Paws::ElastiCache::CacheSecurityGroupMessage instance

       The DescribeCacheSecurityGroups action returns a	list of	cache security
       group descriptions. If a	cache security group name is specified,	the
       list will contain only the description of that group.

   DescribeCacheSubnetGroups([CacheSubnetGroupName => Str, Marker => Str,
       MaxRecords => Int])
       Each argument is	described in detail in:
       Paws::ElastiCache::DescribeCacheSubnetGroups

       Returns:	a Paws::ElastiCache::CacheSubnetGroupMessage instance

       The DescribeCacheSubnetGroups action returns a list of cache subnet
       group descriptions. If a	subnet group name is specified,	the list will
       contain only the	description of that group.

   DescribeEngineDefaultParameters(CacheParameterGroupFamily =>	Str, [Marker
       => Str, MaxRecords => Int])
       Each argument is	described in detail in:
       Paws::ElastiCache::DescribeEngineDefaultParameters

       Returns:	a Paws::ElastiCache::DescribeEngineDefaultParametersResult
       instance

       The DescribeEngineDefaultParameters action returns the default engine
       and system parameter information	for the	specified cache	engine.

   DescribeEvents([Duration => Int, EndTime => Str, Marker => Str, MaxRecords
       => Int, SourceIdentifier	=> Str,	SourceType => Str, StartTime =>	Str])
       Each argument is	described in detail in:
       Paws::ElastiCache::DescribeEvents

       Returns:	a Paws::ElastiCache::EventsMessage instance

       The DescribeEvents action returns events	related	to cache clusters,
       cache security groups, and cache	parameter groups. You can obtain
       events specific to a particular cache 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.

   DescribeReplicationGroups([Marker =>	Str, MaxRecords	=> Int,
       ReplicationGroupId => Str])
       Each argument is	described in detail in:
       Paws::ElastiCache::DescribeReplicationGroups

       Returns:	a Paws::ElastiCache::ReplicationGroupMessage instance

       The DescribeReplicationGroups action returns information	about a
       particular replication group. If	no identifier is specified,
       DescribeReplicationGroups returns information about all replication
       groups.

   DescribeReservedCacheNodes([CacheNodeType =>	Str, Duration => Str, Marker
       => Str, MaxRecords => Int, OfferingType => Str, ProductDescription =>
       Str, ReservedCacheNodeId	=> Str,	ReservedCacheNodesOfferingId =>	Str])
       Each argument is	described in detail in:
       Paws::ElastiCache::DescribeReservedCacheNodes

       Returns:	a Paws::ElastiCache::ReservedCacheNodeMessage instance

       The DescribeReservedCacheNodes action returns information about
       reserved	cache nodes for	this account, or about a specified reserved
       cache node.

   DescribeReservedCacheNodesOfferings([CacheNodeType => Str, Duration => Str,
       Marker => Str, MaxRecords => Int, OfferingType => Str,
       ProductDescription => Str, ReservedCacheNodesOfferingId => Str])
       Each argument is	described in detail in:
       Paws::ElastiCache::DescribeReservedCacheNodesOfferings

       Returns:	a Paws::ElastiCache::ReservedCacheNodesOfferingMessage
       instance

       The DescribeReservedCacheNodesOfferings action lists available reserved
       cache node offerings.

   DescribeSnapshots([CacheClusterId =>	Str, Marker => Str, MaxRecords => Int,
       SnapshotName => Str, SnapshotSource => Str])
       Each argument is	described in detail in:
       Paws::ElastiCache::DescribeSnapshots

       Returns:	a Paws::ElastiCache::DescribeSnapshotsListMessage instance

       The DescribeSnapshots action returns information	about cache cluster
       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.

   ListTagsForResource(ResourceName => Str)
       Each argument is	described in detail in:
       Paws::ElastiCache::ListTagsForResource

       Returns:	a Paws::ElastiCache::TagListMessage instance

       The ListTagsForResource action 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. Cost allocation
       tags can	be used	to categorize and track	your AWS costs.

       You can have a maximum of 10 cost allocation tags on an ElastiCache
       resource. For more information, see Using Cost Allocation Tags in
       Amazon ElastiCache.

   ModifyCacheCluster(CacheClusterId =>	Str, [ApplyImmediately => Bool,
       AutoMinorVersionUpgrade => Bool,	AZMode => Str, CacheNodeIdsToRemove =>
       ArrayRef[Str], CacheParameterGroupName => Str, CacheSecurityGroupNames
       => ArrayRef[Str], EngineVersion => Str, NewAvailabilityZones =>
       ArrayRef[Str], NotificationTopicArn => Str, NotificationTopicStatus =>
       Str, NumCacheNodes => Int, PreferredMaintenanceWindow =>	Str,
       SecurityGroupIds	=> ArrayRef[Str], SnapshotRetentionLimit => Int,
       SnapshotWindow => Str])
       Each argument is	described in detail in:
       Paws::ElastiCache::ModifyCacheCluster

       Returns:	a Paws::ElastiCache::ModifyCacheClusterResult instance

       The ModifyCacheCluster action modifies the settings for a cache
       cluster.	You can	use this action	to change one or more cluster
       configuration parameters	by specifying the parameters and the new
       values.

   ModifyCacheParameterGroup(CacheParameterGroupName =>	Str,
       ParameterNameValues => ArrayRef[Paws::ElastiCache::ParameterNameValue])
       Each argument is	described in detail in:
       Paws::ElastiCache::ModifyCacheParameterGroup

       Returns:	a Paws::ElastiCache::CacheParameterGroupNameMessage instance

       The ModifyCacheParameterGroup action 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.

   ModifyCacheSubnetGroup(CacheSubnetGroupName => Str,
       [CacheSubnetGroupDescription => Str, SubnetIds => ArrayRef[Str]])
       Each argument is	described in detail in:
       Paws::ElastiCache::ModifyCacheSubnetGroup

       Returns:	a Paws::ElastiCache::ModifyCacheSubnetGroupResult instance

       The ModifyCacheSubnetGroup action modifies an existing cache subnet
       group.

   ModifyReplicationGroup(ReplicationGroupId =>	Str, [ApplyImmediately =>
       Bool, AutomaticFailoverEnabled => Bool, AutoMinorVersionUpgrade =>
       Bool, CacheParameterGroupName =>	Str, CacheSecurityGroupNames =>
       ArrayRef[Str], EngineVersion => Str, NotificationTopicArn => Str,
       NotificationTopicStatus => Str, PreferredMaintenanceWindow => Str,
       PrimaryClusterId	=> Str,	ReplicationGroupDescription => Str,
       SecurityGroupIds	=> ArrayRef[Str], SnapshotRetentionLimit => Int,
       SnapshottingClusterId =>	Str, SnapshotWindow => Str])
       Each argument is	described in detail in:
       Paws::ElastiCache::ModifyReplicationGroup

       Returns:	a Paws::ElastiCache::ModifyReplicationGroupResult instance

       The ModifyReplicationGroup action modifies the settings for a
       replication group.

   PurchaseReservedCacheNodesOffering(ReservedCacheNodesOfferingId => Str,
       [CacheNodeCount => Int, ReservedCacheNodeId => Str])
       Each argument is	described in detail in:
       Paws::ElastiCache::PurchaseReservedCacheNodesOffering

       Returns:	a Paws::ElastiCache::PurchaseReservedCacheNodesOfferingResult
       instance

       The PurchaseReservedCacheNodesOffering action allows you	to purchase a
       reserved	cache node offering.

   RebootCacheCluster(CacheClusterId =>	Str, CacheNodeIdsToReboot =>
       ArrayRef[Str])
       Each argument is	described in detail in:
       Paws::ElastiCache::RebootCacheCluster

       Returns:	a Paws::ElastiCache::RebootCacheClusterResult instance

       The RebootCacheCluster action reboots some, or all, of the cache	nodes
       within a	provisioned cache cluster. This	API will apply any modified
       cache parameter groups to the cache cluster. The	reboot action takes
       place as	soon as	possible, and results in a momentary outage to the
       cache cluster. During the reboot, the cache 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 cache cluster event is created.

   RemoveTagsFromResource(ResourceName => Str, TagKeys => ArrayRef[Str])
       Each argument is	described in detail in:
       Paws::ElastiCache::RemoveTagsFromResource

       Returns:	a Paws::ElastiCache::TagListMessage instance

       The RemoveTagsFromResource action removes the tags identified by	the
       "TagKeys" list from the named resource.

   ResetCacheParameterGroup(CacheParameterGroupName => Str,
       ParameterNameValues => ArrayRef[Paws::ElastiCache::ParameterNameValue],
       [ResetAllParameters => Bool])
       Each argument is	described in detail in:
       Paws::ElastiCache::ResetCacheParameterGroup

       Returns:	a Paws::ElastiCache::CacheParameterGroupNameMessage instance

       The ResetCacheParameterGroup action 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.

   RevokeCacheSecurityGroupIngress(CacheSecurityGroupName => Str,
       EC2SecurityGroupName => Str, EC2SecurityGroupOwnerId => Str)
       Each argument is	described in detail in:
       Paws::ElastiCache::RevokeCacheSecurityGroupIngress

       Returns:	a Paws::ElastiCache::RevokeCacheSecurityGroupIngressResult
       instance

       The RevokeCacheSecurityGroupIngress action revokes ingress from a cache
       security	group. Use this	action to disallow access from an Amazon EC2
       security	group that had been previously authorized.

SEE ALSO
       This service class forms	part of	Paws

BUGS and CONTRIBUTIONS
       The source code is located here:	https://github.com/pplu/aws-sdk-perl

       Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues

perl v5.24.1			  2015-08-06		  Paws::ElastiCache(3)

NAME | SYNOPSIS | DESCRIPTION | METHODS | SEE ALSO | BUGS and CONTRIBUTIONS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=Paws::ElastiCache&sektion=3&manpath=FreeBSD+12.1-RELEASE+and+Ports>

home | help